Python: texte japonais: caractéristique de la parole à partir de la continuité des mots
Connaître la continuité des mots
Séparation du texte parlé
Dans le post précédent, je me suis concentré sur Word Similarity et j'ai appris à traiter et analyser les données. Ici, vous découvrirez l'analyse des données en mettant l'accent sur la continuité des mots.
Tout d'abord, à titre de critique, j'écrirai le code du traitement des chaînes de caractères à l'aide d'expressions régulières et l'écriture de division par Janome.
import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
#Création d'un ensemble de données vocales non interrompu
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
label_text = []
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
for turn in json_data['turns']:
turn_index = turn['turn-index']
speaker = turn['speaker']
utterance = turn['utterance']
if turn_index != 0:
if speaker == 'U':
u_text = ''
u_text = utterance
else:
a = ''
for annotate in turn['annotations']:
a = annotate['breakdown']
tmp1 = str(a) + '\t' + u_text
tmp2 = tmp1.split('\t')
label_text.append(tmp2)
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']
t = Tokenizer()
#Créez une liste vide pour stocker les mots séparés
wakatiO = []
tmp1 = []
tmp2 = ''
#Lire ligne par ligne
for row in df_label_text_O.values.tolist():
#Supprimer les chaînes inutiles avec des expressions régulières
reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
reg_row = reg_row.replace('\n', '')
#Séparez les mots avec Janome et stockez les mots dans une liste
tmp1 = t.tokenize(reg_row, wakati=True)
wakatiO.append(tmp1)
tmp1 = []
#Afficher les mots séparés
print(wakatiO)
Créer un dictionnaire de mots
Nous quantifierons les mots pour faciliter leur utilisation dans une analyse ultérieure. Afin de numériser, créez une liste de conversion (dictionnaire) pour attribuer des identifiants aux mots. Ici, nous attribuerons les numéros de série par ordre décroissant du nombre d'occurrences de mots.
Divisez l'ensemble de données, puis comptez le nombre d'occurrences des mots et triez-les par ordre décroissant
Cliquez ici pour des exemples d'utilisation
import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools
#Création d'un ensemble de données vocales non interrompu
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
label_text = []
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
for turn in json_data['turns']:
turn_index = turn['turn-index']
speaker = turn['speaker']
utterance = turn['utterance']
if turn_index != 0:
if speaker == 'U':
u_text = ''
u_text = utterance
else:
a = ''
for annotate in turn['annotations']:
a = annotate['breakdown']
tmp1 = str(a) + '\t' + u_text
tmp2 = tmp1.split('\t')
label_text.append(tmp2)
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']
#Séparez et supprimez les chaînes inutiles avec des expressions régulières
t = Tokenizer()
wakatiO = []
tmp1 = []
tmp2 = ''
for row in df_label_text_O.values.tolist():
reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
reg_row = reg_row.replace('\n', '')
tmp1 = t.tokenize(reg_row, wakati=True)
wakatiO.append(tmp1)
tmp1 = []
#① Comptez le nombre d'apparitions de mots
word_freq = Counter(itertools.chain(*wakatiO))
#② Triez les mots par ordre d'apparition et ajoutez-les au dic
dic = []
for word_uniq in word_freq.most_common():
dic.append(word_uniq[0])
#③ Créez un dictionnaire en donnant des identifiants aux mots
# enumerate(dic)Utilisation de l'instruction for`dic`Index de`i`, Éléments`word_uniq`Accéder à
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
dic_inv.update({word_uniq: i})
#Afficher le dictionnaire
print(dic_inv)
Compter le nombre d'occurrences de mots
Pour compter le nombre d'occurrences d'un mot
Avec la classe Counter de la bibliothèque standard Python
itertools.chain()Est utilisé.
①Counter
Comptez le nombre d'éléments.
collections.Counter()Si vous passez une liste ou appuyez sur
Un objet Counter est créé avec l'élément comme clé et le nombre d'occurrences comme valeur.
Vous pouvez également utiliser des méthodes de type dictionnaire
Liste des clés clés(), Liste des valeurs valeurs(), Clé et
Liste des tuples d'éléments de paires de valeurs()Peut être obtenu.
import collections
#liste`list_`Générer un
list_ = ['a', 'c', 'a', 'c', 'b', 'b', 'c', 'c', 'a']
# `list_`Comptez les éléments de
C = collections.Counter(list_)
#Compte résultat
print(C)
Counter({'c': 4, 'a': 3, 'b': 2})
#Si vous spécifiez un élément, le résultat du comptage est renvoyé.
print(C['c'])
4
#Si vous spécifiez un élément qui n'est pas inclus`0`rends le
print(C['d'])
0
#Par ordre d'apparence, comptez(élément,Nombre d'apparitions)Renvoie un taple sous la forme de
print(C.most_common())
[('c', 4), ('a', 3), ('b', 2)]
#Obtenez le deuxième élément du taple
most_common = C.most_common()
print(most_common[1])
('a', 3)
Aplatir une liste multidimensionnelle à une dimension
②itertools.chain
Aplatit une liste multidimensionnelle à une dimension.
La liste est[1,2,3,],[4,5,6]Même si ça ressemble à
Vous pouvez accéder aux éléments de chaque liste.
Plusieurs listes entraîneront une erreur,*Et passez-le comme une seule liste.
import itertools
from collections import Counter
b = [['A', 'B', 'C',],['D', 'E', 'F']]
print(list(itertools.chain(*b)))
['A', 'B', 'C', 'D', 'E', 'F']
a = Counter(itertools.chain(*b))
print(a)
Counter({'A': 1, 'B': 1, 'C': 1, 'D': 1, 'E': 1, 'F': 1})
Tri des mots
Comment trier les mots
③most_common(n)Est utilisé.
Renvoie une liste d'éléments triés par ordre décroissant de quantité. Si n est spécifié, n taples sera renvoyé de celui avec le plus grand nombre. Si n est omis, tous les éléments sont renvoyés.
from collections import Counter
list_ = ['a', 'c', 'a', 'c', 'b', 'b', 'c', 'c', 'a']
C = Counter(list_)
print(C)
Counter({'c': 4, 'a': 3, 'b': 2})
#Par ordre d'apparence, comptez(élément,Nombre d'apparitions)Renvoie un taple sous la forme de
print(C.most_common())
[('c', 4), ('a', 3), ('b', 2)]
print(C.most_common(2))
[('c', 4), ('a', 3)]
#Obtenez le deuxième élément et les suivants du taple
mc = C.most_common()
print(mc[1:])
[('a', 3), ('b', 2)]
Convertir des mots en nombres
Pour les ensembles de données vocales non interrompues Convertir des mots en identifiants à l'aide du dictionnaire créé Stockez dans une nouvelle baie.
wakatiO contient une liste de mots séparés.
print(wakatiO[0:1])
[['Bonjour', '。'], ['Je suis désolé', '、', 'tu', 'Est', 'Qui', 'est', 'Ou', '？']]
Le mot avec l'ID est stocké dans dic_inv.
print(dic_inv['Bonjour'])
218
print(dic_inv['。'])
2
Utilisation de la méthode ou de l'instruction et de la référence de données de type dictionnaire (contenu expliqué dans la section précédente) Convertissez la liste de mots de wakatiO en ID de dic_inv.
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
[218, 2]
La seconde mi-temps pour waka à wakatiO
Passez la liste de mots wakatiO à waka un par un.
Le milieu du mot dans waka est
Passez la liste de mots waka mot à mot.
Premier demi-dic_inv[word]Est
L'ID correspondant au mot est dic_Obtenez de l'inv.
Cliquez ici pour des exemples d'utilisation
import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools
#Création d'un ensemble de données vocales non interrompu
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
label_text = []
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
for turn in json_data['turns']:
turn_index = turn['turn-index']
speaker = turn['speaker']
utterance = turn['utterance']
if turn_index != 0:
if speaker == 'U':
u_text = ''
u_text = utterance
else:
a = ''
for annotate in turn['annotations']:
a = annotate['breakdown']
tmp1 = str(a) + '\t' + u_text
tmp2 = tmp1.split('\t')
label_text.append(tmp2)
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']
#Séparez et supprimez les chaînes inutiles avec des expressions régulières
t = Tokenizer()
wakatiO = []
tmp1 = []
tmp2 = ''
for row in df_label_text_O.values.tolist():
reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
reg_row = reg_row.replace('\n', '')
tmp1 = t.tokenize(reg_row, wakati=True)
wakatiO.append(tmp1)
tmp1 = []
#Compter, trier et ajouter des mots à dic
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
dic.append(word_uniq[0])
#Créer un dictionnaire en attribuant des identifiants aux mots
# enumerate(dic)Utilisation de l'instruction for`dic`Index de`i`, Éléments`word_uniq`Accéder à
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
dic_inv.update({word_uniq: i})
#① Convertir les mots en ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
print(wakatiO_n)
Obtenir l'identifiant du dictionnaire
dic_inv[Mots divisés]Est utilisé.
Même contenu, mais si vous l'écrivez à nouveau Convertissez la liste de mots de wakatiO en ID de dic_inv.
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
[218, 2]
La seconde mi-temps pour waka à wakatiO
Passez la liste de mots wakatiO à waka un par un.
Le milieu du mot dans waka est
Passez la liste de mots waka mot à mot.
Premier demi-dic_inv[word]Est
L'ID correspondant au mot est dic_Obtenez de l'inv.
Convertissez la liste de mots de wakatiO en ID de dic_inv.
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
[218, 2]
La seconde mi-temps pour waka à wakatiO
Passez la liste de mots wakatiO à waka un par un.
Le milieu du mot dans waka est
Passez la liste de mots waka mot à mot.
Premier demi-dic_inv[word]Est
L'ID correspondant au mot est dic_Obtenez de l'inv.
Connaître les caractéristiques du texte à partir de la continuité des mots
Qu'est-ce que N-gramme
Lors de l'analyse des données en langage naturel, si le but est de classer du texte Créez une matrice de document Word à partir de données Word.
De plus, si le but est d'extraire des sujets du texte
N-Créez un modèle de gramme.
N-gramme est une méthode de division de texte en N caractères consécutifs.
Dans un exemple familier, il est utilisé comme index du système de recherche. 1 gramme (unigramme) lorsque N = 1 et 2 grammes (bigramme) lorsque N = 2 Lorsque N = 3, il est appelé 3 grammes (trigramme).
[Texte] Aiueo
【 1-gramme] Ah|je|U|e|Oh
【 2-gramme] Ai|Dire|haut|Eo
【 3-gramme]|Iue|Ueo
Vous pouvez également diviser le texte en N mots consécutifs.
[Texte] Il fait beau aujourd'hui.
【 1-gramme] Aujourd'hui|Est|Ensoleillé|est| 。
【 2-gramme] Aujourd'hui-Est|Est-Ensoleillé|Ensoleillé-est|est-。
【 3-gramme] Aujourd'hui-Est-Ensoleillé| Est-Ensoleillé-est| Ensoleillé-est-。
Pour une matrice de document Word représentant la cooccurrence (si elle apparaît dans la même phrase) de mots contenus dans le même texte N-gram représente la continuité des mots (dans quel ordre ils apparaissent).
Parce que je veux extraire des sujets de mots et les analyser ici Nous allons créer ce dernier modèle N-gramme, en particulier le modèle 2 grammes.
Tout d'abord, créons un modèle de 2 grammes avec un exemple simple.
word = ['aujourd'hui', 'Est', 'Ensoleillé', 'est', '。']
bigram = []
for i in range(len(word)-1):
bigram.append([word[i], word[i+1]])
print(bigram)
>>>Résultat de sortie
[['aujourd'hui', 'Est'], ['Est', 'Ensoleillé'], ['Ensoleillé', 'est'], ['est', '。']]
2-Création d'une liste de grammes
Créez une liste de 2 grammes à partir de l'ensemble de données dans lequel les mots créés dans Convertir les mots en nombres sont convertis en ID.
2-Pour créer une liste de grammes
Regrouper par regroupement par rapport à DataFrame()Quand
Somme pour calculer la valeur totale()Est utilisé.
Voyons d'abord comment utiliser groupby () et sum ().
from pandas import DataFrame
#Préparer DataFrame
df=DataFrame([['AA','Camela',150000,20000],
['BB','Camera',70000,10000],
['AA','earphone',2000,200],
['AA','Video',3000,150],
['BB','earphone',200000,8000],
['BB','Camera',50000,5000],
['AA','Video',1000,200]],
columns=['CUSTOMER','PRODUCT','PRICE','DISCOUNT'])
df
>>>Résultat de sortie
CUSTOMER PRODUCT PRICE DISCOUNT
0 AA Camela 150000 20000
1 BB Camera 70000 10000
2 AA earphone 2000 200
3 AA Video 3000 150
4 BB earphone 200000 8000
5 BB Camera 50000 5000
6 AA Video 1000 200
#Regrouper sous une condition et calculer la somme
grouped = df.groupby('CUSTOMER').sum()
grouped
>>>Résultat de sortie
PRICE DISCOUNT
CUSTOMER
AA 156000 20550
BB 320000 23000
#Grouper par sous plusieurs conditions et calculer la somme
grouped = df.groupby(['CUSTOMER','PRODUCT']).sum()
grouped
>>>Résultat de sortie
PRICE DISCOUNT
CUSTOMER PRODUCT
AA Camela 150000 20000
Video 4000 350
earphone 2000 200
BB Camera 120000 15000
earphone 200000 8000
2-En créant une liste de grammes Parce que cela signifie que les 2 grammes en double apparaissent plusieurs fois Je pense que c'est une combinaison importante.
Grouper par () et sum () pour calculer le nombre d'occurrences (= poids).
Cliquez ici pour des exemples d'utilisation
import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools
#Création d'un ensemble de données vocales non interrompu
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
label_text = []
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
for turn in json_data['turns']:
turn_index = turn['turn-index']
speaker = turn['speaker']
utterance = turn['utterance']
if turn_index != 0:
if speaker == 'U':
u_text = ''
u_text = utterance
else:
a = ''
for annotate in turn['annotations']:
a = annotate['breakdown']
tmp1 = str(a) + '\t' + u_text
tmp2 = tmp1.split('\t')
label_text.append(tmp2)
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']
#Séparez et supprimez les chaînes inutiles avec des expressions régulières
t = Tokenizer()
wakatiO = []
tmp1 = []
tmp2 = ''
for row in df_label_text_O.values.tolist():
reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
reg_row = reg_row.replace('\n', '')
tmp1 = t.tokenize(reg_row, wakati=True)
wakatiO.append(tmp1)
tmp1 = []
#Compter, trier et ajouter des mots à dic
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
dic.append(word_uniq[0])
#Créer un dictionnaire en attribuant des identifiants aux mots
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
dic_inv.update({word_uniq: i})
#Convertir des mots en ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
# 2-Créer une liste de grammes
tmp = []
bigramO = []
for i in range(0, len(wakatiO_n)):
row = wakatiO_n[i]
# 2-Créer un gramme
for j in range(len(row)-1):
tmp.append([row[j], row[j+1]])
bigramO.extend(tmp)
tmp = []
#Dupliquer 2-Compter le nombre de grammes et exprimer au format DataFrame
#Tableau`bigramO`Vers DataFrame et définir la colonne
df_bigramO = pd.DataFrame(bigramO)
df_bigramO = df_bigramO.rename(columns={0: 'node1', 1: 'node2'})
# `weight`Ajouter des colonnes et unifier les valeurs avec 1
df_bigramO['weight'] = 1
# 2-Comptez le nombre de gramme
df_bigramO = df_bigramO.groupby(['node1', 'node2'], as_index=False).sum()
#Extraire une liste avec plus d'une occurrence
#Nombre d'apparitions=`weight`Valeur somme de
df_bigramO = df_bigramO[df_bigramO['weight'] > 1]
# 2-Affichage du gramme
df_bigramO.head(10)
Créer un réseau de 2 grammes
Dans Word Similarity
Nœud de mot
Similitude entre les mots en tant qu'arêtes et leurs poids
J'ai créé un graphique non dirigé.
ici
Nœud de mot
Le nombre d'occurrences d'une paire de mots comme arête et son poids
Créez un graphe orienté (réseau orienté).
Nous pensons que les graphes orientés sont significatifs dans l'ordre d'apparition. Les exemples incluent l'ordre dans lequel les mots apparaissent et l'échange de communications au sein d'une organisation. Tout d'abord, créons un graphique dirigé et visualisons-le en utilisant la liste de 2 grammes créée lors de la création d'une liste de 2 grammes.
Cliquez ici pour des exemples d'utilisation
import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools
import networkx as nx
import matplotlib.pyplot as plt
#Création d'un ensemble de données vocales non interrompu
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
label_text = []
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
for turn in json_data['turns']:
turn_index = turn['turn-index']
speaker = turn['speaker']
utterance = turn['utterance']
if turn_index != 0:
if speaker == 'U':
u_text = ''
u_text = utterance
else:
a = ''
for annotate in turn['annotations']:
a = annotate['breakdown']
tmp1 = str(a) + '\t' + u_text
tmp2 = tmp1.split('\t')
label_text.append(tmp2)
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']
#Séparez et supprimez les chaînes inutiles avec des expressions régulières
t = Tokenizer()
wakatiO = []
tmp1 = []
tmp2 = ''
for row in df_label_text_O.values.tolist():
reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
reg_row = reg_row.replace('\n', '')
tmp1 = t.tokenize(reg_row, wakati=True)
wakatiO.append(tmp1)
tmp1 = []
#Compter, trier et ajouter des mots à dic
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
dic.append(word_uniq[0])
#Créer un dictionnaire en attribuant des identifiants aux mots
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
dic_inv.update({word_uniq: i})
#Convertir des mots en ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
# 2-Créer une liste de grammes
tmp = []
bigramO = []
for i in range(0, len(wakatiO_n)):
row = wakatiO_n[i]
# 2-Créer un gramme
for j in range(len(row)-1):
tmp.append([row[j], row[j+1]])
bigramO.extend(tmp)
tmp = []
#Tableau`bigramO`Vers DataFrame et définir la colonne
df_bigramO = pd.DataFrame(bigramO)
df_bigramO = df_bigramO.rename(columns={0: 'node1', 1: 'node2'})
# `weight`Ajouter des colonnes et unifier les valeurs avec 1
df_bigramO['weight'] = 1
# 2-Comptez le nombre de gramme
df_bigramO = df_bigramO.groupby(['node1', 'node2'], as_index=False).sum()
#Extraire une liste avec plus d'une occurrence
df_bigramO = df_bigramO[df_bigramO['weight'] > 1]
#Créer un graphique dirigé
G_bigramO = nx.from_pandas_edgelist(df_bigramO, 'node1', 'node2', ['weight'], nx.DiGraph)
#Visualisez le graphique créé
#Paramètres de mise en page
pos = nx.spring_layout(G_bigramO)
nx.draw_networkx(G_bigramO, pos)
plt.show()
Création d'un graphe orienté (réseau orienté)
Ajoutez nx.DiGraph à l'argument de nx.from_pandas_edgelist () utilisé pour créer le graphe non orienté. Pour plus d'informations sur les autres arguments, voir 2.2.2 Création d'un réseau de similarité.
G_corlistO = nx.from_pandas_edgelist(df_corlistO, 'node1', 'node2', ['weight'], nx.DiGraph)
Visualisation du graphe (réseau)
C'est exactement la même chose que la visualisation de graphes non orientés.
#Bibliothèque`Matplotlib`De`pyplot`Importer
from matplotlib import pyplot
#Calculez la position d'affichage optimale pour chaque nœud
pos = nx.spring_layout(graph)
#Dessinez un graphique
nx.draw_networkx(graph, pos)
#Afficher des graphiques à l'aide de Matplotlib
plt.show()
Fonctionnalités réseau de 2 grammes
Même s'il s'agit d'un graphe orienté, l'idée est la même que celle d'un graphe non orienté. Puisqu'il est difficile de saisir les caractéristiques même en un coup d'œil sur le graphique visualisé en créant un réseau de 2 grammes Saisir quantitativement les caractéristiques à l'aide d'indicateurs.
Encore une fois, calculons le coefficient de cluster et la centralité de la médiation.
Cliquez ici pour des exemples d'utilisation
import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools
import networkx as nx
import matplotlib.pyplot as plt
#Création d'un ensemble de données vocales non interrompu
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
label_text = []
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
for turn in json_data['turns']:
turn_index = turn['turn-index']
speaker = turn['speaker']
utterance = turn['utterance']
if turn_index != 0:
if speaker == 'U':
u_text = ''
u_text = utterance
else:
a = ''
for annotate in turn['annotations']:
a = annotate['breakdown']
tmp1 = str(a) + '\t' + u_text
tmp2 = tmp1.split('\t')
label_text.append(tmp2)
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']
#Séparez et supprimez les chaînes inutiles avec des expressions régulières
t = Tokenizer()
wakatiO = []
tmp1 = []
tmp2 = ''
for row in df_label_text_O.values.tolist():
reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
reg_row = reg_row.replace('\n', '')
tmp1 = t.tokenize(reg_row, wakati=True)
wakatiO.append(tmp1)
tmp1 = []
#Compter, trier et ajouter des mots à dic
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
dic.append(word_uniq[0])
#Créer un dictionnaire en attribuant des identifiants aux mots
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
dic_inv.update({word_uniq: i})
#Convertir des mots en ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
# 2-Créer une liste de grammes
tmp = []
bigramO = []
for i in range(0, len(wakatiO_n)):
row = wakatiO_n[i]
# 2-Créer un gramme
for j in range(len(row)-1):
tmp.append([row[j], row[j+1]])
bigramO.extend(tmp)
tmp = []
#Tableau`bigramO`Vers DataFrame et définir la colonne
df_bigramO = pd.DataFrame(bigramO)
df_bigramO = df_bigramO.rename(columns={0: 'node1', 1: 'node2'})
# `weight`Ajouter des colonnes et unifier les valeurs avec 1
df_bigramO['weight'] = 1
# 2-Comptez le nombre de gramme
df_bigramO = df_bigramO.groupby(['node1', 'node2'], as_index=False).sum()
#Extraire une liste avec plus d'une occurrence
df_bigramO = df_bigramO[df_bigramO['weight'] > 1]
#Création de graphiques dirigés
G_bigramO = nx.from_pandas_edgelist(
df_bigramO, 'node1', 'node2', ['weight'], nx.DiGraph)
#Réseau parlant qui n'est pas cassé
#① Calcul du coefficient de cluster moyen
print('Coefficient de cluster moyen')
print(nx.average_clustering(G_bigramO, weight='weight'))
print()
#② Calcul de la centralité de la médiation
bc = nx.betweenness_centrality(G_bigramO, weight='weight')
print('Centralité de la médiation')
for k, v in sorted(bc.items(), key=lambda x: -x[1]):
print(str(k) + ': ' + str(v))
Calcul du coefficient de cluster moyen
Plus le coefficient de cluster moyen de tous les nœuds est élevé, plus le réseau est dense. La moyenne des coefficients de cluster est calculée à l'aide de nx.average_clustering ().
nx.average_clustering(G, weight=None)
G
Spécifiez le graphique.
(Graphe dirigé G créé dans la section précédente_bigramO)
weight
Spécifie l'arête avec le nombre à utiliser comme poids. Si aucun, le poids de chaque arête sera de 1.
Calcul de la centralité de la médiation
Il est déterminé par le nombre de nœuds inclus dans l'itinéraire le plus court entre tous les nœuds. En d'autres termes, les nœuds les plus utilisés pour transmettre efficacement des informations sont plus intermédiaires et centraux.
nx.betweenness_centrality(G, weight=None)
G
Spécifiez le graphique.
(Graphe dirigé G créé dans la section précédente_bigramO)
weight
Spécifie l'arête avec le nombre à utiliser comme poids. Si aucun, tous les poids de bord sont considérés comme égaux.
Impact réseau de 2 grammes
Nous avons mis en place des indicateurs pour comprendre quantitativement les caractéristiques du réseau. plus loin
Utilisons une distribution de degrés pour voir comment chaque mot affecte les uns les autres.
Parce que les nœuds de mots ont une orientation dans des réseaux dirigés
Commande:Un mot est influencé par un autre
Commande:Un mot en affecte un autre
Je vais l'examiner séparément.
Cliquez ici pour des exemples d'utilisation
import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools
import networkx as nx
import matplotlib.pyplot as plt
#Création d'un ensemble de données vocales non interrompu
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
label_text = []
for file in file_dir[:100]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
for turn in json_data['turns']:
turn_index = turn['turn-index']
speaker = turn['speaker']
utterance = turn['utterance']
if turn_index != 0:
if speaker == 'U':
u_text = ''
u_text = utterance
else:
a = ''
for annotate in turn['annotations']:
a = annotate['breakdown']
tmp1 = str(a) + '\t' + u_text
tmp2 = tmp1.split('\t')
label_text.append(tmp2)
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
df_label_text_O = df_label_text[df_label_text[0] == 'O']
#Séparez et supprimez les chaînes inutiles avec des expressions régulières
t = Tokenizer()
wakatiO = []
tmp1 = []
tmp2 = ''
for row in df_label_text_O.values.tolist():
reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
reg_row = reg_row.replace('\n', '')
tmp1 = t.tokenize(reg_row, wakati=True)
wakatiO.append(tmp1)
tmp1 = []
#Compter, trier et ajouter des mots à dic
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
dic.append(word_uniq[0])
#Créer un dictionnaire en attribuant des identifiants aux mots
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
dic_inv.update({word_uniq: i})
#Convertir des mots en ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
# 2-Créer une liste de grammes
tmp = []
bigramO = []
for i in range(0, len(wakatiO_n)):
row = wakatiO_n[i]
# 2-Créer un gramme
for j in range(len(row)-1):
tmp.append([row[j], row[j+1]])
bigramO.extend(tmp)
tmp = []
#Tableau`bigramO`Vers DataFrame et définir la colonne
df_bigramO = pd.DataFrame(bigramO)
df_bigramO = df_bigramO.rename(columns={0: 'node1', 1: 'node2'})
# `weight`Ajouter des colonnes et unifier les valeurs avec 1
df_bigramO['weight'] = 1
# 2-Comptez le nombre de gramme
df_bigramO = df_bigramO.groupby(['node1', 'node2'], as_index=False).sum()
#Extraire une liste avec plus d'une occurrence
df_bigramO = df_bigramO[df_bigramO['weight'] > 1]
#Création de graphiques dirigés
G_bigramO = nx.from_pandas_edgelist(
df_bigramO, 'node1', 'node2', ['weight'], nx.DiGraph)
#Réseau parlant qui n'est pas cassé
#Trouvez la fréquence de la commande
indegree = sorted([d for n, d in G_bigramO.in_degree(weight='weight')], reverse=True)
indegreeCount = Counter(indegree)
indeg, cnt = zip(*indegreeCount.items())
#Trouvez la fréquence de la commande
outdegree = sorted([d for n, d in G_bigramO.out_degree(weight='weight')], reverse=True)
outdegreeCount = Counter(outdegree)
outdeg, cnt = zip(*outdegreeCount.items())
#Créer une distribution de diplômes
plt.subplot(1, 2, 1)
plt.bar(indeg, cnt, color='r')
plt.title('in_degree')
plt.subplot(1, 2, 2)
plt.bar(outdeg, cnt, color='b')
plt.title('out_degree')
plt.show()
Indegree
Qu'est-ce que indegree? Dans un graphe orienté, dites le nombre de côtés qui entrent dans l'apex Dans le graphe non orienté, il s'agit du nombre de côtés de connexion.
Pour découvrir la puissance du réseau Utilisez la méthode in_degree (). Le résultat est renvoyé sous la forme de (numéro de nœud, ordre d'entrée).
# G_Vérifiez l'ordre de bigramO
print(G_bigramO.in_degree(weight='weight'))
>>>Résultat de sortie
[(1, 208), (2, 155), (4, 148), (5, 126), (7, 47)・ ・ ・]
Outdegree
Qu'est-ce que le hors degré Dans un graphe orienté, dites le nombre de côtés sortant du sommet Dans le graphe non orienté, il s'agit du nombre de côtés de connexion.
Utilisez la méthode out_degree () pour connaître l'ordre. Le résultat est renvoyé sous la forme (numéro de nœud, ordre).
# G_Découvrez l'ordre de bigramO
print(G_bigramO.out_degree(weight='weight'))
>>>Résultat de sortie
[(1, 248), (2, 12), (4, 83), (5, 65), (7, 57)・ ・ ・]
Recommended Posts