Aperçu de la classification de texte

Deep Learning pour le texte avec PyTorch

Shubham Jain

Instructor

Définition de la classification des textes

"- Attribuer des étiquettes au texte

Donner du sens aux mots et aux phrases

Types de classification en machine learning {{6}}"

"- Organise et structure les données non structurées

Applications :
- Analyse du sentiment client dans les avis
- Détection du spam dans les e-mails
- Étiquetage des articles de presse avec des sujets pertinents
Types : binaire, multi-classes, multi-étiquettes {{6}}"

Classification binaire

"- Tri en deux catégories

Exemple : détection de courriers indésirables
Les e-mails peuvent être classés comme 'indésirable' ou 'non indésirable' {{2}}"

" Classification binaire {{2}}"

¹ https://storage.googleapis.com/gweb-cloudblog-publish/images/image4_v2LFcq0.max-1200x1200.png

Classification multicatégorie

" Classification des actualités {{2}}"

"- Classement dans plusieurs catégories

Exemple : les articles de presse peuvent être classés dans différentes catégories comme
1. Politique
2. Sport
3. Technologie {{5}}"

Classification multi-étiquette

"- Chaque texte peut se voir attribuer plusieurs étiquettes

Exemple : Les livres peuvent appartenir à plusieurs genres
- Action
- Aventure
- Fantastique {{4}}"

Que sont les embeddings de mots

" Pipeline d'intégration de mots

Exemple d'intégration de mots {{3}}"

"- Les techniques d'encodage précédentes constituent une bonne première étape

- Souvent, on crée trop de caractéristiques et on ne peut pas identifier les mots similaires

Les plongements de mots associent les mots à des vecteurs numériques
Exemple de relation sémantique :
- Roi et reine
- Homme et femme {{4}}"

Correspondance mot-index

"- Exemple :

\"Roi\" -> 1
\"Reine\" -> 2
- Compact et efficace sur le plan computationnel
- Suit la tokenisation dans le pipeline {{3}}"

Représentations vectorielles de mots dans PyTorch

"- torch.nn.Embedding :

Crée des vecteurs de mots à partir des index

Entrée : Indexes for ['The', 'cat', 'sat', 'on', 'the', 'mat']

out Embedding for 'the': tensor([-0.4689, 0.3164, -0.2971, -0.1291, 0.4064]) Embedding for 'cat': tensor([-0.0978, -0.4764, 0.0476, 0.1044, -0.3976]) Embedding for 'sat': tensor([ 0.2731, 0.4431, 0.1275, 0.1434, -0.4721]){{4}}"

Utilisation de torch.nn.Embedding

"`py import torch from torch import nn


----CODE_GLUE----
```py
words = [\"The\", \"cat\", \"sat\", \"on\", \"the\", \"mat\"]
word_to_idx = {word: i for i, word in enumerate(words)}

inputs = torch.LongTensor([word_to_idx[w] for w in words])

embedding = nn.Embedding(num_embeddings=len(words), embedding_dim=10)

output = embedding(inputs)

print(output)

out tensor([[ 1.0624, 0.6792, 0.0459, ... -1.0828, -0.4475, 0.4868], ... [1.5766, 0.0106, 0.1161, ...,, -0.0859, 1.3160, 1.3621]){{6}}"

Utiliser des embeddings dans le pipeline

"`python def preprocess_sentences(text):

Tokenization

Stemming

...


----CODE_GLUE----
```python
  # Word to index mapping

----CODE_GLUE---- `python class TextDataset(Dataset): def init(self, encoded_sentences): self.data = encoded_sentences

def __len__(self):
    return len(self.data)

def __getitem__(self, index):
    return self.data[index]

"`python def text_processing_pipeline(text): tokens = preprocess_sentences(text) dataset = TextDataset(tokens) dataloader = DataLoader(dataset, batch_size=2, shuffle=True) return dataloader, vectorizer


----CODE_GLUE----
```python

text = \"Votre texte d'exemple ici.\"
dataloader, vectorizer = text_processing_pipeline(text)

----CODE_GLUE---- `python embedding = nn.Embedding(num_embeddings=10, embedding_dim=50)

for batch in dataloader: output = embedding(batch) print(output) `{{1}}"

Passons à la pratique !

Deep Learning pour le texte avec PyTorch