Kennen Sie die Kontinuität der Wörter

Trennung von gesprochenem Text

Im vorherigen Beitrag habe ich mich auf Wortähnlichkeit konzentriert und gelernt, wie Daten verarbeitet und analysiert werden. Hier lernen Sie die Datenanalyse mit Schwerpunkt auf Wortkontinuität kennen.

Zunächst werde ich zur Überprüfung den Code der Zeichenfolgenverarbeitung mit regulären Ausdrücken und die Teilungsschrift von Janome schreiben.

import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer


#Erstellen eines nicht fehlerhaften Sprachdatensatzes
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()

#Erstellen Sie eine leere Liste, um die getrennten Wörter zu speichern
wakatiO = []
tmp1 = []
tmp2 = ''

#Zeile für Zeile lesen
for row in df_label_text_O.values.tolist():

    #Entfernen Sie unnötige Zeichenfolgen mit regulären Ausdrücken
    reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
    reg_row = reg_row.replace('\n', '')

    #Trennen Sie Wörter mit Janome und speichern Sie Wörter in einer Liste
    tmp1 = t.tokenize(reg_row, wakati=True)
    wakatiO.append(tmp1)
    tmp1 = []

#Getrennte Wörter anzeigen
print(wakatiO)

Erstellen eines Wortwörterbuchs

Wir werden die Wörter zur Vereinfachung der Verwendung in der nachfolgenden Analyse quantifizieren. Erstellen Sie zum Digitalisieren eine Konvertierungsliste (Wörterbuch) zum Zuweisen von IDs zu Wörtern. Hier werden wir Seriennummern in absteigender Reihenfolge der Anzahl der Wortvorkommen zuweisen.

Teilen Sie den Datensatz, zählen Sie die Anzahl der Wortvorkommen und sortieren Sie sie in absteigender Reihenfolge

Klicken Sie hier für Anwendungsbeispiele

import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools


#Erstellen eines nicht fehlerhaften Sprachdatensatzes
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']

#Trennen und entfernen Sie unnötige Zeichenfolgen mit regulären Ausdrücken
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 = []

#① Zählen Sie die Anzahl der Wörter
word_freq = Counter(itertools.chain(*wakatiO))

#② Sortieren Sie die Wörter in der Reihenfolge ihrer Erscheinungsnummer und fügen Sie sie zu dic hinzu
dic = []
for word_uniq in word_freq.most_common():
    dic.append(word_uniq[0])

#③ Erstellen Sie ein Wörterbuch, indem Sie Wörtern IDs geben
# enumerate(dic)Verwenden der for-Anweisung`dic`Index von`i`, Elemente`word_uniq`Komm zu
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
    dic_inv.update({word_uniq: i})

#Wörterbuch anzeigen
print(dic_inv)

Zählen der Anzahl der Wörter

Zählen der Anzahl der Vorkommen eines Wortes

Mit der Counter-Klasse der Python-Standardbibliothek
itertools.chain()Wird genutzt.

①Counter

Zählen Sie die Anzahl der Elemente.
collections.Counter()Wenn Sie eine Liste übergeben oder an tippen
Ein Zählerobjekt wird mit dem Element als Schlüssel und der Anzahl der Vorkommen als Wert erstellt.

Sie können auch Methoden vom Typ Wörterbuch verwenden
Liste der Schlüssel Schlüssel(), Liste der Werte Werte(), Schlüssel und
Liste der Tupel von Wertpaarelementen()Kann erhalten werden.

import collections
#aufführen`list_`Generieren Sie a
list_ = ['a', 'c', 'a', 'c', 'b', 'b', 'c', 'c', 'a']

# `list_`Zähle die Elemente von
C = collections.Counter(list_)

#Ergebnis zählen
print(C)
Counter({'c': 4, 'a': 3, 'b': 2})

#Wenn Sie ein Element angeben, wird das Zählergebnis zurückgegeben.
print(C['c'])
4
#Wenn Sie ein Element angeben, das nicht enthalten ist`0`Gib es zurück
print(C['d'])
0

#In der Reihenfolge des Aussehens zählen(Element,Anzahl der Auftritte)Gibt ein Tupel in Form von zurück
print(C.most_common())
[('c', 4), ('a', 3), ('b', 2)]

#Holen Sie sich das zweite Element des Taple
most_common = C.most_common()
print(most_common[1])
('a', 3)

Reduzieren Sie eine mehrdimensionale Liste auf eine Dimension

②itertools.chain

Reduziert eine mehrdimensionale Liste auf eine Dimension.
Die Liste ist[1,2,3,],[4,5,6]Auch wenn es so aussieht
Sie können auf die Elemente jeder Liste zugreifen.
Mehrere Listen führen zu einem Fehler.*Und übergeben Sie es als einzelne 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})

Wörter sortieren

Wie man Wörter sortiert

③most_common(n)Wird genutzt.

Gibt eine Liste mit Artikeln zurück, die in absteigender Reihenfolge der Menge sortiert sind. Wenn n angegeben ist, werden n Taples von dem mit der größten Anzahl zurückgegeben. Wenn n weggelassen wird, werden alle Elemente zurückgegeben.

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})

#In der Reihenfolge des Aussehens zählen(Element,Anzahl der Auftritte)Gibt ein Tupel in Form von zurück
print(C.most_common())
[('c', 4), ('a', 3), ('b', 2)]

print(C.most_common(2))
[('c', 4), ('a', 3)]

#Holen Sie sich das zweite und nachfolgende Element des Taple
mc = C.most_common()
print(mc[1:])
[('a', 3), ('b', 2)]

Konvertieren Sie Wörter in Zahlen

Für nicht fehlerhafte Sprachdatensätze Konvertieren Sie Wörter mithilfe des erstellten Wörterbuchs in IDs In einem neuen Array speichern.

wakatiO enthält eine Liste getrennter Wörter.

print(wakatiO[0:1])
[['Guten Morgen', '。'], ['Es tut mir Leid', '、', 'Sie', 'Ist', 'Wer', 'ist', 'Oder', '？']]

Das Wort mit der ID wird in dic_inv gespeichert.

print(dic_inv['Guten Morgen'])
218
print(dic_inv['。'])
2

Verwenden der Datenreferenz für Methode oder Anweisung und Wörterbuchtyp (Inhalt im vorherigen Abschnitt erläutert) Konvertieren Sie die Liste der Wörter in wakatiO in die ID von dic_inv.

wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
[218, 2]

Die zweite Hälfte für Waka in WakatiO
Übergeben Sie die wakatiO-Wortliste nacheinander an waka.

Die Mitte für Wort in Waka ist
Übergeben Sie die Waka-Wortliste Wort für Wort.

Erste Hälfte dic_inv[word]Ist
Die ID, die dem Wort entspricht, ist dic_Holen Sie sich von inv.

Klicken Sie hier für Anwendungsbeispiele

import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools


#Erstellen eines nicht fehlerhaften Sprachdatensatzes
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']

#Trennen und entfernen Sie unnötige Zeichenfolgen mit regulären Ausdrücken
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 = []

#Zähle, sortiere und füge Wörter zu dic hinzu
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
    dic.append(word_uniq[0])

#Erstellen Sie ein Wörterbuch, indem Sie Wörtern IDs zuweisen
# enumerate(dic)Verwenden der for-Anweisung`dic`Index von`i`, Elemente`word_uniq`Komm zu
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
    dic_inv.update({word_uniq: i})

#① Konvertieren Sie Wörter in ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
print(wakatiO_n)

ID aus dem Wörterbuch abrufen

dic_inv[Geteilte Wörter]Wird genutzt.

Gleicher Inhalt, aber wenn Sie ihn noch einmal schreiben Konvertieren Sie die Liste der Wörter in wakatiO in die ID von dic_inv.

wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
[218, 2]

Die zweite Hälfte für Waka in WakatiO
Übergeben Sie die wakatiO-Wortliste nacheinander an waka.

Die Mitte für Wort in Waka ist
Übergeben Sie die Waka-Wortliste Wort für Wort.

Erste Hälfte dic_inv[word]Ist
Die ID, die dem Wort entspricht, ist dic_Holen Sie sich von inv.

Konvertieren Sie die Liste der Wörter in wakatiO in die ID von dic_inv.

wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]
[218, 2]

Die zweite Hälfte für Waka in WakatiO
Übergeben Sie die wakatiO-Wortliste nacheinander an waka.

Die Mitte für Wort in Waka ist
Übergeben Sie die Waka-Wortliste Wort für Wort.

Erste Hälfte dic_inv[word]Ist
Die ID, die dem Wort entspricht, ist dic_Holen Sie sich von inv.

Kennen Sie die Eigenschaften des Textes aus der Kontinuität der Wörter

Was ist N-Gramm?

Wenn bei der Analyse von Daten in natürlicher Sprache der Zweck darin besteht, Text zu klassifizieren Erstellen Sie eine Word-Dokumentmatrix aus Word-Daten.

Auch, wenn der Zweck darin besteht, Themen aus dem Text zu extrahieren
N-Erstellen Sie ein Gramm-Modell.

N-Gramm ist eine Methode zum Teilen von Text in N aufeinanderfolgende Zeichen.

In einem bekannten Beispiel wird es als Suchsystemindex verwendet. 1 Gramm (Unigramm) bei N = 1 und 2 Gramm (Bigram) bei N = 2 Wenn N = 3 ist, heißt es 3 Gramm (Trigramm).

[Text] Aiueo
【 1-Gramm] Ah|ich|U.|e|Oh
【 2-Gramm] Ai|Sagen|über|Eo
【 3-Gramm]|Iue|Ueo

Sie können den Text auch in N aufeinanderfolgende Wörter aufteilen.

[Text] Heute ist es sonnig.
【 1-Gramm] Heute|Ist|Sonnig|ist| 。
【 2-Gramm] Heute-Ist|Ist-Sonnig|Sonnig-ist|ist-。
【 3-Gramm] Heute-Ist-Sonnig| Ist-Sonnig-ist| Sonnig-ist-。

Für eine Wortdokumentmatrix, die das gleichzeitige Auftreten (ob es im selben Satz erscheint) von Wörtern darstellt, die im selben Text enthalten sind N-Gramm repräsentiert die Kontinuität von Wörtern (in welcher Reihenfolge sie erscheinen).

Weil ich Themen aus Wörtern extrahieren und hier analysieren möchte Wir werden das letztere N-Gramm-Modell erstellen, insbesondere das 2-Gramm-Modell.

Lassen Sie uns zunächst ein 2-Gramm-Modell mit einem einfachen Beispiel erstellen.

word = ['heute', 'Ist', 'Sonnig', 'ist', '。']
bigram = []

for i in range(len(word)-1):
    bigram.append([word[i], word[i+1]])

print(bigram)
>>>Ausgabeergebnis
[['heute', 'Ist'], ['Ist', 'Sonnig'], ['Sonnig', 'ist'], ['ist', '。']]

2-Erstellen einer Grammliste

Erstellen Sie eine 2-Gramm-Liste aus dem Datensatz, in der die unter Wörter in Zahlen konvertieren erstellten Wörter in IDs konvertiert werden.

2-So erstellen Sie eine Grammliste

Gruppieren durch Gruppieren gegen DataFrame()Wann
Summe zur Berechnung des Gesamtwertes()Wird genutzt.

Lassen Sie uns zunächst überprüfen, wie groupby () und sum () verwendet werden.

from pandas import DataFrame

#Bereiten Sie DataFrame vor
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

>>>Ausgabeergebnis
    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
#Gruppieren Sie unter einer Bedingung und berechnen Sie die Summe
grouped = df.groupby('CUSTOMER').sum()
grouped

>>>Ausgabeergebnis
           PRICE    DISCOUNT
CUSTOMER        
AA           156000      20550
BB           320000      23000
#Gruppieren Sie unter mehreren Bedingungen und berechnen Sie die Summe
grouped = df.groupby(['CUSTOMER','PRODUCT']).sum()
grouped

>>>Ausgabeergebnis
　　　　　　　　　　               PRICE    　　　　DISCOUNT
CUSTOMER    PRODUCT        
　AA    　　　　　Camela    　　　 　150000    　　　　  20000
　　　　　　　　　  Video    　　　　　 4000    　　　　　　 350
　　　　　　　　　earphone    　　　　　 2000    　　　　　　 200
　BB    　　　　　Camera    　　　　 120000    　　　　 　15000
　　　　　　　　　earphone    　　　   200000    　　　　　  8000

2-Beim Erstellen einer Grammliste Weil es bedeutet, dass das doppelte 2-Gramm mehrmals erscheint. Ich denke, es ist eine wichtige Kombination.

Gruppieren Sie nach () und sum (), um die Anzahl der Vorkommen (= Gewicht) zu berechnen.

Klicken Sie hier für Anwendungsbeispiele

import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
from collections import Counter
import itertools


#Erstellen eines nicht fehlerhaften Sprachdatensatzes
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']

#Trennen und entfernen Sie unnötige Zeichenfolgen mit regulären Ausdrücken
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 = []

#Zähle, sortiere und füge Wörter zu dic hinzu
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
    dic.append(word_uniq[0])

#Erstellen Sie ein Wörterbuch, indem Sie Wörtern IDs zuweisen
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
    dic_inv.update({word_uniq: i})

#Konvertieren Sie Wörter in ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]

# 2-Erstellen Sie eine Grammliste
tmp = []
bigramO = []

for i in range(0, len(wakatiO_n)):
    row = wakatiO_n[i]
    # 2-Ein Gramm erstellen
    for j in range(len(row)-1):
        tmp.append([row[j], row[j+1]])
    bigramO.extend(tmp)
    tmp = []

#Duplizieren 2-Zählen Sie die Anzahl der Gramm und drücken Sie sie im DataFrame-Format aus
#Array`bigramO`Zu DataFrame und Spalte setzen
df_bigramO = pd.DataFrame(bigramO)
df_bigramO = df_bigramO.rename(columns={0: 'node1', 1: 'node2'})

# `weight`Fügen Sie Spalten hinzu und vereinheitlichen Sie Werte mit 1
df_bigramO['weight'] = 1

# 2-Zählen Sie die Anzahl der Gramm
df_bigramO = df_bigramO.groupby(['node1', 'node2'], as_index=False).sum()

#Extrahieren Sie eine Liste mit mehr als 1 Vorkommen
#Anzahl der Auftritte=`weight`Summenwert von
df_bigramO = df_bigramO[df_bigramO['weight'] > 1]

# 2-Anzeige von Gramm
df_bigramO.head(10)

Erstellen eines 2-Gramm-Netzwerks

In Wortähnlichkeit

Wortknoten
Ähnlichkeit zwischen Wörtern als Kanten und deren Gewichten
Ich habe ein ungerichtetes Diagramm erstellt.

Hier

Wortknoten
Die Anzahl der Vorkommen eines Wortpaars als Kante und sein Gewicht
Erstellen Sie einen gerichteten Graphen (gerichtetes Netzwerk).

Wir denken, dass gerichtete Graphen in der Reihenfolge ihres Auftretens von Bedeutung sind. Beispiele sind die Reihenfolge, in der Wörter erscheinen, und der Austausch von Kommunikation innerhalb einer Organisation. Lassen Sie uns zunächst ein gerichtetes Diagramm erstellen und es mithilfe der 2-Gramm-Liste visualisieren, die bei der Erstellung der 2-Gramm-Liste erstellt wurde.

Klicken Sie hier für Anwendungsbeispiele

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


#Erstellen eines nicht fehlerhaften Sprachdatensatzes
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']

#Trennen und entfernen Sie unnötige Zeichenfolgen mit regulären Ausdrücken
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 = []

#Zähle, sortiere und füge Wörter zu dic hinzu
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
    dic.append(word_uniq[0])

#Erstellen Sie ein Wörterbuch, indem Sie Wörtern IDs zuweisen
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
    dic_inv.update({word_uniq: i})

#Konvertieren Sie Wörter in ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]

# 2-Erstellen Sie eine Grammliste
tmp = []
bigramO = []

for i in range(0, len(wakatiO_n)):
    row = wakatiO_n[i]
    # 2-Ein Gramm erstellen
    for j in range(len(row)-1):
        tmp.append([row[j], row[j+1]])
    bigramO.extend(tmp)
    tmp = []

#Array`bigramO`Zu DataFrame und Spalte setzen
df_bigramO = pd.DataFrame(bigramO)
df_bigramO = df_bigramO.rename(columns={0: 'node1', 1: 'node2'})

# `weight`Fügen Sie Spalten hinzu und vereinheitlichen Sie Werte mit 1
df_bigramO['weight'] = 1

# 2-Zählen Sie die Anzahl der Gramm
df_bigramO = df_bigramO.groupby(['node1', 'node2'], as_index=False).sum()

#Extrahieren Sie eine Liste mit mehr als 1 Vorkommen
df_bigramO = df_bigramO[df_bigramO['weight'] > 1]

#Erstellen Sie ein gerichtetes Diagramm
G_bigramO = nx.from_pandas_edgelist(df_bigramO, 'node1', 'node2', ['weight'], nx.DiGraph)

#Visualisieren Sie das erstellte Diagramm
#Layouteinstellungen
pos = nx.spring_layout(G_bigramO)
nx.draw_networkx(G_bigramO, pos)
plt.show()

Erstellen eines gerichteten Graphen (gerichtetes Netzwerk)

Fügen Sie dem Argument von nx.from_pandas_edgelist (), mit dem das ungerichtete Diagramm erstellt wurde, nx.DiGraph hinzu. Weitere Informationen zu den anderen Argumenten finden Sie unter 2.2.2 Erstellen eines Ähnlichkeitsnetzwerks.

G_corlistO = nx.from_pandas_edgelist(df_corlistO, 'node1', 'node2', ['weight'], nx.DiGraph)

Visualisierung des Graphen (Netzwerk)

Dies entspricht genau der Visualisierung ungerichteter Diagramme.

#Bibliothek`Matplotlib`Von`pyplot`Importieren
from matplotlib import pyplot

#Berechnen Sie die optimale Anzeigeposition für jeden Knoten
pos = nx.spring_layout(graph)

#Zeichnen Sie ein Diagramm
nx.draw_networkx(graph, pos)

#Zeigen Sie Diagramme mit Matplotlib an
plt.show()

2-Gramm-Netzwerkfunktionen

Selbst wenn es sich um einen gerichteten Graphen handelt, ist die Idee dieselbe wie die eines ungerichteten Graphen. Da es schwierig ist, die Eigenschaften selbst auf einen Blick zu erfassen, wird das Diagramm durch Erstellen eines 2-Gramm-Netzwerks visualisiert Erfassen Sie die Merkmale quantitativ mithilfe von Indikatoren.

Berechnen wir erneut den Clusterkoeffizienten und die Mediationszentralität.

Klicken Sie hier für Anwendungsbeispiele

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


#Erstellen eines nicht fehlerhaften Sprachdatensatzes
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']

#Trennen und entfernen Sie unnötige Zeichenfolgen mit regulären Ausdrücken
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 = []

#Zähle, sortiere und füge Wörter zu dic hinzu
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
    dic.append(word_uniq[0])

#Erstellen Sie ein Wörterbuch, indem Sie Wörtern IDs zuweisen
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
    dic_inv.update({word_uniq: i})

#Konvertieren Sie Wörter in ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]

# 2-Erstellen Sie eine Grammliste
tmp = []
bigramO = []

for i in range(0, len(wakatiO_n)):
    row = wakatiO_n[i]
    # 2-Ein Gramm erstellen
    for j in range(len(row)-1):
        tmp.append([row[j], row[j+1]])
    bigramO.extend(tmp)
    tmp = []

#Array`bigramO`Zu DataFrame und Spalte setzen
df_bigramO = pd.DataFrame(bigramO)
df_bigramO = df_bigramO.rename(columns={0: 'node1', 1: 'node2'})

# `weight`Fügen Sie Spalten hinzu und vereinheitlichen Sie Werte mit 1
df_bigramO['weight'] = 1

# 2-Zählen Sie die Anzahl der Gramm
df_bigramO = df_bigramO.groupby(['node1', 'node2'], as_index=False).sum()

#Extrahieren Sie eine Liste mit mehr als 1 Vorkommen
df_bigramO = df_bigramO[df_bigramO['weight'] > 1]

#Erstellen gerichteter Diagramme
G_bigramO = nx.from_pandas_edgelist(
    df_bigramO, 'node1', 'node2', ['weight'], nx.DiGraph)

#Sprechen Netzwerk, das nicht kaputt ist
#① Berechnung des durchschnittlichen Clusterkoeffizienten
print('Durchschnittlicher Clusterkoeffizient')
print(nx.average_clustering(G_bigramO, weight='weight'))
print()

#② Berechnung der Mediationszentralität
bc = nx.betweenness_centrality(G_bigramO, weight='weight')
print('Mediationszentralität')
for k, v in sorted(bc.items(), key=lambda x: -x[1]):
    print(str(k) + ': ' + str(v))

Berechnung des durchschnittlichen Clusterkoeffizienten

Je höher der durchschnittliche Clusterkoeffizient aller Knoten ist, desto dichter ist das Netzwerk. Der Durchschnitt der Clusterkoeffizienten wird mit nx.average_clustering () berechnet.

nx.average_clustering(G, weight=None)

G
Diagramm angeben.
(Richtungsgraph G, erstellt im vorherigen Abschnitt_bigramO)

weight
Gibt die Kante mit der Zahl an, die als Gewicht verwendet werden soll. Wenn Keine, beträgt das Gewicht jeder Kante 1.

Berechnung der Mediationszentralität

Es wird dadurch bestimmt, wie viele Knoten in der kürzesten Route zwischen allen Knoten enthalten sind. Mit anderen Worten, die Knoten, die am häufigsten zur effizienten Übermittlung von Informationen verwendet werden, sind zwischengeschalteter und zentraler.

nx.betweenness_centrality(G, weight=None)

G
Diagramm angeben.
(Richtungsgraph G, erstellt im vorherigen Abschnitt_bigramO)

weight
Gibt die Kante mit der Zahl an, die als Gewicht verwendet werden soll. Wenn Keine, werden alle Kantengewichte als gleich betrachtet.

2-Gramm-Netzwerkauswirkung

Wir haben einige Indikatoren implementiert, um die Eigenschaften des Netzwerks quantitativ zu verstehen. des Weiteren

Verwenden wir eine Gradverteilung, um zu sehen, wie sich die einzelnen Wörter gegenseitig beeinflussen.

Weil Wortknoten in gerichteten Netzwerken orientiert sind

Auftrag:Ein Wort wird von einem anderen beeinflusst
Auftrag:Ein Wort beeinflusst ein anderes
Ich werde es separat betrachten.

Klicken Sie hier für Anwendungsbeispiele

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


#Erstellen eines nicht fehlerhaften Sprachdatensatzes
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']

#Trennen und entfernen Sie unnötige Zeichenfolgen mit regulären Ausdrücken
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 = []

#Zähle, sortiere und füge Wörter zu dic hinzu
word_freq = Counter(itertools.chain(*wakatiO))
dic = []
for word_uniq in word_freq.most_common():
    dic.append(word_uniq[0])

#Erstellen Sie ein Wörterbuch, indem Sie Wörtern IDs zuweisen
dic_inv = {}
for i, word_uniq in enumerate(dic, start=1):
    dic_inv.update({word_uniq: i})

#Konvertieren Sie Wörter in ID
wakatiO_n = [[dic_inv[word] for word in waka] for waka in wakatiO]

# 2-Erstellen Sie eine Grammliste
tmp = []
bigramO = []

for i in range(0, len(wakatiO_n)):
    row = wakatiO_n[i]
    # 2-Ein Gramm erstellen
    for j in range(len(row)-1):
        tmp.append([row[j], row[j+1]])
    bigramO.extend(tmp)
    tmp = []

#Array`bigramO`Zu DataFrame und Spalte setzen
df_bigramO = pd.DataFrame(bigramO)
df_bigramO = df_bigramO.rename(columns={0: 'node1', 1: 'node2'})

# `weight`Fügen Sie Spalten hinzu und vereinheitlichen Sie Werte mit 1
df_bigramO['weight'] = 1

# 2-Zählen Sie die Anzahl der Gramm
df_bigramO = df_bigramO.groupby(['node1', 'node2'], as_index=False).sum()

#Extrahieren Sie eine Liste mit mehr als 1 Vorkommen
df_bigramO = df_bigramO[df_bigramO['weight'] > 1]

#Erstellen gerichteter Diagramme
G_bigramO = nx.from_pandas_edgelist(
    df_bigramO, 'node1', 'node2', ['weight'], nx.DiGraph)

#Sprechen Netzwerk, das nicht kaputt ist
#Finden Sie die Häufigkeit der Bestellung
indegree = sorted([d for n, d in G_bigramO.in_degree(weight='weight')], reverse=True)
indegreeCount = Counter(indegree)
indeg, cnt = zip(*indegreeCount.items())

#Finden Sie die Häufigkeit der Bestellung
outdegree = sorted([d for n, d in G_bigramO.out_degree(weight='weight')], reverse=True)
outdegreeCount = Counter(outdegree)
outdeg, cnt = zip(*outdegreeCount.items())

#Abschlussverteilung erstellen
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()

Grad

Was ist Grad? Sagen Sie im gerichteten Diagramm die Anzahl der Seiten, die in den Scheitelpunkt eintreten Im ungerichteten Diagramm ist dies die Anzahl der Verbindungsseiten.

Um die Leistung des Netzwerks herauszufinden Verwenden Sie die Methode in_degree (). Das Ergebnis wird in Form von (Knotennummer, Eingabereihenfolge) zurückgegeben.

# G_Überprüfen Sie die Reihenfolge von bigramO
print(G_bigramO.in_degree(weight='weight'))

>>>Ausgabeergebnis
[(1, 208), (2, 155), (4, 148), (5, 126), (7, 47)・ ・ ・]

Outdegree

Was ist Grad? Sagen Sie in einem gerichteten Diagramm die Anzahl der Seiten, die vom Scheitelpunkt ausgehen Im ungerichteten Diagramm ist dies die Anzahl der Verbindungsseiten.

Verwenden Sie die Methode out_degree (), um die Reihenfolge zu ermitteln. Das Ergebnis wird in Form von (Knotennummer, Reihenfolge) zurückgegeben.

# G_Finden Sie die Reihenfolge von bigramO heraus
print(G_bigramO.out_degree(weight='weight'))

>>>Ausgabeergebnis
[(1, 248), (2, 12), (4, 83), (5, 65), (7, 57)・ ・ ・]

Python: Japanischer Text: Charakteristisch für Sprache aus Wortkontinuität

Kennen Sie die Kontinuität der Wörter

Trennung von gesprochenem Text

Erstellen eines Wortwörterbuchs

Zählen der Anzahl der Wörter

Reduzieren Sie eine mehrdimensionale Liste auf eine Dimension

Wörter sortieren

Konvertieren Sie Wörter in Zahlen

ID aus dem Wörterbuch abrufen

Konvertieren Sie die Liste der Wörter in wakatiO in die ID von dic_inv.

Kennen Sie die Eigenschaften des Textes aus der Kontinuität der Wörter

Was ist N-Gramm?

2-Erstellen einer Grammliste

Erstellen eines 2-Gramm-Netzwerks

Erstellen eines gerichteten Graphen (gerichtetes Netzwerk)

Visualisierung des Graphen (Netzwerk)

2-Gramm-Netzwerkfunktionen

Berechnung des durchschnittlichen Clusterkoeffizienten

Berechnung der Mediationszentralität

2-Gramm-Netzwerkauswirkung

Grad

Outdegree