Partie 1 · Des mots aux nombres

Découper le texte

Un réseau ne calcule que sur des nombres. Le jeu du jour, MorFITT, contient 3 624 résumés médicaux en français (1 514 pour l'entraînement, 1 022 pour la validation, 1 088 pour le test), chacun classé dans une ou plusieurs des 12 spécialités. Première étape : transformer un texte en suite de numéros.

La règle du jour : 1) tout en minuscules ; 2) on coupe à chaque caractère qui n'est ni une lettre ni un chiffre (espace, ponctuation, apostrophe). Chaque morceau est un token. Un résumé compte en moyenne 241 tokens (de 30 à 1 410). Essaie la règle ci-dessous.

Les tokens connus reçoivent leur numéro (bleu) ; un token absent du mini-vocabulaire reçoit 1, <inconnu> (rouge).

Le vocabulaire associe un numéro à chaque token. Deux numéros sont réservés à des tokens spéciaux : <rempl> = 0 (le remplissage, on y vient) et <inconnu> = 1. Le vocabulaire se construit sur l'entraînement seul : 22 702 tokens différents + 2 spéciaux = 22 704.

Un token jamais vu à l'entraînement devient <inconnu>. Exemple : « expectoration » apparaît 13 fois dans le test et jamais à l'entraînement. Sur tout le test : 12 679 tokens inconnus sur 260 788, soit 4,86 %. Le réseau sait alors qu'il y avait un mot, pas lequel.

À toi de coder

Écrire decouper()

Tu vas enchaîner deux gestes dans l'ordre : mettre en minuscules, puis extraire les suites de lettres et de chiffres. Le minuscule d'abord, pour que « Fièvre » et « fièvre » soient un seul token et ne gaspillent pas deux numéros. L'expression régulière \w+ désigne une suite de lettres/chiffres : tout le reste (espace, point, apostrophe) devient une coupure.

Complète decouper(texte), qui renvoie la liste des tokens.

def decouper(texte):
    # 1) minuscules   2) suites de lettres et de chiffres
    return re.findall(r"___", texte.___())

Ctrl/⌘+Entrée

À toi de coder

Numéroter, avec <inconnu>

Maintenant on passe des tokens aux numéros avec un dictionnaire. Piège : un token absent du vocabulaire ferait planter vocab[t]. On utilise donc vocab.get(t, valeur_par_defaut), et la valeur par défaut est le numéro de <inconnu>, pas celui de <rempl> : 0 est réservé aux remplissages, et les confondre brouillerait le masque plus tard.

Complète numeroter(texte).

vocab = {"<rempl>": 0, "<inconnu>": 1, "fièvre": 2, "sans": 3, "toux": 4}

def decouper(texte):
    return re.findall(r"\w+", texte.lower())

def numeroter(texte):
    # un numéro par token ; token absent -> numéro de <inconnu>
    return [vocab.get(t, ___) for t in decouper(texte)]

Ctrl/⌘+Entrée

Les sous-mots. Découper en mots laisse des inconnus ; découper en caractères donne des suites 6,2 fois plus longues, faites de lettres sans sens. Entre les deux : apprendre des morceaux de mots fréquents par la méthode BPE (byte pair encoding) : 1) partir des caractères ; 2) compter les paires de symboles voisins ; 3) fusionner la plus fréquente en un seul symbole, puis recompter ; 4) s'arrêter à une taille de vocabulaire fixée (32 005 morceaux pour DrBERT).

Corpus de la démo : chien (110 apparitions), chiens (377), chat (46), chats (151). Une paire compte autant de fois que son mot.

Clique sur « Fusion suivante » : la paire la plus fréquente devient un symbole, puis on recompte. Observe « chiots », mot jamais vu, qui se découpe sans aucun inconnu.

À toi de coder

Compter les paires du BPE

Le cœur du BPE est de compter les paires voisines. Pour chaque mot, tu parcours ses symboles deux par deux (zip(suite, suite[1:]) associe chaque symbole à son suivant) et tu ajoutes le nombre d'apparitions du mot (pas 1) : « ch » vaut 110 + 377 + 46 + 151 = 684. Ensuite, la fusion change les symboles, donc il faut recompter sur le nouveau corpus pour trouver la fusion suivante.

Complète compter_paires ; fusionner est fourni.

mots = {"chien": 110, "chiens": 377, "chat": 46, "chats": 151}
symboles = {mot: list(mot) for mot in mots}

def compter_paires(symboles):
    comptes = Counter()
    for mot, suite in symboles.items():
        for a, b in zip(suite, ___):     # paires de symboles voisins
            comptes[(a, b)] += ___       # autant que le mot apparaît
    return comptes

def fusionner(symboles, a, b):
    resultat = {}
    for mot, suite in symboles.items():
        nouvelle, i = [], 0
        while i < len(suite):
            if i + 1 < len(suite) and suite[i] == a and suite[i + 1] == b:
                nouvelle.append(a + b); i += 2
            else:
                nouvelle.append(suite[i]); i += 1
        resultat[mot] = nouvelle
    return resultat

paire, compte = compter_paires(symboles).most_common(1)[0]
symboles_1 = fusionner(symboles, *paire)
paire_2, compte_2 = compter_paires(___).most_common(1)[0]   # on recompte

Ctrl/⌘+Entrée

Former un paquet. Le réseau reçoit plusieurs résumés à la fois, rangés en tableau : une ligne par résumé, une colonne par position. Or les résumés n'ont pas la même longueur. On complète donc chaque suite avec le token <rempl> (0) jusqu'à la longueur de la suite la plus longue de ce paquet. Le masque de remplissage a la même forme : 1 pour un vrai token, 0 pour un remplissage. Il dira aux calculs suivants quoi ignorer. Dans le notebook, les résumés sont coupés à 256 tokens (plafond).

Change les textes et le plafond : la longueur du paquet suit le plus long résumé (coupé au plafond). Orange = remplissage.

À toi de coder

Former un paquet et son masque

Trois étapes à enchaîner : 1) trouver la longueur L du plus long résumé du paquet (pas du jeu entier : sinon on gaspille de la mémoire) ; 2) compléter chaque suite avec des 0 jusqu'à L ; 3) construire le masque avec la même forme, 1 sur les vrais tokens, 0 sur les remplissages. Le masque doit être déduit des longueurs d'origine, pas du contenu : un vrai token ne vaut jamais 0 ici, mais c'est la longueur qui fait foi.

def former_paquet(suites):
    L = ___(len(s) for s in suites)             # le plus long de CE paquet
    paquet = [s + [0] * (L - len(s)) for s in suites]
    masque = [[1] * len(s) + [___] * (L - len(s)) for s in suites]
    return paquet, masque

paquet, masque = former_paquet([[4, 3, 2], [2]])

Ctrl/⌘+Entrée