3. Traitement du langage naturel par Python 2-2. Réseau de co-occurrence [mecab-ipadic-NEologd]

• ** mecab-ipadic-NEologd ** est un dictionnaire personnalisé qui complète le dictionnaire standard MeCab.

• Des mots ont été ajoutés à partir de nombreuses ressources linguistiques sur le Web, et ** prend en charge les nouveaux mots, les mots composés, les expressions idiomatiques, etc. **.

• Comme mentionné ci-dessus, le standard MeCab le divise en «individuel» et «principe», mais mecab-ipadic-NEologd le traite comme un mot «individualisme».

Tâche

** Utilisez mecab-ipadic-NEologd ** pour effectuer une série de tâches telles que ** supprimer les mots vides ** et ** exprimer dans un réseau cooccurrence **.

** 1. Préparation des données textuelles **

⑴ Lire des données textuelles

• Pour le corpus, nous utiliserons le discours du Premier ministre Kan à l'Assemblée générale des Nations Unies (26 septembre, 2e année de Reiwa). En outre, les discours et conférences de presse des premiers ministres successifs sont publiés dans des textes non coupés et des vidéos à l'adresse URL suivante.
• https://www.kantei.go.jp/jp/99_suga/statement/index.html
• J'ai copié le texte à l'écran à l'avance et créé un fichier texte sur le PC local. Téléchargez-le dans Colaboratory et chargez-le.

from google.colab import files
uploaded = files.upload()

with open('20200926_suga_un.txt', mode='rt', encoding='utf-8') as f:
    read_text = f.read()
sugatxt = read_text

⑵ Nettoyage des données

• Supprime le bruit tel que les codes et symboles de saut de ligne, et se divise en unités de phrase avec le signe de ponctuation ".".

#Supprimer les caractères / symboles inutiles
def clean(text):
    text = text.replace("\n", "")
    text = text.replace("\u3000", "")
    text = text.replace("「", "")
    text = text.replace("」", "")
    text = text.replace("（", "")
    text = text.replace("）", "")
    text = text.replace("、", "")
    return text

text = clean(sugatxt)

#Fractionner ligne par ligne
lines = text.split("。")

** 2. Création de données de cooccurrence **

• Utilisez MeCab et ** mecab-ipadic-NEologd ** pour effectuer une analyse morphologique phrase par phrase afin de créer une liste de nomenclature uniquement à l'exclusion des mots vides **.

⑶ Installation de MeCab et mecab-ipadic-NEologd

# MeCab
!apt-get -q -y install sudo file mecab libmecab-dev mecab-ipadic-utf8 git curl python-mecab > /dev/null
!pip install mecab-python3 > /dev/null

# mecab-ipadic-NEologd
!git clone --depth 1 https://github.com/neologd/mecab-ipadic-neologd.git > /dev/null 
!echo yes | mecab-ipadic-neologd/bin/install-mecab-ipadic-neologd -n > /dev/null 2>&1

#Éviter les erreurs avec les liens symboliques
!ln -s /etc/mecabrc /usr/local/etc/mecabrc

• Des mesures ont été prises pour s'assurer que le chemin dans la section suivante fonctionne correctement, évitant les erreurs telles que les liens rompus et pointant vers le mauvais fichier.

⑷ Créez une instance en spécifiant mecab-ipadic-NEologd

#Vérifiez le chemin du dictionnaire
!echo `mecab-config --dicdir`"/mecab-ipadic-neologd"

• Créez une instance m_neo avec le mode de sortie comme path (= mecab-ipadic-NEologd).

import MeCab

path = "-d /usr/lib/x86_64-linux-gnu/mecab/dic/mecab-ipadic-neologd"
m_neo = MeCab.Tagger(path)

⑸ Créez une liste de nomenclature basée sur des phrases

• Définissez le mot ** mot d'arrêt ** à supprimer. Nous listons les mots qui n'ont pas de signification utile pour l'interprétation par eux-mêmes, tels que les nombres, les nombres et les synonymes directive. Dans cet exemple, les symboles restants après l'analyse morphologique sont également ajoutés.

stopwords = ["１", "２", "３", "４", "５", "６", "７", "８", "９", "０", 
             "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", 
             "un", "deux", "Trois", "quatre", "Cinq", "Six", "Sept", "Huit", "Neuf", "〇", 
             "Année", "Mois", "journée", "Suivant", "Remise", "Fois", "Cible", "Maladie", "c'est tout", "Moins que", "周Année", "Cas", "À chaque fois",
             "de", "もde", "chose", "Yo", "Sama", "Pour", "Avoir tendance à", "cette", "Il", "cette", "Qui", 
             "*", ",", "，"]

• Créez une liste de noms basée sur des phrases noun_list.
• À partir des données de texte lignes divisées en unités de ligne, répétez le processus suivant ligne par ligne et ajoutez-le à nom_liste.
• Soit le résultat de l'analyse morphologique v1, et que ce soit une liste divisée en unités de mots par splitlines () ʻas v2`.
• Répétez le processus suivant mot par mot de «v2» et ajoutez-le au «résultat».
• Divisez le résultat de l'analyse pour un mot en split (" \ t ") c'est-à-dire un blanc, et divisez-le en deux parties, le "mot original" et la "partie contenu de l'analyse" pour créer v3.
• En réglant ʻif len (v3) == 2, sauf pour "EOS" et "", la partie contenu de l'analyse v3 [1]est divisée parsplit (','), c'est-à-dire split (','). Disons v4.
• Si ce premier élément «v4 [0]» est une nomenclature et que l'original «v4 [6]» n'est pas un mot vide, ajoutez-le au «résultat».
• Lorsque vous avez fini de traiter tous les mots, ajoutez result à noun_list et passez au traitement de la phrase suivante.

noun_list  = []

for line in lines:
    result = []
    v1 = m_neo.parse(line)
    v2 = v1.splitlines()
    for v in v2:
        v3 = v.split("\t")
        if len(v3) == 2:
            v4 = v3[1].split(',')
            if (v4[0] == "nom") and (v4[6] not in stopwords):
                 result.append(v4[6])
    noun_list.append(result)

⑹ Génération de données de cooccurrence

• Séquentiellement à partir de la liste de noms basée sur des phrases noun_list, générez une paire (combinaison de deux mots) avec ʻitertools.combinations () pour ceux avec deux mots ou plus avec ʻif len (noun_list)> = 2. , Listez-le avec list () et stockez-le dans pair_list.
• Ensuite, aplatissez la pair_list basée sur des instructions pour la rendre ʻall_pairs`, puis comptez le nombre d'occurrences de la paire.

import itertools #Un module qui rassemble les fonctions d'itérateur
from collections import Counter #Une classe qui compte le nombre d'occurrences du type dictionnaire

#Générer une liste de paires de nomenclatures basée sur des phrases
pair_list = []
for n in noun_list:
    if len(noun_list) >= 2:
        lt = list(itertools.combinations(n, 2))
        pair_list.append(lt)

#Aplatir la liste des paires de nez
all_pairs = []
for p in pair_list:
    all_pairs.extend(p)

#Comptez la fréquence des paires de noms
cnt_pairs = Counter(all_pairs)

** 3. Dessiner un schéma de réseau **

⑺ Création de données de dessin

• Pour le dessin, n'utilisez que les 30 meilleures paires en fonction du nombre d'occurrences.
• C'est un argument de sorted () [: 30] pour trier et récupérer 30 paires, mais l'élément de cnt_pairs est key = lambda x: x [1] et le nombre d'occurrences est ciblé et reverse = True Trié par ordre décroissant.
• De plus, convertissez le type de dictionnaire «dict» en un tableau à deux dimensions pour en faire des «données» pour le dessin.

import pandas as pd
import numpy as np

#Générez les 30 meilleures paires de dictionnaires
dict = sorted(cnt_pairs.items(), key=lambda x:x[1], reverse=True)[:30]

#Convertir le type de dict en tableau 2D
result = []
for key, value in dict:
    temp = []
    for k in key:
        temp.append(k)
    temp.append(value)
    result.append(temp)

data = np.array(result)

⑻ Import de la bibliothèque de visualisation

• Utilisez le package ** networkX ** pour créer et manipuler des réseaux complexes et des structures graphiques en Python.

import matplotlib.pyplot as plt
import networkx as nx
%matplotlib inline 

#Un module qui rend matplotlib compatible avec l'affichage japonais
!pip install japanize-matplotlib
import japanize_matplotlib

⑼ Visualisation par NetworkX

• Créez un objet de structure graphique, chargez-y des données et dessinez en spécifiant des spécifications telles que des nœuds et des arêtes sur matplotlib.
• Pour que l'étiquette du nœud corresponde à l'affichage japonais, la police japonaise est spécifiée comme font_family =" IPAexGothic.

#Générer un objet graphique
G = nx.Graph()

#Lire les données
G.add_weighted_edges_from(data)

#Dessiner un graphique
plt.figure(figsize=(10,10))
nx.draw_networkx(G,
                 node_shape = "s",
                 node_color = "chartreuse", 
                 node_size = 800,
                 edge_color = "gray", 
                 font_family = "IPAexGothic") #Spécification de la police japonaise

plt.show()

• Comme indiqué ci-dessous, les mots qui seraient divisés par la norme MeCab sont traités comme un mot.

• Les mots écrits et prononcés par des êtres humains vivants sont comme des êtres vivants à part entière et sont constamment métabolisés. Je pense vraiment que le dictionnaire doit être mis à jour en conséquence.