Nous définissons simplement et précisément la langue des messages

Chez YouScan , nous traitons environ 100 millions de messages par jour, auxquels de nombreuses règles et diverses fonctions intelligentes sont appliquées. Pour leur travail correct, il est nécessaire de déterminer correctement la langue, car toutes les fonctions ne peuvent pas être rendues agnostiques par rapport à la langue. Dans cet article, nous parlerons brièvement de notre étude de ce problème et montrerons une évaluation de la qualité sur un ensemble de données de réseau social. les réseaux.

Aperçu de l'article

1. Problèmes de définition du langage
2. Solutions publiques abordables
   
   • Détecteur de langue compact 2
   • Fasttext
3. Évaluation de la qualité
4. Conclusions

1. Problèmes de définition de la langue

La définition de la langue est un problème assez ancien et beaucoup tentent de le résoudre dans le cadre du multilinguisme de leurs produits. Les approches plus anciennes utilisent des solutions basées sur n-grammes, lorsque le nombre d'occurrences d'un certain n-gramme est pris en compte et sur cette base, la "vitesse" pour chaque langue est calculée, après quoi la langue la plus probable est sélectionnée selon notre modèle. Le principal inconvénient de ces modèles est que le contexte n'est absolument pas pris en compte, par conséquent, la définition d'une langue pour des groupes linguistiques similaires est difficile. Mais en raison de la simplicité des modèles, nous nous retrouvons avec une vitesse de détermination élevée, ce qui économise des ressources pour les systèmes fortement chargés. Une autre option, plus moderne, est une solution sur les réseaux de neurones récurrents. Cette solution est déjà basée non seulement sur des n-grammes, mais prend également en compte le contexte, ce qui devrait donner une augmentation de la qualité du travail.

La complexité de la création de votre propre solution réside dans la collecte de données pour la formation et le processus d'apprentissage lui-même. La solution la plus évidente est de former le modèle aux articles de Wikipédia, car nous connaissons bien la langue et il existe des textes vérifiés de très haute qualité qui sont relativement faciles à compiler. Et pour former votre modèle, vous devez passer beaucoup de temps à assembler l'ensemble de données, à le traiter, puis à choisir la meilleure architecture. Il est fort probable que quelqu'un l'ait déjà fait avant nous. Dans le bloc suivant, nous examinons les solutions existantes.

2. Solutions publiques disponibles

Détecteur de langue compact 2

CLD2 est un modèle probabiliste basé sur l'apprentissage automatique (classificateur naïf baessien) qui peut définir 83 langues différentes pour le texte au format UTF-8 ou html / xml. Pour les langues mixtes, le modèle renvoie les 3 premières langues, où la probabilité est calculée comme un pourcentage approximatif du texte du nombre total d'octets. Si le modèle n'est pas sûr de sa réponse, renvoie la balise "unc".

La précision et l'exhaustivité de ce modèle sont à un assez bon niveau, mais le principal avantage est la vitesse. Les créateurs revendiquent environ 30 ko en 1 ms, sur nos tests du wrapper Python, nous avons reçu de 21 à 26 ko en 1 ms (70 000 à 85 000 messages par seconde, dont la taille moyenne est de 0,8 ko et la médiane est de 0,3 ko).

Cette solution est très simple à utiliser. Vous devez d'abord installer son wrapper python ou utiliser notre docker .

Pour faire une prévision, importez simplement la bibliothèque pycld2 et écrivez une ligne de code supplémentaire:

 import pycld2 as cld2 cld2.detect("Bonjour, Habr!") # (True, # 14, # (('FRENCH', 'fr', 92, 1102.0), # ('Unknown', 'un', 0, 0.0), # ('Unknown', 'un', 0, 0.0))) 

La réponse du détecteur est un tuple à trois éléments:

• la langue est définie ou non;
• nombre de caractères;
• tuple des trois langues les plus probables, où le nom complet vient en premier,
  la seconde est l'abréviation selon les codes ISO 3166, la troisième est le pourcentage de caractères appartenant à cette langue et la quatrième est le nombre d'octets.

Fasttext

FastText est une bibliothèque écrite par Facebook pour un apprentissage et une classification efficaces des textes. Dans le cadre de ce projet, Facebook Research a présenté des intégrations pour 157 langues qui présentent des résultats de pointe pour diverses tâches, ainsi qu'un modèle pour déterminer la langue et d'autres tâches de supervision.

Pour le modèle de définition de langage, ils ont utilisé des données de Wikipedia, Tatoeba et SETimes, et en tant que classifieur, ils ont utilisé leur solution de texte rapide.

Les développeurs de la recherche sur Facebook proposent deux modèles:

• lid.176.bin , qui est légèrement plus rapide et plus précis que le deuxième modèle, mais pèse 128 Mo;
• lid.176.ftz - une version compressée du modèle original.

Pour utiliser ces modèles en python, vous devez d'abord installer le wrapper python pour fasttext . Il peut être difficile de l'installer, vous devez donc suivre attentivement les instructions sur le github ou utiliser notre docker . Il est également nécessaire de télécharger le modèle à partir du lien ci-dessus. Nous utiliserons la version originale dans cet article.

La classification d'un langage à l'aide d'un modèle de Facebook est un peu plus compliquée, pour cela nous avons besoin de trois lignes de code:

 from pyfasttext import FastText model = FastText('../model/lid.176.bin') model.predict_proba(["Bonjour, Habr!"], 3) #[[('fr', 0.7602248429835308), # ('en', 0.05550386696556002), # ('ca', 0.04721488914800802)]] 

Le modèle FastText'a permet de prédire la probabilité pour les n-langues, où par défaut n = 1, mais dans cet exemple nous avons déduit le résultat pour les 3 premières langues. Pour ce modèle, il s'agit déjà de la probabilité générale de prédiction de la langue pour le texte, et non du nombre de caractères appartenant à une langue particulière, comme c'était le cas dans le modèle cld2. La vitesse est également assez élevée - plus de 60 000 messages par seconde.

3. Évaluation de la qualité

Nous évaluerons la qualité des algorithmes en utilisant des données provenant des réseaux sociaux pour un temps aléatoire provenant du système YouScan (environ 500 mille références), par conséquent, l'échantillon aura plus de langues russe et anglaise, 43% et 32%, respectivement, ukrainien, espagnol et portugais - environ 2% de chacune, des langues restantes moins de 1%. Pour la bonne cible, nous prendrons le balisage via google translate, car pour le moment Google est très bon pour gérer non seulement la traduction, mais aussi la définition de la langue des textes. Bien sûr, son balisage n'est pas idéal, mais dans la plupart des cas, il peut être fiable.

Les mesures permettant d'évaluer la qualité des définitions de langage sont l'exactitude, l'exhaustivité et f1. Comptons-les et affichons dans le tableau:

 with open("../data/lang_data.txt", "r") as f: text_l, cld2_l, ft_l, g_l = [], [], [], [] s = '' for i in f: s += i if ' |end\n' in s: text, cld2, ft, g = s.strip().rsplit(" ||| ", 3) text_l.append(text) cld2_l.append(cld2) ft_l.append(ft) g_l.append(g.replace(" |end", "")) s='' data = pd.DataFrame({"text": text_l, "cld2": cld2_l, "ft": ft_l, "google": g_l}) def lang_summary(lang, col): prec = (data.loc[data[col] == lang, "google"] == data.loc[data[col] == lang, col]).mean() rec = (data.loc[data["google"] == lang, "google"] == data.loc[data["google"] == lang, col]).mean() return round(prec, 3), round(rec, 3), round(2*prec*rec / (prec + rec),3) results = {} for approach in ["cld2", "ft"]: results[approach] = {} for l in data["google"].value_counts().index[:20]: results[approach][l] = lang_summary(l, approach) res = pd.DataFrame.from_dict(results) res["cld2_prec"], res["cld2_rec"], res["cld2_f1"] = res["cld2"].apply(lambda x: [x[0], x[1], x[2]]).str res["ft_prec"], res["ft_rec"], res["ft_f1"] = res["ft"].apply(lambda x: [x[0], x[1], x[2]]).str res.drop(columns=["cld2", "ft"], inplace=True) arrays = [['cld2', 'cld2', 'cld2', 'ft', 'ft', 'ft'], ['precision', 'recall', 'f1_score', 'precision', 'recall', 'f1_score']] tuples = list(zip(*arrays)) res.columns = pd.MultiIndex.from_tuples(tuples, names=["approach", "metrics"]) 

Les résultats montrent clairement que l'approche cld2 a une très grande précision dans la détermination de la langue, seulement pour les langues impopulaires, elle tombe en dessous de 90%, et dans 90% des cas, le résultat est meilleur que celui du fasttext. Avec approximativement la même exhaustivité pour les deux approches, f1 est plus rapide à cld2.
La particularité du modèle cld2 est qu'il ne donne une prévision que pour les messages où il est suffisamment confiant, ce qui explique la grande précision. Le modèle fasttext'a donne une réponse pour la plupart des messages, donc la précision est nettement inférieure, mais il est étrange que l'exhaustivité ne soit pas significativement plus élevée, et dans la moitié des cas inférieure. Mais si vous "tordez" le seuil du modèle de texte rapide, vous pouvez améliorer la précision.

4. Conclusions

En général, les deux modèles donnent de bons résultats et peuvent être utilisés pour résoudre le problème de la détermination de la langue dans différents domaines. Leur principal avantage est la grande vitesse, ce qui permet de créer un soi-disant "ensemble" et d'ajouter le prétraitement nécessaire pour améliorer la qualité.

Vous pouvez trouver tout le code pour reproduire des expériences et tester les approches ci-dessus dans notre référentiel .

Vous pouvez également voir les tests de ces solutions dans un autre article , qui compare la précision et la vitesse dans 6 langues d'Europe occidentale.