3. Traitement du langage naturel par Python 2-1. Réseau de co-occurrence

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

• Les données de co-occurrence sont un objet de type dictionnaire constitué de paires de mots de co-occurrence et de fréquence d'occurrence.

import itertools
from collections import Counter

• ʻItertools`: Un module qui rassemble les fonctions d'itérateur pour un traitement efficace des boucles.
• Counter: Un module pour compter le nombre d'occurrences de chaque élément

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

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

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

• Extraire séquentiellement deux mots ou plus de la liste de nomenclature basée sur des phrases, générer une combinaison de deux mots avec ʻitertools.combinations () , les lister avec list () , et les stocker dans pair_list`.
• Cependant, puisque pair_list est une unité de phrase, elle ne peut pas être comptée telle quelle. Par conséquent, aplatissez-le en l'ajoutant séquentiellement à la variable nouvellement préparée ʻall_pairsavec ʻextend ().
• Passez ceci à Counter () pour générer des ** données de cooccurrence de type dictionnaire ** cnt_pairs.

** 3. Création de données de dessin **

import pandas as pd
import numpy as np

⑺ Affiner les données de cooccurrence

• Affinez les éléments pour simplifier l'apparence lors du dessin. Ici, nous allons générer une liste des 50 meilleurs ensembles par fréquence d'apparition.

tops = sorted(
    cnt_pairs.items(), 
    key=lambda x: x[1], reverse=True
    )[:50]

• Il a une syntaxe qui combine les expressions sorted () et lambda, et trie les objets de type dictionnaire en fonction de l'élément spécifié sous key = lambda.
• La référence «x [1]» extrait les 50 premières paires du deuxième élément, c'est-à-dire le tri inversé par fréquence «reverse = True».

⑻ Génération de données pondérées

noun_1 = []
noun_2 = []
frequency = []

#Créer un bloc de données
for n,f in tops:
    noun_1.append(n[0])    
    noun_2.append(n[1])
    frequency.append(f)

df = pd.DataFrame({'La nomenclature ci-dessus': noun_1, 'Nomenclature ultérieure': noun_2, 'Fréquence d'apparition': frequency})

#Définition des données pondérées
weighted_edges = np.array(df)

• Conversion des 50 premiers ensembles de données de cooccurrence en tableau pour créer des weighted_edges (données pondérées).
• Ci-dessous se trouve la trame de données avant la conversion en tableau.

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

⑼ Import de la bibliothèque de visualisation

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

• ** networkX ** est un package pour créer et manipuler des réseaux complexes et des structures de graphes en Python.
• Dans le diagramme de réseau, les sommets sont appelés ** nœuds ** et les arêtes reliant les sommets sont appelées ** arêtes **
• Afin d'afficher l'étiquette du nœud en japonais, il est nécessaire d'importer le japanize_matplotlib suivant puis de spécifier la police japonaise.

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

⑽ Visualisation par NetworkX

• La procédure pour dessiner un diagramme de réseau avec networkX est de 3 étapes: ➀ créer un objet avec une structure graphique, ➁ y charger des données et ➂ spécifier des spécifications telles que des nœuds et des arêtes sur matplotlib et dessiner.
• Cela semble déroutant, mais font_family =" IPAexGothic " est la clé, et en spécifiant ** font_family avec une police japonaise **, l'étiquette de nœud sera rendue compatible avec l'affichage japonais.

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

#Lecture des données pondérées
G.add_weighted_edges_from(weighted_edges)

#Dessiner un diagramme de réseau
plt.figure(figsize=(10,10))
nx.draw_networkx(G,
                 node_shape = "s",
                 node_color = "c", 
                 node_size = 500,
                 edge_color = "gray", 
                 font_family = "IPAexGothic") #Spécification de la police

plt.show()

• Afin de saisir le mécanisme de l'analyse de réseau de cooccurrence comme un grand flux, des détails tels que la définition de mots vides (mots à exclure) et le traitement des mots composés (par exemple, «individualisme» au lieu de «individu» et «principe») J'ai fermé les yeux.
• De plus, pour plus de commodité, je l'ai divisé en quatre étapes de travail suivantes. Il y a quatre étapes: ➀ préparation des données de texte, ➁ création de données de cooccurrence, ➂ création de données de dessin et ➃ dessin de diagramme de réseau. Cependant, en général, je pense que cela se comprend en trois étapes: ➊ le prétraitement, ➋ l'analyse et ➌ la visualisation.
• Surtout ➊ Je pense que le prétraitement est le cœur du traitement du langage naturel. En fait, il peut être incorporé dans le cadre de ➋ dans le script, mais en bref, il s'agit de "comment extraire les mots nécessaires des données brutes". Quel type de point de vue analytique et quels critères utiliser pour extraire les mots? Il apparaîtra directement dans les résultats de l'analyse, ce qui affectera l'interprétation. C'est l'unité de travail qui demande le plus de considération et qui prend du temps et de l'énergie.