100 Language Processing Knock-84 (en utilisant des pandas): Création d'une matrice de contexte de mots

Il s'agit de l'enregistrement de la 84e "Création de la matrice de contexte de mots" de Traitement du langage 100 knock 2015. Créez une matrice de 160 milliards d'éléments en 400 000 x 400 000. Généralement, s'il y a 160 milliards d'éléments, cela semble être une taille énorme, mais comme il s'agit d'une matrice clairsemée avec presque 0, même si la matrice est enregistrée sous forme de fichier, elle fait environ 7 Mo. Le paquet scipy qui gère les matrices clairsemées est incroyable.

Lien de référence

Lien Remarques
084.Créer une matrice de contexte de mots.ipynb Lien GitHub du programme de réponse
100 coups de traitement du langage amateur:84 Je vous suis toujours redevable de 100 coups de traitement linguistique
100 langues de traitement knock version 2015(83,84) J'y ai fait référence au chapitre 9.

environnement

type version Contenu
OS Ubuntu18.04.01 LTS Il fonctionne virtuellement
pyenv 1.2.15 J'utilise pyenv car j'utilise parfois plusieurs environnements Python
Python 3.6.9 python3 sur pyenv.6.J'utilise 9
3.7 ou 3.Il n'y a aucune raison profonde de ne pas utiliser la série 8
Les packages sont gérés à l'aide de venv

Dans l'environnement ci-dessus, j'utilise les packages Python supplémentaires suivants. Installez simplement avec pip ordinaire.

type version
pandas 0.25.3
scipy 1.4.1

Tâche

Chapitre 9: Méthode de l'espace vectoriel (I)

enwiki-20150112-400-r10-105752.txt.bz2 Le texte de 105 752 articles est-il échantillonné au hasard au 1/10 des articles composés d'environ 400 mots ou plus parmi les articles de Wikipedia anglais au 12 janvier 2015, compressé au format bzip2. y a-t-il. En utilisant ce texte comme corpus, je souhaite apprendre un vecteur (expression distribuée) qui exprime le sens d'un mot. Dans la première moitié du chapitre 9, le processus d'apprentissage du vecteur de mot est mis en œuvre en le divisant en plusieurs processus en appliquant l'analyse en composantes principales à la matrice de cooccurrence de contexte de mot créée à partir du corpus. Dans la seconde moitié du chapitre 9, le vecteur de mots (300 dimensions) obtenu par apprentissage est utilisé pour calculer la similitude des mots et analyser (analogique).

Notez que si le problème 83 est implémenté de manière obéissante, une grande quantité (environ 7 Go) de stockage principal sera nécessaire. Si vous manquez de mémoire, concevez un processus ou un corpus d'échantillonnage 1/100 enwiki-20150112-400-r100-10576.txt.bz2 Utilisez /nlp100/data/enwiki-20150112-400-r100-10576.txt.bz2).

Cette fois * "Corpus d'échantillonnage 1/100 [enwiki-20150112-400-r100-10576.txt.bz2](http://www.cl.ecei.tohoku.ac.jp/nlp100/data/enwiki-20150112-" 400-r100-10576.txt.bz2) "* est utilisé.

84. Création d'une matrice de contexte de mots

Créez une matrice de contexte de mot $ X $ en utilisant la sortie de> 83. Cependant, chaque élément $ X_ {tc} $ de la matrice $ X $ est défini comme suit.

-Si $ f (t, c) ≥10 $, alors $ X_ {tc} = $ PPMI ($ t $, $ c $) $ = $ max {log $ \ frac {N × f (t, c) } {f (t, ∗) × f (∗, c)} $, 0} -Si $ f (t, c) <10 $, alors $ X_ {tc} = 0 $

Ici, PPMI ($ t $, $ c $) est une statistique appelée information mutuelle ponctuelle positive. Notez que le nombre de lignes et de colonnes de la matrice $ X $ est de l'ordre du million, et il est impossible de mettre tous les éléments de la matrice sur la mémoire principale. Heureusement, la plupart des éléments de la matrice $ X $ sont 0, il vous suffit donc d'écrire les éléments non nuls.

Supplément de problème

Par exemple, supposons que vous ayez créé le fichier suivant pour la phrase "Je suis un garçon" de la même manière que le coup précédent.

I	am
I	a
am	I
am	a
a	am
a	boy
boy	am
boy	a

Contrairement à ce qui précède, créez la matrice suivante en tant qu'image. Dans cet exemple, il s'agit d'une matrice clairsemée car il s'agit de 4 colonnes x 4 lignes, mais cette fois, il s'agit d'environ 400 000 colonnes x 400 000 lignes, il s'agit donc d'une matrice clairsemée dans un état squishy.

I am a boy
I 1 1
am 1 1
a 1 1
boy 1 1

La matrice ci-dessus définit simplement l'élément de la matrice sur 1, mais définissez ici les valeurs suivantes. Concernant PPMI, [Article "Pointwise Mutual Information (PMI)"](https://camberbridge.github.io/2016/07/08/%E8%87%AA%E5%B7 % B1% E7% 9B% B8% E4% BA% 92% E6% 83% 85% E5% A0% B1% E9% 87% 8F-Pointwise-Mutual-Information-PMI-% E3% 81% AB% E3% 81% A4% E3% 81% 84% E3% 81% A6 /) est facile à comprendre.

-Si $ f (t, c) ≥10 $, alors $ X_ {tc} = $ PPMI ($ t $, $ c $) $ = $ max {log $ \ frac {N × f (t, c) } {f (t, ∗) × f (∗, c)} $, 0} -Si $ f (t, c) <10 $, alors $ X_ {tc} = 0 $

Répondre

Programme de réponse [084. Création d'un contexte de mot matrix.ipynb](https://github.com/YoheiFukuhara/nlp100/blob/master/09.%E3%83%99%E3%82%AF%E3%83%88 % E3% 83% AB% E7% A9% BA% E9% 96% 93% E6% B3% 95% 20 (I) / 084.% E5% 8D% 98% E8% AA% 9E% E6% 96% 87 % E8% 84% 88% E8% A1% 8C% E5% 88% 97% E3% 81% AE% E4% BD% 9C% E6% 88% 90.ipynb)

import math

import pandas as pd
from scipy import sparse, io

#Lire le nombre de cooccurrences du mot t et du mot de contexte c et supprimer les combinaisons de nombres de cooccurrences de 9 ou moins
def read_tc():
    group_tc = pd.read_pickle('./083_group_tc.zip')
    return group_tc[group_tc > 9]

group_tc = read_tc()

group_t = pd.read_pickle('./083_group_t.zip')
group_c = pd.read_pickle('./083_group_c.zip')

matrix_x = sparse.lil_matrix((len(group_t), len(group_c)))


for ind ,v in group_tc.iteritems():
    ppmi = max(math.log((68000317 * v) / (group_t[ind[0]] * group_c[ind[1]])), 0)
    matrix_x[group_t.index.get_loc(ind[0]), group_c.index.get_loc(ind[1])] = ppmi

#Vérifier la matrice clairsemée
print('matrix_x Shape:', matrix_x.shape)
print('matrix_x Number of non-zero entries:', matrix_x.nnz)
print('matrix_x Format:', matrix_x.getformat())

io.savemat('084.matrix_x.mat', {'x': matrix_x})

Répondre au commentaire

J'utilise la fonction pandas''read_picklepour lire le fichier enregistré lors du dernier coup. Vous pouvez simplement lire le format zip tel quel. Cependant, le temps de traitement est ajouté par la quantité de décompression (cela prend environ 13 secondes pour toute la fonction). Après avoir lu, je jette des disques avec moins de 10 cooccurrences. Je ne voulais pas garder le fichier entier en mémoire avant qu'il ne soit jeté, j'ai donc créé la fonctionread_tc`.

#Lire le nombre de cooccurrences du mot t et du mot de contexte c et supprimer les combinaisons de nombres de cooccurrences de 9 ou moins
def read_tc():
    group_tc = pd.read_pickle('./083_group_tc.zip')
    return group_tc[group_tc > 9]

Les 2 fichiers restants sont lus tels quels car ils ne sont pas tronqués X fois ou moins.

group_t = pd.read_pickle('./083_group_t.zip')
group_c = pd.read_pickle('./083_group_c.zip')

Ici, nous utilisons scipy pour créer une variable de matrice clairsemée matrix_x. Multipliez le nombre de mots cibles et de mots contextuels. Il existe plusieurs types de gestion des matrices creuses, mais comme l'entrée utilise un format appelé lil, la matrice est créée avec la fonction lil_matrix.

matrix_x = sparse.lil_matrix((len(group_t), len(group_c)))

Ce qui suit est la partie principale de ce coup. Calculez le PPMI et définissez-le sur une matrice creuse. La partie marquée «68000317» définit la valeur obtenue par le coup précédent.

for ind ,v in group_tc.iteritems():
    ppmi = max(math.log((68000317 * v) / (group_t[ind[0]] * group_c[ind[1]])), 0)
    matrix_x[group_t.index.get_loc(ind[0]), group_c.index.get_loc(ind[1])] = ppmi

Développez la formule de calcul PPMI ci-dessus en vous référant à Article "100 Language Processing Knock 2015 Edition Chapter 9 Revisited (1)" Je l'ai essayé avec la formule, mais cela ne s'est pas accéléré, alors je l'ai rejeté (LOG_N a été calculé à l'avance). C'est plutôt lent (est-ce que mon chemin est faux?).

ppmi = max(LOG_N + math.log(v) - math.log ( group_t[ind[0]] ) - math.log( group_c[ind[1]] ), 0)

Vérifiez la matrice creuse créée.

print('matrix_x Shape:', matrix_x.shape)
print('matrix_x Number of non-zero entries:', matrix_x.nnz)
print('matrix_x Format:', matrix_x.getformat())

Les informations suivantes sont produites. La deuxième ligne est le nombre d'entrées saisies, mais il est de 400 000 x 400 000, soit 450 000 éléments sur 160 milliards d'éléments, vous pouvez donc voir que la densité est inférieure à 0,1%.

matrix_x Shape: (388836, 388836)
matrix_x Number of non-zero entries: 447875
matrix_x Format: lil

Enfin économisez. L'extension est "mat" et semble être un format qui peut être utilisé avec MATLAB / Octave. C'est celui utilisé dans les exercices du célèbre cours d'introduction en ligne à l'apprentissage automatique de Coursera. Si vous êtes intéressé, veuillez vous référer au "Cours d'introduction en ligne à l'apprentissage automatique Coursera Tora no Maki (recommandé pour les adultes qui travaillent)".

io.savemat('084.matrix_x.mat', {'x': matrix_x})

Conseils: mémoire utilisée pour les variables

La mémoire utilisée pour chaque variable était comme ça.

variable Mémoire Taille du fichier compressé
group_c 40MB 3MB
group_t 40MB 3MB
group_tc 64MB 104MB

La mémoire utilisée est vérifiée en insérant le code suivant. Il s'agit d'un copier-coller de Article "[Rechercher et supprimer des variables consommatrices de mémoire sur Jupyter (IPython)]".

print("{}{: >25}{}{: >10}{}".format('|','Variable Name','|','Memory','|'))
print(" ------------------------------------ ")
for var_name in dir():
    if not var_name.startswith("_") and sys.getsizeof(eval(var_name)) > 10000: #Arrangez seulement ici
        print("{}{: >25}{}{: >10}{}".format('|',var_name,'|',sys.getsizeof(eval(var_name)),'|'))

Recommended Posts

100 Language Processing Knock-84 (en utilisant des pandas): Création d'une matrice de contexte de mots
100 Language Processing Knock-83 (en utilisant des pandas): Mesure de la fréquence des mots / contextes
100 traitement de langage knock-34 (utilisant des pandas): "B of A"
100 traitement du langage knock-36 (en utilisant des pandas): fréquence d'occurrence des mots
100 Language Processing Knock-82 (mot de contexte): Extraction de contexte
100 traitement du langage knock-31 (en utilisant des pandas): verbe
100 traitement du langage knock-38 (en utilisant des pandas): histogramme
100 Language Processing Knock-33 (en utilisant des pandas): nom sahen
100 traitement du langage knock-35 (utilisant des pandas): concaténation de nomenclature
100 Language Processing Knock-39 (en utilisant des pandas): la loi de Zipf
100 langage de traitement knock-20 (à l'aide de pandas): lecture de données JSON
100 Language Processing Knock-32 (utilisant des pandas): Prototype de verbe
Traitement de 100 langues knock-98 (en utilisant des pandas): Clustering par méthode Ward
100 traitement du langage knock-99 (à l'aide de pandas): visualisation par t-SNE
100 traitement du langage knock-95 (en utilisant des pandas): Note avec WordSimilarity-353
Traitement du langage 100 Knock-87: similitude des mots
100 Language Processing Knock: Chapitre 2 Principes de base des commandes UNIX (à l'aide de pandas)
100 Language Processing Knock-30 (en utilisant des pandas): lecture des résultats de l'analyse morphologique
100 traitement du langage knock-76 (en utilisant scicit-learn): étiquetage
Traitement du langage 100 knock-86: affichage vectoriel Word
100 Traitement du langage Knock 2020 Chapitre 7: Vecteur de mots
100 traitement du langage knock-73 (en utilisant scikit-learn): apprentissage
100 traitement du langage knock-74 (en utilisant scicit-learn): prédiction
100 traitement du langage knock-97 (en utilisant scicit-learn): clustering k-means
100 Language Processing Knock-71 (en utilisant Stanford NLP): Stopword
100 coups de traitement linguistique (2020): 28
100 coups de traitement linguistique (2020): 38
100 traitement de la langue frapper 00 ~ 02
100 traitement du langage knock-93 (en utilisant des pandas): calcul du taux de précision de la tâche d'analogie
100 traitement du langage knock-90 (en utilisant Gensim): apprendre avec word2vec
100 langage de traitement knock-79 (en utilisant scikit-learn): dessin de graphe avec rappel de précision
100 traitement du langage knock-75 (en utilisant scicit-learn): poids de l'identité
100 traitement du langage knock-72 (en utilisant Stanford NLP): Extraction d'identité
100 traitements linguistiques Knock 2020 [00 ~ 39 réponse]
100 langues de traitement knock 2020 [00-79 réponse]
100 traitements linguistiques Knock 2020 [00 ~ 69 réponse]
100 Language Processing Knock 2020 Chapitre 1
100 coups de traitement du langage amateur: 17
100 traitements linguistiques Knock 2020 [00 ~ 49 réponse]
100 Traitement du langage Knock Chapitre 1
100 coups de langue amateur: 07
100 Language Processing Knock 2020 Chapitre 3
100 Language Processing Knock 2020 Chapitre 2
100 coups de traitement du langage amateur: 09
100 coups en traitement du langage amateur: 47
Traitement 100 langues knock-53: Tokenisation
100 coups de traitement du langage amateur: 97
100 traitements linguistiques Knock 2020 [00 ~ 59 réponse]
100 coups de traitement du langage amateur: 67
100 langage traitement knock-92 (utilisant Gensim): application aux données d'analogie
100 traitement de langage knock-94 (en utilisant Gensim): calcul de similarité avec WordSimilarity-353
100 traitements linguistiques knock-37 (utilisant des pandas): Top 10 des mots les plus fréquents
100 coups de traitement du langage avec Python 2015
100 Language Processing Knock-58: Extraction de Taple
100 Language Processing Knock-57: Analyse des dépendances
100 traitements linguistiques knock-77 (en utilisant scicit-learn): mesure du taux de réponse
100 traitement linguistique knock-50: coupure de phrase
100 Language Processing Knock Chapitre 1 (Python)
100 Language Processing Knock Chapitre 2 (Python)
Traitement du langage naturel 3 Continuité des mots
100 Language Processing Knock-25: Extraction de modèles