[Traitement du langage naturel] J'ai essayé de visualiser les sujets d'actualité cette semaine dans la communauté Slack

** Séparation d'exemples de phrases (nom uniquement): "Private baseball" **

Ce serait encore mieux.

• N'est-il pas préférable d'effacer également «je»? Je vous ai pensé là-bas. Voir le chapitre "Suppression de mots vides"

5.3. Mise en œuvre de l'analyse morphologique et de la division

Si vous souhaitez mettre en œuvre une analyse morphologique

--Que utiliser pour la bibliothèque d'analyse morphologique --Que utiliser comme données de dictionnaire

Nous devons en décider.

Cette fois, j'ai fait ce qui suit.

--Bibliothèque d'analyse morphologique: Janome --Dictionary data: Janome default (NEologd pour les nouveaux mots est encore mieux)

De plus, les mots de partie à extraire sont ceux nécessaires pour atteindre l'objectif en jetant un coup d'œil à "Système de partie de partie de l'outil d'analyse morphologique". quelque chose? J'ai pensé du point de vue.

Janome, la mascotte officielle, est mignonne. (Je ne sais pas si Janome est le nom)

morphological_analysis.py

from janome.tokenizer import Tokenizer
from tqdm import tqdm
import pandas as pd
import argparse
from pathlib import Path
import sys


exc_part_of_speech = {
    "nom": ["Non indépendant", "代nom", "nombre"]
}
inc_part_of_speech = {
    "nom": ["Changer de connexion", "Général", "固有nom"],
}


class MorphologicalAnalysis:

    def __init__(self):
        self.janome_tokenizer = Tokenizer()

    def tokenize_janome(self, line: str) -> list:
        # list of janome.tokenizer.Token
        tokens = self.janome_tokenizer.tokenize(line)
        return tokens

    def exists_pos_in_dict(self, pos0: str, pos1: str, pos_dict: dict) -> bool:
        # Retrurn where pos0, pos1 are in pos_dict or not.
        # ** pos = part of speech
        for type0 in pos_dict.keys():
            if pos0 == type0:
                for type1 in pos_dict[type0]:
                    if pos1 == type1:
                        return True
        return False

    def get_wakati_str(self, line: str, exclude_pos: dict,
                       include_pos: dict) -> str:
        '''
        exclude/include_pos is like this
        {"nom": ["Non indépendant", "代nom", "nombre"], "adjectif": ["xxx", "yyy"]}
        '''
        tokens = self.janome_tokenizer.tokenize(line, stream=True)  #Générateur pour économiser de la mémoire
        extracted_words = []
        for token in tokens:
            part_of_speech0 = token.part_of_speech.split(',')[0]
            part_of_speech1 = token.part_of_speech.split(',')[1]
            # check for excluding words
            exists = self.exists_pos_in_dict(part_of_speech0, part_of_speech1,
                                             exclude_pos)
            if exists:
                continue
            # check for including words
            exists = self.exists_pos_in_dict(part_of_speech0, part_of_speech1,
                                             include_pos)
            if not exists:
                continue
            # append(Forme de couche de surface acquise pour absorber les fluctuations de notation)
            extracted_words.append(token.surface)
        # wakati string with extracted words
        wakati_str = ' '.join(extracted_words)
        return wakati_str


def make_wakati_for_lines(msg_ser: pd.Series) -> pd.Series:
    manalyzer = MorphologicalAnalysis()
    wakati_msg_list = []
    for msg in tqdm(msg_ser, desc='[mk wakati msgs]'):
        wakati_msg = manalyzer.get_wakati_str(str(msg), exc_part_of_speech,
                                              inc_part_of_speech)
        wakati_msg_list.append(wakati_msg)
    wakati_msg_ser = pd.Series(wakati_msg_list)
    return wakati_msg_ser


def main(input_fname: str):
    input_root = '../../data/020_intermediate'
    output_root = '../../data/030_processed'
    # 1. load messages_cleaned.csv
    msgs_cleaned_fpath = input_root + '/' + input_fname
    df_msgs = pd.read_csv(msgs_cleaned_fpath)
    # 2. make wakati string by record
    ser_msg = df_msgs.msg
    df_msgs['wakati_msg'] = make_wakati_for_lines(ser_msg)
    # 3. save it
    pin = Path(msgs_cleaned_fpath)
    msgs_wakati_fpath = output_root + '/' + pin.stem + '_wakati.csv'
    df_msgs.to_csv(msgs_wakati_fpath, index=False)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("input_fname", help="set input file name", type=str)
    args = parser.parse_args()
    input_fname = args.input_fname
    # input file must been cleaned
    if 'cleaned' not in input_fname:
        print('input file name is invalid.: {0}'.format(input_fname))
        print('input file name must include \'cleaned\'')
        sys.exit(1)
    main(input_fname)

6. Prétraitement: normalisation

6.1 Qu'est-ce que la normalisation?

La normalisation dans le prétraitement du traitement du langage naturel fait référence au traitement suivant. Il est également appelé «identification du nom».

1. Unification des types de caractères
2. Unifier Kana en plein angle
3. L'alphabet est unifié aux rangs inférieurs ... etc.
4. Remplacement du numéro
5. Remplacez tous les nombres par 0, etc.
6. • Il existe peu de situations où les nombres sont importants dans le traitement du langage naturel.
7. Unification des mots à l'aide d'un dictionnaire
8. Jugez que «Sony» et «Sony» sont les mêmes et unifiez la notation en «Sony»

Le monde de la normalisation est profond, je vais donc le laisser ici.

6.2. Mise en œuvre de la normalisation

Cette fois, par souci de simplicité, seul le traitement suivant a été mis en œuvre. C'est incroyablement facile.

1. Unifiez l'alphabet en lettres minuscules
2. Remplacez tous les nombres par 0

normalization.py

import re
import pandas as pd
from tqdm import tqdm
import argparse
from pathlib import Path
import sys


def normarize_text(text: str):
    normalized_text = normalize_number(text)
    normalized_text = lower_text(normalized_text)
    return normalized_text


def normalize_number(text: str) -> str:
    """
    pattern = r'\d+'
    replacer = re.compile(pattern)
    result = replacer.sub('0', text)
    """
    #Remplacer les nombres consécutifs par 0
    replaced_text = re.sub(r'\d+', '0', text)
    return replaced_text


def lower_text(text: str) -> str:
    return text.lower()


def normalize_msgs(wktmsg_ser: pd.Series) -> pd.Series:
    normalized_msg_list = []
    for wktstr in tqdm(wktmsg_ser, desc='normalize words...'):
        normalized = normarize_text(str(wktstr))
        normalized_msg_list.append(normalized)
    normalized_msg_ser = pd.Series(normalized_msg_list)
    return normalized_msg_ser


def main(input_fname: str):
    input_root = '../../data/030_processed'
    output_root = input_root
    # 1. load wakati messages
    msgs_fpath = input_root + '/' + input_fname
    df_msgs = pd.read_csv(msgs_fpath)
    # 2. normalize wakati_msg (update)
    ser_msg = df_msgs.wakati_msg
    df_msgs.wakati_msg = normalize_msgs(ser_msg)
    # 3. save it
    pin = Path(msgs_fpath)
    msgs_ofpath = output_root + '/' + pin.stem + '_norm.csv'
    df_msgs.to_csv(msgs_ofpath, index=False)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("input_fname", help="set input file name", type=str)
    args = parser.parse_args()
    input_fname = args.input_fname
    # input file must been cleaned
    if 'wakati' not in input_fname:
        print('input file name is invalid.: {0}'.format(input_fname))
        print('input file name must include \'wakati\'')
        sys.exit(1)
    main(input_fname)

7. Prétraitement: suppression du mot d'arrêt

7.1. Qu'est-ce que la suppression des mots vides?

"Suppression des mots vides" est le processus de suppression des mots vides. (Trop comme ça ...)

Alors qu'est-ce qu'un "** mot d'arrêt **"?

Selon le dictionnaire de langue nationale goo

Mots qui sont si courants dans les recherches en texte intégral qu'ils sont exclus de la recherche par eux-mêmes. Fait référence à "ha", "no", "desu" en japonais et a, the, of en anglais. Mots vides.

Les tâches de traitement du langage naturel ont souvent pour but de «comprendre le contexte d'une phrase». Les mots vides ne sont pas nécessaires à cette fin et doivent être supprimés.

7.2 Comment décider du mot d'arrêt?

Il y en a deux principaux. Cette fois, nous utiliserons 1.

1. Méthode utilisant un dictionnaire (** ← Cette fois est adoptée **)
2. Méthode utilisant la fréquence d'apparition

Pour les données de dictionnaire, utilisez here.

Il y a plusieurs raisons de choisir la méthode 1.

--Lors de l'utilisation d'un dictionnaire Dictionnaire existant facilite l'installation.

• Lors de l'utilisation de la fréquence d'occurrence, il est nécessaire d'extraire uniquement "les mots qui apparaissent fréquemment dans ** la conversation générale ** et doivent donc être supprimés". Si vous utilisez uniquement les données Slack dont vous disposez pour déterminer la fréquence d'apparition **, il existe un risque que les "mots liés à des sujets passionnants" soient supprimés par inadvertance **, j'ai donc pensé qu'il était nécessaire de préparer des données séparées et de les agréger. .. ...... C'est un peu difficile

7.3. Mise en œuvre de la suppression des mots vides

Supprime les mots enregistrés dans les données de dictionnaire introduites dans la section précédente. De plus, les caractères suivants ont également été supprimés. C'est un mot que j'ai trouvé ennuyeux en réglant diverses choses.

• 「-」
• "-"
• 「w」
• 「m」
• "Lol"

stopword_removal.py

import pandas as pd
import urllib.request
from pathlib import Path
from tqdm import tqdm
import argparse
from pathlib import Path
import sys


def maybe_download(path: str):
    stopword_def_page_url = 'http://svn.sourceforge.jp/svnroot/slothlib/CSharp/Version1/SlothLib/NLP/Filter/StopWord/word/Japanese.txt'
    p = Path(path)
    if p.exists():
        print('File already exists.')
    else:
        print('downloading stop words definition ...')
        # Download the file from `url` and save it locally under `file_name`:
        urllib.request.urlretrieve(stopword_def_page_url, path)
    #mot d'arrêt ajouté
    sw_added_list = [
        '-',
        '-',
        'w',
        'W',
        'm',
        'Lol'
    ]
    sw_added_str = '\n'.join(sw_added_list)
    with open(path, 'a') as f:
        print(sw_added_str, file=f)


def load_sw_definition(path: str) -> list:
    with open(path, 'r', encoding='utf-8') as f:
        lines = f.read()
        line_list = lines.split('\n')
        line_list = [x for x in line_list if x != '']
    return line_list


def remove_sw_from_text(wktstr: str, stopwords: list) -> str:
    words_list = wktstr.split(' ')
    words_list_swrm = [x for x in words_list if x not in stopwords]
    swremoved_str = ' '.join(words_list_swrm)
    return swremoved_str


def remove_sw_from_msgs(wktmsg_ser: pd.Series, stopwords: list) -> pd.Series:
    swremved_msg_list = []
    for wktstr in tqdm(wktmsg_ser, desc='remove stopwords...'):
        removed_str = remove_sw_from_text(str(wktstr), stopwords)
        swremved_msg_list.append(removed_str)
    swremved_msg_ser = pd.Series(swremved_msg_list)
    return swremved_msg_ser


def main(input_fname: str):
    input_root = '../../data/030_processed'
    output_root = input_root
    # 1. load stop words
    sw_def_fpath = 'stopwords.txt'
    maybe_download(sw_def_fpath)
    stopwords = load_sw_definition(sw_def_fpath)
    # 2. load messages
    msgs_fpath = input_root + '/' + input_fname
    df_msgs = pd.read_csv(msgs_fpath)
    # 3. remove stop words
    ser_msg = df_msgs.wakati_msg
    df_msgs.wakati_msg = remove_sw_from_msgs(ser_msg, stopwords)
    # 4. save it
    pin = Path(msgs_fpath)
    msgs_ofpath = output_root + '/' + pin.stem + '_rmsw.csv'
    df_msgs.to_csv(msgs_ofpath, index=False)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("input_fname", help="set input file name", type=str)
    args = parser.parse_args()
    input_fname = args.input_fname
    # input file must been cleaned
    if 'norm' not in input_fname:
        print('input file name is invalid.: {0}'.format(input_fname))
        print('input file name must include \'norm\'')
        sys.exit(1)
    main(input_fname)

8. Prétraitement: extraction de phrases importantes (tf-idf)

8.1. Qu'est-ce que tf-idf?

Il existe de nombreux articles de commentaires intéressants. J'ai fait référence à cet article. TF-IDF | Qiita

Voici une explication approximative.

• tf (Term Frequency) --Fréquence d'occurrence de mot dans un document ――S'il est gros, "le mot apparaît souvent dans le document"
• idf (Inverse Document Frequency) --Ratio des documents dans lesquels un mot apparaît (pour tous les documents) ** Nombre inverse ** ――Si c'est gros, cela n'apparaît pas beaucoup dans les autres documents.

tf-idf est le produit de tf et idf. En d'autres termes ** Grand tf-idf ** = ** Apparaissant fréquemment dans un document ** & ** Ne figurant pas souvent dans d'autres documents ** = Important pour comprendre le ** contexte du document **

8.2. Implémentation du traitement de notation de mots par tf-idf

8.2.1 Que devrait être un document / tous les documents?

Le but de ce temps est de voir les caractéristiques des remarques pour une certaine période (1 semaine). Par conséquent, j'ai pensé qu'il devrait être possible de comprendre ** quelles sont les caractéristiques des remarques d'une certaine période (1 semaine) pour tous les postes jusqu'à présent **.

Donc,

• ** Tous les documents **: Tous les messages à ce jour
• ** 1 document **: Une masse de postes pour une certaine période (1 semaine)

J'ai calculé tf-idf comme.

8.2.2. Mise en œuvre

Écrivez facilement le flux de processus

1. Lire le tableau du magasin de messages (prétraité)
2. Regroupement par période de message
3. Divisez et regroupez les données passées en unités de 7 jours à partir du moment de l'exécution du traitement
4. Calculez tf-idf avec un groupe de messages comme un document
5. Extraire les mots dont le score tf-idf est supérieur au seuil (sortie sous forme de dictionnaire)

important_word_extraction.py

import pandas as pd
import json
from datetime import datetime, date, timedelta, timezone
from pathlib import Path
from sklearn.feature_extraction.text import TfidfVectorizer
JST = timezone(timedelta(hours=+9), 'JST')

#Regroupement des messages par période spécifiée
def group_msgs_by_term(df_msgs: pd.DataFrame, term: str) -> dict:
    # set term
    term_days = 8
    if term == 'lm':
        term_days = 31
    print('group messages every {0} days'.format(term_days))
    # analyze timestamp
    now_in_sec = (datetime.now(JST) - datetime.fromtimestamp(0, JST)).total_seconds()
    interval_days = timedelta(days=term_days)
    interval_seconds = interval_days.total_seconds()
    oldest_timestamp = df_msgs.min().timestamp
    oldest_ts_in_sec = (datetime.fromtimestamp(oldest_timestamp, JST) - datetime.fromtimestamp(0, JST)).total_seconds()
    loop_num = (abs(now_in_sec - oldest_ts_in_sec) / interval_seconds) + 1
    # extract by term
    dict_msgs_by_term = {}
    df_tmp = df_msgs
    now_tmp = now_in_sec
    for i in range(int(loop_num)):
        # make current term string
        cur_term_s = 'term_ago_{0}'.format(str(i).zfill(3))
        print(cur_term_s)
        # current messages
        df_msgs_cur = df_tmp.query('@now_tmp - timestamp < @interval_seconds')
        df_msgs_other = df_tmp.query('@now_tmp - timestamp >= @interval_seconds')
        # messages does not exist. break.
        if df_msgs_cur.shape[0] == 0:
            break
        # add current messages to dict
        dict_msgs_by_term[cur_term_s] = ' '.join(df_msgs_cur.wakati_msg.dropna().values.tolist())
        # update temp value for next loop
        now_tmp = now_tmp - interval_seconds
        df_tmp = df_msgs_other
    return dict_msgs_by_term

# tf-Extraire les mots importants et les renvoyer sous forme de dictionnaire en se référant au score idf
def extract_important_word_by_key(feature_names: list, bow_df: pd.DataFrame, uids: list) -> dict:
    # >Regardez chaque ligne et extrayez les mots importants(tfidf Top X mots)
    dict_important_words_by_user = {}
    for uid, (i, scores) in zip(uids, bow_df.iterrows()):
        #Créer une table de mots et de scores tfidf pour l'utilisateur
        words_score_tbl = pd.DataFrame()
        words_score_tbl['scores'] = scores
        words_score_tbl['words'] = feature_names
        #Trier par ordre décroissant par score tfidf
        words_score_tbl = words_score_tbl.sort_values('scores', ascending=False)
        words_score_tbl = words_score_tbl.reset_index()
        # extract : tf-idf score > 0.001
        important_words = words_score_tbl.query('scores > 0.001')
        #Créer un dictionnaire pour l'utilisateur'uid0': {'w0': 0.9, 'w1': 0.87}
        d = {}
        for i, row in important_words.iterrows():
            d[row.words] = row.scores
        #Ajouter au tableau uniquement si le dictionnaire de l'utilisateur contient au moins un mot
        if len(d.keys()) > 0:
            dict_important_words_by_user[uid] = d
    return dict_important_words_by_user

#Extraire les mots importants dans l'unité de période spécifiée
def extraction_by_term(input_root: str, output_root: str, term: str) -> dict:
    # ---------------------------------------------
    # 1. load messages (processed)
    # ---------------------------------------------
    print('load msgs (all of history and last term) ...')
    msg_fpath = input_root + '/' + 'messages_cleaned_wakati_norm_rmsw.csv'
    df_msgs_all = pd.read_csv(msg_fpath)
    # ---------------------------------------------
    # 2. group messages by term
    # ---------------------------------------------
    print('group messages by term and save it.')
    msgs_grouped_by_term = group_msgs_by_term(df_msgs_all, term)
    msg_grouped_fpath = input_root + '/' + 'messages_grouped_by_term.json'
    with open(msg_grouped_fpath, 'w', encoding='utf-8') as f:
        json.dump(msgs_grouped_by_term, f, ensure_ascii=False, indent=4)
    # ---------------------------------------------
    # 3.Tf pour tous les documents-calcul idf
    # ---------------------------------------------
    print('tfidf vectorizing ...')
    # >Les mots de tous les documents sont des colonnes et le nombre de documents (=Une matrice est créée dans laquelle l'utilisateur) est la ligne. Tf pour chaque élément-Il y a une valeur idf
    tfidf_vectorizer = TfidfVectorizer(token_pattern=u'(?u)\\b\\w+\\b')

    bow_vec = tfidf_vectorizer.fit_transform(msgs_grouped_by_term.values())
    bow_array = bow_vec.toarray()
    bow_df = pd.DataFrame(bow_array,
                        index=msgs_grouped_by_term.keys(),
                        columns=tfidf_vectorizer.get_feature_names())
    # ---------------------------------------------
    # 5. tf-Extraire des mots importants basés sur idf
    # ---------------------------------------------
    print('extract important words ...')
    dict_word_score_by_term = extract_important_word_by_key(
        tfidf_vectorizer.get_feature_names(),
        bow_df, msgs_grouped_by_term.keys())
    return dict_word_score_by_term

9. Processus de visualisation avec Wordcloud

9.1. Qu'est-ce que Wordcloud?

Les mots avec un score élevé sont grands et les mots avec un score faible sont petits. Diverses valeurs telles que "fréquence d'apparition" et "importance" peuvent être librement définies pour la partition.

Dépôt officiel: amueller / word_cloud: octocat:

9.2. Polices Wordcloud disponibles

Cette fois, je vais l'utiliser. Qu'est-ce que Homemade Rounded M +

9.3. Implémentation de Wordcloud

Dans le chapitre précédent "8. Prétraitement: extraction de mots importants (tf-idf)", le fichier JSON suivant a été généré.

important_word_tfidf_by_term.json

{
  "term_ago_000": {
    "Les données": 0.890021,
    "Jeu": 0.780122,
    "article": 0.720025,
    :
  },
  "term_ago_001": {
    "Traduction": 0.680021,
    "Les données": 0.620122,
    "deepl": 0.580025,
    :
  },
  :
}

Chargez ceci et créez une image Wordcloud. Utilisez la méthode WordCloud.generate_from_frequencies ().

wordcloud_from_score.py

from wordcloud import WordCloud
import matplotlib.pyplot as plt
import json
from pathlib import Path
from sklearn.feature_extraction.text import TfidfVectorizer
import pandas as pd
from tqdm import tqdm
import sys
import argparse


def main(input_fname: str):
    input_root = '../../data/031_features'
    output_root = './wordcloud_by_user' if 'by_user' in input_fname else './wordcloud_by_term'
    p = Path(output_root)
    if p.exists() is False:
        p.mkdir()
    # -------------------------------------
    # 1. load tf-idf score dictionary
    # -------------------------------------
    d_word_score_by_user = {}
    tfidf_fpath = input_root + '/' + input_fname
    with open(tfidf_fpath, 'r', encoding='utf-8') as f:
        d_word_score_by_user = json.load(f)
    # -------------------------------------
    # 2. gen word cloud from score
    # -------------------------------------
    fontpath = './rounded-l-mplus-1c-regular.ttf'
    for uname, d_word_score in tqdm(d_word_score_by_user.items(), desc='word cloud ...'):
        # img file name is user.png
        uname = str(uname).replace('/', '-')
        out_img_fpath = output_root + '/' + uname + '.png'
        # gen
        wc = WordCloud(
            background_color='white',
            font_path=fontpath,
            width=900, height=600,
            collocations=False
            )
        wc.generate_from_frequencies(d_word_score)
        wc.to_file(out_img_fpath)


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("input_fname", help="set input file name", type=str)
    args = parser.parse_args()
    input_fname = args.input_fname
    main(input_fname)

10. Bonus

Articles auxquels j'ai fait référence en particulier

• Types de prétraitement dans le traitement du langage naturel et leur puissance | Qiita
• NLP Pipeline 101 With Basic Code Example — Feature Extraction

D'autres documents de référence (en grande quantité) sont résumés dans ici: octocat:.

Publicité

Cette fois, nous utilisons les données de la communauté Slack appelée Data Learning Guild. La Data Learning Guild est une communauté en ligne de personnel d'analyse de données. Si vous êtes intéressé, veuillez vérifier ici.

Site Web officiel de Data Learning Guild

Calendrier de l'Avent Data Learning Guild 2019