NNet / Traitement automatique des langues

• Cours: Classification binaire / Séparation linéaire
• TP : Prise en main python et données imdb

• cours: apprentissage / optimisation
• TP : sur numpy, à faire à la maison
• TP : intro pytorch

Neige: la séance du 30/01 est annulée, mais on peut s'avancer en faisant les TPs d'ici la semaine prochaine. Il y a 2 notebooks, le premier est sur numpy et le second sur pytorch. Il est bien de les faire dans cet ordre.

L'objectif important est d'avancer le plus possible dans le TP sur pytorch après avoir maîtrisé le TP sur numpy. Avancer le plus possible les TP pour la semaine prochaine.

Correction partielle du TP sur pytorch qui devrait vous permettre de terminer pour la semaine prochaine:

import torch as th
# set the seed (reproductibility)
torch.manual_seed(1) 
# dimensions of the problem
D_in = 2
D_out= 1
# Use the nn package to define our model and loss function
model = th.nn.Sequential(
    th.nn.Linear(D_in, D_out),
    th.nn.Sigmoid()    
)
loss_fn = th.nn.BCELoss()
learning_rate = 1e-2
optimizer = th.optim.SGD(model.parameters(), lr=learning_rate)

for epoch in range(1000):
    total=th.zeros([])
    for i in range(14):
        prediction = model(x[i])    
        loss = loss_fn(prediction, y[i])
        optimizer.zero_grad()  
        loss.backward()        
        optimizer.step()
        total+=loss
    if epoch%50==0:
        print(epoch,total)

• Cours sur la classification de texte: représentation sous forme de sac d'atributs binaires puis de word embeddings.
• TP : Classification sur ImDB, de la regression logistique au word embeddings.

• Cours sur la classification multi-classe, et la génération de phrase.
• Présentation des projets
• TP: Classification de texte, suite et fin. Il fait faire et finir dans l'ordre les TP3 et 4. Complétement !
• TP complément: Pour celles ou ceux qui aurait en effet tout terminer, l'article suivant propose un modèle simple pour faire de la classification de texte. Il est considéré comme un modèle de base. Lire l'article, et proposer une implémentation, même simplifiée.

• TP : on reprend le TP 4 et il faut faire le TP5 sur les modèles récurrents.

Pour le TP4, voici un début de correction:

class CBOW_classifier(nn.Module):
    """
    A text classifier: 
    - input = a list of word indices 
    - output = probability associated to a binary classification task
    The pooling operation is the sum

    To build it, two args : 
    - vocab_size: the number of words in the vocabulary we want to embed
    - embedding_dim: size of the word vectors
    """
    def __init__(self, vocab_size, embedding_dim):
        super(CBOW_classifier, self).__init__()
        self.embeddings = nn.Embedding(vocab_size, embedding_dim)
        self.linear1 = nn.Linear(embedding_dim, 1)
        self.out = nn.Sigmoid()

    def forward(self, inputs):
        inp = self.embeddings(inputs).sum(dim=0)
        return self.out(self.linear1(inp))

• Travail à rendre, avant la séance: bilan sur la classification de texte: rendre les TP 3,4, et 5. Comme des éléments de corrections existent, l'important est de documenter le code et d'analyser comment les modèles fonctionnent. Ce qui est attendu:
  • classifieur simple, la régression logistique
  • un réseau de neurone réalisant une régression logistique, mais un texte est vu comme un sac de mots et chaque mot est représenté par son embedding. Le modèle est donc une régression logistique branchée sur un sac de word embeddings.
  • Pour ces deux classifieurs, la démarche expérimentale est la même : évaluation à partir d'une partition des données en train/dev/test
  • Format : un notebook avec les résultats
• Travail à rendre, choix du projet

• 7 : 20/03
• 8 : 27/03
• 9 : 3/04
• 10 : 10/04

Les données sont ici pour le téléchargement et leur description est dans cet article.

Lorsque l'on connait:

• une question,
• une réponse d'un étudiant,
• la bonne réponse,

comment prédire la note à donné à la réponse de l'étudiant. Il peut être aussi intéressant d'essayer d'apprendre à générer la réponse.

Les données sont disponibles ici en json. Un exemple d'utilisation de ces données est décrit dans cet article. Mais on peut envisager des choses plus simple:

• juste un classifieur pour assigner plusieurs notes
• expliquer la note pour un classifier plus simple
• …

Corpus des années 90, il est dédié à la compréhension de la parole. Le but est de faire de l'étiquetage de séquence. En entrée, une phrase est une séquence de mots, et le but est de lui associé une séquence d'étiquette, une par mot.

• Show flights from Boston to New York today
• O O O B-dept O B-arr I-arr B-date

Ainsi le mot Show est associé à 'O' pour 'other'; 'Boston' est associé au lieu de départ, 'B-dept' signifie 'début de départ'; 'York' est 'Inside arrival', …

Partant d'un tweet vu comme une séquence de symboles, effectuer une classification binaire (positif/négatif). Les données peuvent se télécharger ici.

Un axe peut être de développer un modèle efficace. Les étapes importantes:

• Exploration puis préparation des données sous forme exploitable
• Filtrage des données éventuel
• Préparation d'une partition : apprentissage, validation, test
• essayer différents modèles

Un autre axe est de partir de cet article en pdf qui parle, entre autre, de comment collecter des données tweeter pour faire de la classification.

Partant d'un mot vue comme une séquence de lettres (les graphèmes), le but est de générer une séquence de phonèmes. Les données nettalk sont décrites ici et disponible ici.

Il y a deux types d'annotation que l'on peut vouloir générer :

• au moins la séquence de phonèmes (c'est le but premier),
• mais également la séquence d'accentuation.

La séquence d'accentuation peut éventuellement aider à prédire les phonèmes. Il existe alors plusieurs pistes à explorer.

Remarque : penser à vérifier si la séquence à générer est toujours de la même longueur que la séquence de graphèmes

L'objectif est pouvoir sélectionner une réponse à une question. Les données viennent du domaine de l'assurance. Les données brutes viennent de ce site.

Une version plus simple peut se télécharger ici

Cette page explique beaucoup de choses (certaines sont peut être soit trop complexes, soit inutiles). Elle cite entre autres des articles décrivant des modèles performants et qui peuvent donner des idées.

Le challenge https://www.kaggle.com/c/quora-question-pairs

https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge,

http://www.fakenewschallenge.org/

https://snap.stanford.edu/data/web-Amazon.html

https://www.kaggle.com/vkrahul/twitter-hate-speech