Il s'agit de l'enregistrement de la 83e «Mesure de la fréquence des mots / contextes» de Traitement du langage 100 knock 2015. Cela prend du temps (environ 7 minutes) car il s'agit d'un processus pour un fichier d'environ 800 Mo. Je pensais qu'une erreur de mémoire se produirait si je les lisais tous en même temps, et quand j'essayais de survivre en utilisant l'option chunksize des pandas, j'ai eu du mal car je ne pouvais pas du tout le faire. Après tout, il pouvait être lu en une seule fois et il n'y avait aucun problème particulier.
| Lien | Remarques |
|---|---|
| 083.Mesure de fréquence de mots / contextes.ipynb | Lien GitHub du programme de réponse |
| 100 coups de traitement du langage amateur:83 | 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. |
| Comment utiliser Pandas groupby | Facile à comprendre comment utiliser le groupe pandas par |
| to_fonction pickle | to_fonction pickleの公式ヘルプ |
| 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 |
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é.
Utilisez la sortie> 82 pour trouver la distribution d'apparence et les constantes suivantes.
- $ f (t, c) $: Nombre de co-occurrence du mot $ t $ et du mot de contexte $ c $
- $ f (t, ∗) $: Nombre d'occurrences du mot $ t $
- $ f (∗, c) $: Nombre d'occurrences du mot de contexte $ c $
- $ N $: Nombre total d'occurrences de paires mot / mot contextuel
"Word $ t $" est [article précédent](https://qiita.com/FukuharaYohei/items/64e20ced30cba76383dc#%E6%96%87%E8%84%88%E8%AA%9E%E3%81% Il s'agit du ** "Mot cible" ** écrit en A8% E3% 81% AF). Supposons que la sortie de 82 soit la suivante.
| t(Langue cible) | c(Mots contextuels) |
|---|---|
| t1 | c1 |
| t1 | c2 |
| t2 | c1 |
| t1 | c1 |
Ensuite, ce qui suit est sorti. Ce que l'on appelle SQL Group By.
** $ f (t, c) $: Nombre de co-occurrence du mot $ t $ et du mot de contexte $ c $ **
| t(Langue cible) | c(Mots contextuels) | Nombre de cooccurrence |
|---|---|---|
| t1 | c1 | 2 |
| t1 | c2 | 1 |
| t2 | c1 | 1 |
** $ f (t, ∗) $: Nombre d'occurrences du mot $ t $ **
| t(Langue cible) | Nombre d'apparitions |
|---|---|
| t1 | 3 |
| t2 | 1 |
** $ f (∗, c) $: Nombre d'occurrences du mot de contexte $ c $ **
| c(Mots contextuels) | Nombre d'apparitions |
|---|---|
| c1 | 3 |
| c2 | 1 |
** $ N $: nombre total d'occurrences de paires de mots / mots contextuels ** 4 (car le tout fait 4 lignes)
import sys
import pandas as pd
df = pd.read_table('./082.context.txt', header=None, names=['t', 'c'])
print(df.info())
def to_pickle_file(grouped, path):
print('length:', grouped.size)
grouped.to_pickle(path)
to_pickle_file(df.groupby(['t','c'])['c'].agg('count'), './083_group_tc.zip')
to_pickle_file(df.groupby('t')['c'].agg('count'), './083_group_t.zip')
to_pickle_file(df.groupby('c')['c'].agg('count'), './083_group_c.zip')
J'utilise des pandas pour charger un fichier c avec le nom de colonne t.
df = pd.read_table('./082.context.txt', header=None, names=['t', 'c'])
print(df.info())
Comme résultat de df.info (), ce qui suit est sorti, et vous pouvez voir que le résultat de * "$ N $: Nombre total d'occurrences de la paire mot / mot contextuel" * est 6800317. Vous pouvez également voir qu'il utilise environ 1 Go de mémoire. À propos, il a fallu environ 1,5 minute pour la partie lue.
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 68000317 entries, 0 to 68000316
Data columns (total 2 columns):
t object
c object
dtypes: object(2)
memory usage: 1.0+ GB
None
Ici, le décompte du résultat «groupby» des pandas est enregistré par «pickle». Si vous définissez l'extension de fichier sur zip, il sera automatiquement compressé, ce qui est pratique. Si vous chargez le fichier enregistré ici, vous pouvez le restaurer sous le même objet de la série pandas que lorsque vous l'avez enregistré.
def to_pickle_file(grouped, path):
print('length:', grouped.size)
grouped.to_pickle(path)
C'est la partie principale de ce temps. Le regroupement se fait en utilisant «groupby» de pandas et le résultat est compté.
to_pickle_file(df.groupby(['t','c'])['c'].agg('count'), './083_group_tc.zip')
to_pickle_file(df.groupby('t')['c'].agg('count'), './083_group_t.zip')
to_pickle_file(df.groupby('c')['c'].agg('count'), './083_group_c.zip')
À propos, voici les informations de chaque processus.
| Nombre de lignes | temps de traitement | taille du fichier | |
|---|---|---|---|
| $ f(t,c) $ | 21,327,Ligne 945 | 4min 38s | 103.7MB |
| $ f(t,*) $ | 388,Ligne 836 | 34.7s | 2.8MB |
| $ f(*,c) $ | 388,Ligne 836 | 24.2s | 2.8MB |
La taille du fichier cible étant importante (environ 800 Mo), les essais et erreurs ont été très difficiles. Par conséquent, dans un premier temps, j'ai créé et codé un fichier qui ne couvrait que les 100 000 premières lignes.
cat 082.context.txt | head -n 100000 >> 082.context_mini.txt
Lorsqu'il y avait une erreur sur la ligne XX dans DataFrame, j'ai combiné head et tail pour voir le contenu du fichier. Normalement, j'ouvre simplement le fichier, mais pour les gros fichiers, il faut du temps pour s'ouvrir, alors je l'ai fait.
La commande suivante affiche les lignes 12198 à 3 du fichier. En passant, cette erreur est un échec lié à la tokenisation de la phrase écrite dans "Spill" dans l'article précédent.
$ cat 082.context.txt | head -n 124150 | tail -n 3
"b")("s" "c
− "b")("s"
− "c
Recommended Posts