J'en ai marre de Python, alors j'ai essayé d'analyser les données avec nehan (je veux aller vivre même avec Corona) -Partie 1)

salutation

Bonjour, c'est sunfish. ** "Twtter x Corona" ** C'est la deuxième fois de la série. La dernière fois a essayé de compter le nombre de tweets, c'était un niveau, mais cette fois je ferai de mon mieux. Surtout, si vous êtes épuisé par le traitement du langage naturel tel que l'installation de MeCab ou la création d'un environnement, veuillez jeter un coup d'œil.

Rechercher des mots de tendance haut / bas à partir des données Twitter

Plus de six mois se sont écoulés depuis que le virus corona est devenu un problème social. Suivons du tweet ce qui monte chez les gens et ce qui est oublié. Dans une première partie, nous effectuerons une analyse morphologique et sélectionnerons les mots à analyser.

Les données

Utilisez les données après le Dernier prétraitement. En d'autres termes, ce sont les données de la date et du contenu du tweet.

Processus de suppression en double

En fait, dans ces données, le même contenu de tweet se produit sur plusieurs enregistrements et plusieurs jours. (Parce qu'il inclut le retweet) Cette fois, nous analyserons avec 1 contenu de tweet 1 enregistrement, à l'exclusion du biais de retweet.

from collections import Counter
from sklearn.feature_extraction.text import CountVectorizer
import pandas as pd
import statsmodels.api as sm
import re
import MeCab
import dask.dataframe as dd
from multiprocessing import cpu_count

#Les plus créés pour chaque tweet_At prend un jeune jour et fait 1 tweet 1 enregistrement
port_13['Created_At'] = pd.to_datetime(port_12['Created_At'])
port_13 = port_12.groupby(['Text']).apply(lambda grp: getattr(
    grp, 'nsmallest')(n=1, columns='Created_At', keep='first'))
port_13['Created_At'] = port_12['Created_At'].map(lambda x: x.date())

Analyse morphologique

Je vais faire la clé du traitement linguistique. Comme il sera difficile de comprendre si toutes les parties sont données, seule la ** «nomenclature générale» ** sera analysée cette fois.

def tokenizer(text, pos, only_surface):
    def _extract():
        if only_surface:
            return re.sub(r'[\s　]+', '_', feature[0])
        else:
            return re.sub(r'[\s　]+', '_', feature[2])
    _tagger = MeCab.Tagger(
        '-Ochasen -d {}'.format("/var/lib/mecab/dic/mecab-ipadic-neologd"))
    try:
        result = []
        for feature in _tagger.parse(text).split('\n')[:-2]:
            feature = feature.split('\t')
            if pos:
                if feature[3] in pos:
                    result.append(_extract())
            else:
                result.append(_extract())
        return ' '.join(result)
    except UnicodeEncodeError:
        return ''
    except NotImplementedError:
        return ''

port2 = port1.copy()
port2['Text_morphème'] = port2['Text'].fillna('')
ddf = dd.from_pandas(port2, npartitions=cpu_count()-1)
target_cols = ['Text_morphème']
pos = ['nom-Général']
for target_col in target_cols:
    ddf[target_col] = ddf[target_col].apply(
        tokenizer, pos=pos, only_surface=True, meta=(f'{target_col}', 'object'))
port2 = ddf.compute(scheduler='processes')

L'analyse morphologique de ↓ nehan combine des éléments morphologiques séparés par des espaces et les insère dans une colonne.

Notez que les tweets qui ne contiennent pas de nomenclature générale perdront les résultats de l'analyse morphologique, supprimez-les donc. Utilisez le traitement des valeurs manquantes.

port_15 = port_14.copy()
port_15 = port_15.dropna(subset=None, how='any')

Sélectionnez les mots qui apparaissent fréquemment (*)

Puisqu'il est inévitable de cibler des mots qui apparaissent rarement, nous avons analysé ceux qui sont apparus plus de 1 500 sur l'ensemble de la période.

#Agrégation de la fréquence des mots
port_18 = port_15.copy()
flat_words = list(chain.from_iterable(port_18['Text_morphème'].str.split(' ')))
c = Counter(flat_words)
res = pd.DataFrame.from_dict(c, orient='index').reset_index()
res.columns = ['mot', 'compter']
port_18 = res

#Filtrer les lignes par condition
port_20 = port_18[(port_18['compter'] >= 1500.0)]

#Sélection de colonne
port_21 = port_20[['mot']]

↓ Le nombre d'apparitions des 27 mots sélectionnés ressemble à ceci

↓ En prime, c'est un nuage de mots avant la sélection.

Regroupez le nombre de mots qui apparaissent chaque jour et limitez-vous aux mots qui apparaissent fréquemment

Étant donné que les mots cibles ont été réduits à l'étape précédente, l'étape suivante consiste à créer des données quotidiennes. Agréger la fréquence des mots en utilisant Created_At comme colonne clé.

port_16 = port_15.copy()
target_col = 'Text_morphème'
groupby_cols = ['Created_At']
tmp = port_16[groupby_cols+[target_col]]
tmp = tmp.groupby(groupby_cols)[target_col].apply(lambda x: ' '.join(x))
vec_counter = CountVectorizer(tokenizer=lambda x: x.split(' '))
X = vec_counter.fit_transform(tmp)
res = pd.DataFrame(X.toarray(), columns=vec_counter.get_feature_names(), index=tmp.index
                   ).reset_index().melt(id_vars=groupby_cols, var_name='mot', value_name='compter')
port_16 = res.sort_values(groupby_cols).reset_index(drop=True)

Les données de * sont combinées ici, les données quotidiennes sont réduites aux mots à analyser et le travail de la première partie est terminé.

port_22 = pd.merge(port_21, port_16, how='inner',
                   left_on=['mot'], right_on=['mot'])

↓ À titre d'essai, filtrez les données obtenues et visualisez le nombre d'apparitions de mots par jour. Un sourire vaut mieux qu'un visage qui pleure.

Résumé

Cela fait longtemps, mais j'ai essayé de faire apparaître le nombre de mots fréquents chaque jour. Nous privilégions la simplicité à la rigueur. Lorsque vous essayez de faire une analyse compliquée, le code a tendance à être long et difficile, mais nehan le fait avec 10 nœuds (le nombre de cercles verts). Bien sûr, je n'ai écrit aucun programme. J'espère que vous serez intéressé par nehan même un peu.

• Pour une introduction à l'outil d'analyse nehan, cliquez ici [https://nehan.io/product/).
• ↓ Contenu d'aujourd'hui Le code source ci-dessus est une copie du code produit par la [fonction d'exportation python] de nehan (https://prtimes.jp/main/html/rd/p/000000004.000044237.html). Seule la partie analyse morphologique n'était pas applicable à la sortie du code, j'ai donc demandé au personnel de nehan de l'écrire.