Python: Japanischer Text: Charakteristisch für Sprache aufgrund von Wortähnlichkeit
Kennen Sie das Wort Ähnlichkeit
Morphologische Analyse des gesprochenen Textes
In Python: Japanischer Text: Morphologische Analyse Ich lernte "zu analysierende Daten lesen" und "Grundlagen der Vorverarbeitung für die Verarbeitung natürlicher Sprache". In diesem Beitrag verwenden Sie das, was Sie bisher gelernt haben, um die "Methode zur Verarbeitung von Sprachdatensätzen" zu erlernen, die Gegenstand der Analyse ist. Insbesondere werden wir eine Vorverarbeitung implementieren, die sich auf die Wortähnlichkeit konzentriert.
Das Flag dieses Datensatzes O Sprechen, das ist kein Fehler Es kann nicht gesagt werden, dass T ein Fehler ist, aber es ist eine seltsame Rede. X Es gibt drei Arten von Äußerungen, die sich eindeutig seltsam anfühlen.
Hier werden wir basierend auf dem Flag der Äußerung verarbeiten, die kein O-Fehler ist.
Informationen zu den Variablen, die im Beispiel angezeigt werden
Inhalt der Variablen df_label_text_O, die nur nicht unterbrochene Äußerungen extrahiert (Zeile 49) Das ndarray des NumPy-Arrays, das den Index und die Spalte enthält.
0 1
1 O Entschuldigung, wer bist du?
24 O Ist das so? Magst du High School Baseball?
48 O Koshien, richtig?
... .. ...
2376 O Ist das so?
Inhalt der variablen Zeile, die bei der Verarbeitung eines nicht unterbrochenen Sprachdatensatzes verwendet wird (Zeile 62) Zeile verwendet tolist () NumPy-Array ndarray df_label_text_O in Python-Listentyp konvertiert.
[['O', 'Entschuldigung, wer sind Sie?'], ['O', 'Ja wirklich. Magst du High School Baseball?'], ['O', 'Koshien, richtig?'], ... ['O', 'Ist das so.']]
Klicken Sie hier für ein Beispiel
import os
import json
import pandas as pd
import re
from janome.tokenizer import Tokenizer
#Geben Sie das Verzeichnis init100 an
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
#Erstellen Sie eine leere Liste zum Speichern von Flags und Äußerungen
label_text = []
#Verarbeiten Sie 10 JSON-Dateien nacheinander
for file in file_dir[:10]:
#Lesen Sie im schreibgeschützten Modus
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
#Sprachdatenarray`turns`Extrahieren Sie Äußerungsinhalte und Flags aus
for turn in json_data['turns']:
turn_index = turn['turn-index'] #Sprechrunde Nr
speaker = turn['speaker'] #Lautsprecher-ID
utterance = turn['utterance'] #Inhalt der Rede
#Schließen Sie die erste Zeile aus, da es sich um eine Systemäußerung handelt
if turn_index != 0:
#Extrahieren des Inhalts der Rede einer Person
if speaker == 'U':
u_text = ''
u_text = utterance
else:
a = ''
for annotate in turn['annotations']:
#Extrahieren Sie die Fehlerflagge
a = annotate['breakdown']
#Speichern Sie Flaggen und menschliche Sprache in einer Liste
tmp1 = str(a) + '\t' + u_text
tmp2 = tmp1.split('\t')
label_text.append(tmp2)
#aufführen`label_text`Zu DataFrame
df_label_text = pd.DataFrame(label_text)
#Entfernen Sie doppelte Zeilen
df_label_text = df_label_text.drop_duplicates()
#Extrahieren Sie nur nicht kollabierte Äußerungen
df_label_text_O = df_label_text[df_label_text[0] == 'O']
t = Tokenizer()
#Erstellen Sie einen Äußerungsdatensatz, der kein leerer Zusammenbruch ist
morpO = [] #Speichern Sie getrennte Wörter
tmp1 = []
tmp2 = ''
#Zeile für Zeile lesen
# .values:Lesen Sie außer Index und Spalte
# .tolist:Konvertieren Sie das NumPy-Array ndarray in den Python-Listentyp
for row in df_label_text_O.values.tolist():
#Entfernen Sie die Groß- und Kleinschreibung von Zahlen und Alphabeten mit regulären Ausdrücken
reg_row = re.sub('[0-9a-zA-Z]+', '', row[1])
reg_row = reg_row.replace('\n', '')
#Führen Sie mit Janome eine morphologische Analyse durch
for token in t.tokenize(reg_row):
#Das Oberflächensystem der Wörter`morpO`Bitte hinzufügen zu
tmp1.append(token.surface)
tmp2 = ' '.join(tmp1)
morpO.append(tmp2)
tmp1 = []
#Morphologisch analysierte Wörter ausgeben
pd.DataFrame(morpO)
Was ist eine Word-Dokumentmatrix?
Er erklärte, dass zur Analyse von Daten in natürlicher Sprache Wortdaten (Satzdaten) in numerische Daten umgewandelt werden sollten. Eine der Konvertierungsmethoden
Word-Dokumentmatrix (Begriff-Es gibt so etwas wie Dokumentmatrix).
Die Wortdokumentmatrix ist eine tabellarische Darstellung der Häufigkeit von Wörtern, die in einem Dokument erscheinen.
Die in jedem Dokument enthaltenen Wortdaten können durch morphologische Analyse erhalten werden. Von dort wird die Anzahl der Vorkommen jedes Wortes gezählt und in numerische Daten umgewandelt.
Die Wortdokumentmatrix ist ein Wort- / Spaltendokument in Zeilenrichtung oder eine Dokument- / Spaltenrichtung in der entgegengesetzten Zeilenrichtung. Es wird in einem Matrixformat ausgedrückt, in dem Wörter angeordnet sind.
Wenn alle N Arten von Wörtern und alle M Dokumente vorhanden sind, spricht man von einer Wortdokumentmatrix aus N Zeilen x M Spalten.
In der Wortdokumentmatrix in der Figur hat Dokument 1 zweimal Wort 1, Wort 2 einmal, Wort 3 dreimal, ..., Wort N 0 Mal. Zeigt an, dass es angezeigt wird.
Um zu zählen, wie oft ein Wort erscheint
Python-Standardbibliothekssammlungen.Counter()Es gibt verschiedene Methoden wie die Verwendung
Hier Scikit-Learn (Sykit Learn) Count Vectorizer()Verwenden von
Hier ist ein Beispiel für die Erstellung einer Word-Dokumentmatrix.
CountVectorizer()Bricht den Text in Wörter auf und zählt, wie oft das Wort erscheint.
from sklearn.feature_extraction.text import CountVectorizer
# `CountVectorizer()`Generieren Sie einen Konverter mit
CV = CountVectorizer()
corpus = ['This is a pen.',
'That is a bot.',]
# `fit_transform()`damit`corpus`Und konvertieren Sie die Anzahl der Wörter in ein Array
X = CV.fit_transform(corpus)
print(X)
>>>Ausgabeergebnis
(0, 2) 1
(0, 1) 1
(0, 4) 1
(1, 0) 1
(1, 3) 1
(1, 1) 1
# `get_feature_names()`Überprüfen Sie die Liste mit den Wörtern, in denen Sie gelernt haben
print(CV.get_feature_names())
>>>Ausgabeergebnis
['bot', 'is', 'pen', 'that', 'this']
#Die Anzahl der gezählten Auftritte`toarray()`In Vektor konvertieren und anzeigen
print(X.toarray())
>>>Ausgabeergebnis
#Linie:`corpus`Reihenfolge der Sätze in
#Säule:`get_feature_names()`Reihenfolge der Wörter bestätigt in
[[0 1 1 0 1]
[1 1 0 1 0]]
Klicken Sie hier für Anwendungsbeispiele
import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import CountVectorizer
#Geben Sie das Verzeichnis init100 an
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
#Erstellen Sie eine leere Liste zum Speichern von Flags und Äußerungen
label_text = []
#Verarbeiten Sie 10 JSON-Dateien nacheinander
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
#Sprachdatenarray`turns`Extrahieren Sie Äußerungsinhalte und Flags aus
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)
#aufführen`label_text`Zu DataFrame und entfernen Sie Duplikate
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
#Extrahieren Sie nur nicht kollabierte Äußerungen
df_label_text_O = df_label_text[df_label_text[0] == 'O']
t = Tokenizer()
#Erstellen Sie einen Äußerungsdatensatz, der kein leerer Zusammenbruch ist
morpO = []
tmp1 = []
tmp2 = ''
#Entfernen Sie Groß- und Kleinbuchstaben von Zahlen und Buchstaben
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', '')
#Morphologische Analyse mit Janome
for token in t.tokenize(reg_row):
tmp1.append(token.surface)
tmp2 = ' '.join(tmp1)
morpO.append(tmp2)
tmp1 = []
#Konvertieren Sie vom Listenformat in das NumPy-Array (da das Array schneller ist).
morpO_array = np.array(morpO)
#Zählen Sie, wie oft ein Wort erscheint
cntvecO = CountVectorizer()
#Lernen und konvertieren Sie Wortvorkommen in ein Array
morpO_cntvecs = cntvecO.fit_transform(morpO_array)
#In ndarray-Array konvertieren
morpO_cntarray = morpO_cntvecs.toarray()
#Zeigen Sie die Anzahl der Wörter im DataFrame-Format an
#Spalten: geteilte Wörter
#Index (Zeile): Ursprüngliche Sprachdaten
pd.DataFrame(morpO_cntarray, columns=cntvecO.get_feature_names(),
index=morpO).head(20)
Ein-Buchstaben-Wortnotiz
Standardmäßig werden Wörter mit einem Buchstaben nicht gezählt. Es gibt japanische Wörter, die nur einen Buchstaben bedeuten. Seien Sie also vorsichtig, wenn Sie mit Japanisch umgehen. Geben Sie token_pattern = '(? U) \ b \ w + \ b'in CountVectorizer () an, um auch Wörter mit einem Buchstaben zu zählen.
CountVectorizer(token_pattern='(?u)\\b\\w+\\b')
Was ist eine gewichtete Word-Dokumentmatrix?
In einer Word-Dokumentmatrix, die die Anzahl der Vorkommen (Häufigkeit) eines Wortes als Wert hat Wörter, die universell vorkommen (z. B. "I" und "desu"), erscheinen in jedem Dokument häufiger.
Andererseits erscheinen Wörter, die nur in bestimmten Dokumenten vorkommen, seltener. Es wird schwierig, jedes Dokument anhand von Wörtern zu charakterisieren. Daher in der Word-Dokumentmatrix
In TF (Termfrequenz)
Inverse Dokumentfrequenz multipliziert mit IDF (Inverse Dokumentfrequenz)
TF-IDF-Werte werden häufig verwendet.
Der IDF-Wert eines Wortes kann per Protokoll berechnet werden (Gesamtzahl der Dokumente / Anzahl der Dokumente, in denen ein Wort vorkommt) + 1. Zum Beispiel, wenn ein Wort in 3 von 4 Dokumenten enthalten ist Der IDF-Wert ist log (4/3) + 1 ≒ 1.1 Wörter, die nur in einem bestimmten Dokument vorkommen, haben einen höheren IDF-Wert.
Ein großer IDF-Wert ist ein Merkmal des Dokuments, da das Wort von hoher Bedeutung ist.
Sie können die IDF aus der TF berechnen und den TF-IDF-Wert berechnen, indem Sie die TF mit der IDF multiplizieren.
Unten ist TfidfVectorizer()Wurde benutzt
Hier ist ein Beispiel für die Erstellung einer gewichteten Word-Dokumentmatrix basierend auf dem TF-IDF-Wert.
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
#Anzeige nach dem Dezimalpunkt mit 2 gültigen Zahlen
np.set_printoptions(precision=2)
docs = np.array([
"Weiß schwarz rot", "Weiß weiß schwarz", "Rot schwarz"
])
# `TfidfVectorizer()`Generieren Sie einen Konverter mit
vectorizer = TfidfVectorizer(use_idf=True, token_pattern="(?u)\\b\\w+\\b")
# `fit_transform()`damit`docs`Und konvertieren Sie die Anzahl der Vorkommen gewichteter Wörter in ein Array
vecs = vectorizer.fit_transform(docs)
print(vecs.toarray())
# >>Ausgabeergebnis
[[ 0.62 0.62 0.48]
[ 0.93 0. 0.36]
[ 0. 0.79 0.61]]
①vectorizer = TfidfVectorizer()damit
Erzeugt einen Konverter, der eine Vektordarstellung (Quantifizierung von Wörtern) durchführt.
②use_idf=Bei der Einstellung False wird nur tf gewichtet.
③vectorizer.fit_transform()Konvertiert das Dokument in einen Vektor.
Das Argument ist ein Array, das durch Leerzeichen getrennt ist.
④toarray()Konvertiert die Ausgabe in ein NumPy ndarray-Array.
np.set_printoptions()Ist eine Funktion, die das Anzeigeformat des NumPy-Arrays definiert.
print()Der ursprüngliche Wert ändert sich nicht mit der Einstellung, die nur gültig ist, wenn der Wert mit angezeigt wird.
Argumentgenauigkeit=Geben Sie die Anzahl der Stellen an, die nach dem Dezimalpunkt in angezeigt werden sollen.
Klicken Sie hier für Anwendungsbeispiele
import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
#Geben Sie das Verzeichnis init100 an
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
#Erstellen Sie eine leere Liste zum Speichern von Flags und Äußerungen
label_text = []
#Verarbeiten Sie 10 JSON-Dateien nacheinander
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
#Sprachdatenarray`turns`Extrahieren Sie Äußerungsinhalte und Flags aus
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)
#aufführen`label_text`Zu DataFrame und entfernen Sie Duplikate
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
#Extrahieren Sie nur nicht kollabierte Äußerungen
df_label_text_O = df_label_text[df_label_text[0] == 'O']
t = Tokenizer()
#Erstellen Sie einen Äußerungsdatensatz, der kein leerer Zusammenbruch ist
morpO = []
tmp1 = []
tmp2 = ''
#Entfernen Sie Groß- und Kleinbuchstaben von Zahlen und Buchstaben
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', '')
#Morphologische Analyse mit Janome
for token in t.tokenize(reg_row):
tmp1.append(token.surface)
tmp2 = ' '.join(tmp1)
morpO.append(tmp2)
tmp1 = []
#Konvertieren Sie vom Listenformat in das NumPy-Array (da das Array schneller ist).
morpO_array = np.array(morpO)
#(1) Erzeugen Sie einen Konverter, der eine Vektordarstellung durchführt
tfidf_vecO = TfidfVectorizer(use_idf=True)
#② Konvertieren Sie Wörter in Vektordarstellung
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
#③ In ndarray-Array konvertieren
morpO_tfidf_array = morpO_tfidf_vecs.toarray()
#Anzeigen von Wörtern (Vektordarstellung) im DataFrame-Format
pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(),
index=morpO).head(20)
Wortähnlichkeit berechnen (Korrelation)
Eine Merkmalsmenge ist ein Merkmal, das sich von anderen Daten unterscheidet, über die die Daten verfügen.
In der von CountVectorizer () erstellten Word-Dokumentmatrix wird angegeben, wie oft ein Wort angezeigt wird In der von TfidfVectorizer () erstellten Word-Dokumentmatrix wird der TF-IDF-Wert eines Wortes als Merkmalsmenge des Wortes verwendet.
Zum Beispiel bei der Unterscheidung, ob das Objekt auf dem Bild ein Hund oder eine Katze ist Zuallererst bemerken Sie möglicherweise unwissentlich die Form Ihrer Ohren.
In diesem Fall ist das Ohr (einschließlich des Bereichs) die Merkmalsmenge. Das Dokumentklassifizierungsproblem verwendet jedes Wort als Merkmal, um ein überwachtes Lernmodell zu erstellen.
Hier sehen Sie, wie ähnlich die beiden Wörter aussehen, was sich von den oben genannten unterscheidet
Mit anderen Worten, erstellen Sie ein unbeaufsichtigtes Lernmodell mit Ähnlichkeit als Merkmal.
Eine bekannte Methode zur Messung der Ähnlichkeit ist der Korrelationskoeffizient.
Zusätzlich Cosinus-Ähnlichkeit, die die Ähnlichkeit zwischen Vektoren misst
Der Jaccard-Koeffizient, der die Ähnlichkeit zwischen Sätzen misst, ist berühmt.
Hier wird die corr () -Methode von pandas.DataFrame verwendet, um die Ähnlichkeit zu ermitteln. Berechnen Sie den Korrelationskoeffizienten zwischen den einzelnen Spalten.
Die corr () -Methode berechnet Spalten, deren Datentyp numerisch oder boolesch ist. Zeichenfolgen und fehlende NaN-Werte sind ausgeschlossen.
corr = DataFrame.corr()
Geben Sie im Argument von corr () die Berechnungsmethode des Korrelationskoeffizienten aus dem Folgenden an.
'pearson': Pearson-Produktfaktorkorrelationskoeffizient (Standard)
'kendall': Kendalls Rangkorrelationskoeffizient
'spearman': Rangkorrelationskoeffizient nach Spearman
Klicken Sie hier für Anwendungsbeispiele
import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
#Geben Sie das Verzeichnis init100 an
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
#Erstellen Sie eine leere Liste zum Speichern von Flags und Äußerungen
label_text = []
#Verarbeiten Sie 10 JSON-Dateien nacheinander
for file in file_dir[:10]:
r = open(file_path + file, 'r', encoding='utf-8')
json_data = json.load(r)
#Sprachdatenarray`turns`Extrahieren Sie Äußerungsinhalte und Flags aus
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)
#aufführen`label_text`Zu DataFrame und entfernen Sie Duplikate
df_label_text = pd.DataFrame(label_text)
df_label_text = df_label_text.drop_duplicates()
#Extrahieren Sie nur nicht kollabierte Äußerungen
df_label_text_O = df_label_text[df_label_text[0] == 'O']
t = Tokenizer()
#Erstellen Sie einen Äußerungsdatensatz, der kein leerer Zusammenbruch ist
morpO = []
tmp1 = []
tmp2 = ''
#Entfernen Sie Groß- und Kleinbuchstaben von Zahlen und Buchstaben
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', '')
#Morphologische Analyse mit Janome
for token in t.tokenize(reg_row):
tmp1.append(token.surface)
tmp2 = ' '.join(tmp1)
morpO.append(tmp2)
tmp1 = []
# TF-Erstellen Sie eine nach IDF-Wert gewichtete Word-Dokumentmatrix
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()
#Konvertieren Sie die Anzahl der Wortvorkommen in das DataFrame-Format
dtmO = pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(),
index=morpO).head(20)
#Erstellen Sie eine Korrelationsmatrix
corr_matrixO = dtmO.corr().abs()
# `.abs()`Ist eine Methode, um den absoluten Wert zu finden
#Anzeige der Korrelationsmatrix
corr_matrixO
Kennen Sie die Eigenschaften der Sprache aus der Ähnlichkeit der Wörter
Erstellen einer Ähnlichkeitsliste
Von hier aus durch Netzwerkanalyse unter Verwendung des Korrelationskoeffizienten der beiden im vorherigen Abschnitt erstellten Wörter als Merkmalsgröße. Wir werden eine quantitative Analyse durchführen.
Konvertieren Sie den Korrelationskoeffizienten vom Matrixformat in das Listenformat für die Netzwerkanalyse.
Konvertieren des Matrixformats in das Listenformat
pandas.DataFrame-Stapel()Verwenden Sie die Methode.
from pandas import DataFrame
#Bereiten Sie DataFrame vor
df=DataFrame([[0.1,0.2,0.3],[0.4,'NaN',0.5]],
columns=['test1','test2','test3'],
index=['AA','BB'])
print(df)
# >>>Ausgabeergebnis
test1 test2 test3
AA 0.1 0.2 0.3
BB 0.4 NaN 0.5
# stack :Umwandlung von Spalte in Zeile
print(df.stack())
# >>>Ausgabeergebnis
AA test1 0.1
test2 0.2
test3 0.3
BB test1 0.4
test2 NaN
test3 0.5
#Entstapeln: Konvertierung von Zeile zu Spalte
print(df.unstack())
# >>>Ausgabeergebnis
test1 AA 0.1
BB 0.4
test2 AA 0.2
BB NaN
test3 AA 0.3
BB 0.5
Klicken Sie hier für Anwendungsbeispiele
import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
#Geben Sie das Verzeichnis init100 an
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
#Erstellen Sie eine Liste mit Flags und Äußerungen
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)
#Entfernen Sie Duplikate und extrahieren Sie nur nicht gebrochene Äußerungen
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']
#Morphologische Analyse von Janome
t = Tokenizer()
morpO = []
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', '')
for token in t.tokenize(reg_row):
tmp1.append(token.surface)
tmp2 = ' '.join(tmp1)
morpO.append(tmp2)
tmp1 = []
# TF-Erstellen Sie eine nach IDF-Wert gewichtete Word-Dokumentmatrix
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()
#In das DataFrame-Format konvertieren und Korrelationsmatrix erstellen
dtmO = pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(),
index=morpO)
corr_matrixO = dtmO.corr().abs()
#Korrelationsmatrix`corr_matrixO`Von Spaltenrichtung in Zeilenrichtung konvertieren
corr_stackO = corr_matrixO.stack()
index = pd.Series(corr_stackO.index.values)
value = pd.Series(corr_stackO.values)
#Der Korrelationskoeffizient ist 0.5 oder mehr 1.Extrahieren Sie weniger als 0
tmp3 = [] #Der Korrelationskoeffizient ist 0.5 oder mehr 1.Liste der Indexwerte mit Werten unter 0
tmp4 = [] #Der Korrelationskoeffizient ist 0.5 oder mehr 1.Liste von Wertwerten kleiner als 0
for i in range(0, len(index)):
if value[i] >= 0.5 and value[i] < 1.0:
tmp1 = str(index[i][0]) + ' ' + str(index[i][1])
tmp2 = [s for s in tmp1.split()]
tmp3.append(tmp2)
tmp4 = np.append(tmp4, value[i])
tmp3 = pd.DataFrame(tmp3)
tmp3 = tmp3.rename(columns={0: 'node1', 1: 'node2'})
tmp4 = pd.DataFrame(tmp4)
tmp4 = tmp4.rename(columns={0: 'weight'})
# DataFrame`tmp3`Wann`tmp4`Bitte in horizontaler Richtung anschließen
df_corlistO = pd.concat([tmp3, tmp4], axis=1)
#Zeigen Sie den erstellten DataFrame an
df_corlistO.head(20)
Erstellen eines Ähnlichkeitsnetzwerks
Die Vernetzung ist eine Möglichkeit, die Beziehung zwischen Objekten auszudrücken. Ein bekanntes Beispiel ist das Netzwerk von Freundschaften auf SNS.
In der Netzwerkstruktur
Das Ziel ist ein Knoten
Beziehungen werden durch Kanten dargestellt.
Kanten haben Gewicht und sind Intimität in Freundschaftsnetzwerken. Je näher Sie sind, desto höher ist der Gewichtswert.
Darüber hinaus können Routenkarten, Luftverkehrsnetze und gleichzeitige / ähnliche Beziehungen von Wörtern in Netzwerken ausgedrückt werden.
Visualisierung einer Gruppe von Sprachen, die kein Richtungskonzept an den Rändern haben und nicht miteinander verbunden sind, z. B. die im vorherigen Abschnitt erstellte Ähnlichkeitsliste.
Verwenden Sie ein ungerichtetes Diagramm (oder ein ungerichtetes Netzwerk).
Der gewichtete Graph wird auch als Netzwerk bezeichnet.
Ein ungerichteter Graph ist einer, bei dem die Kanten, aus denen das Netzwerk besteht, keine Richtung haben. Im Gegenteil, wenn die Kante gerichtet ist
Es wird als gerichteter Graph (oder gerichtetes Netzwerk) bezeichnet.
Erstellen eines ungerichteten Diagramms (ungerichtetes Netzwerk)
Python hat eine Bibliothek namens NetworkX. In diesem Abschnitt wird diese Bibliothek verwendet, um die im vorherigen Abschnitt erstellte Ähnlichkeitsliste anzuzeigen.
#Bibliothek`NetworkX`Importieren
import networkx as nx
#Erstellen eines ungerichteten Diagramms
network = nx.from_pandas_edgelist(df, source='source', target='target', edge_attr=None, create_using=None)
① df: DataFrame-Name von Pandas, der die Quelle des Diagramms ist
② Quelle: Spaltenname des Quellknotens
Geben Sie mit str (Zeichenfolgentyp) oder int (Ganzzahltyp) an.
③ Ziel: Spaltenname des Zielknotens
Geben Sie mit str oder int an
④edge_attr: Kante (Gewicht) der einzelnen Daten
Geben Sie mit str oder int, iterable, True an
⑤create_using: Diagrammtyp (optional)
Ungerichteter Graph: nx.Grafik (Standard)
Gerichtete Grafik: nx.DiGraph
Visualisierung des Graphen (Netzwerk)
#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()
Klicken Sie hier für Anwendungsbeispiele
import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx
import matplotlib.pyplot as plt
#Geben Sie das Verzeichnis init100 an
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
#Erstellen Sie eine Liste mit Flags und Äußerungen
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)
#Entfernen Sie Duplikate und extrahieren Sie nur nicht gebrochene Äußerungen
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']
#Morphologische Analyse von Janome
t = Tokenizer()
morpO = []
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', '')
for token in t.tokenize(reg_row):
tmp1.append(token.surface)
tmp2 = ' '.join(tmp1)
morpO.append(tmp2)
tmp1 = []
# TF-Erstellen Sie eine nach IDF-Wert gewichtete Word-Dokumentmatrix
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()
#In das DataFrame-Format konvertieren und Korrelationsmatrix erstellen
dtmO = pd.DataFrame(morpO_tfidf_array)
corr_matrixO = dtmO.corr().abs()
#Erstellen eines nicht fehlerhaften Sprachdatensatzes
corr_stackO = corr_matrixO.stack()
index = pd.Series(corr_stackO.index.values)
value = pd.Series(corr_stackO.values)
tmp3 = []
tmp4 = []
for i in range(0, len(index)):
if value[i] >= 0.5 and value[i] < 1.0:
tmp1 = str(index[i][0]) + ' ' + str(index[i][1])
tmp2 = [int(s) for s in tmp1.split()]
tmp3.append(tmp2)
tmp4 = np.append(tmp4, value[i])
tmp3 = pd.DataFrame(tmp3)
tmp3 = tmp3.rename(columns={0: 'node1', 1: 'node2'})
tmp4 = pd.DataFrame(tmp4)
tmp4 = tmp4.rename(columns={0: 'weight'})
df_corlistO = pd.concat([tmp3, tmp4], axis=1)
#① Erstellen Sie ein ungerichtetes Diagramm
G_corlistO = nx.from_pandas_edgelist(df_corlistO, 'node1', 'node2', ['weight'])
#② Visualisieren Sie das erstellte Diagramm
#Layouteinstellungen
pos = nx.spring_layout(G_corlistO)
nx.draw_networkx(G_corlistO, pos)
plt.show()
Ähnlichkeitsnetzwerkfunktionen
Wie in der im vorherigen Abschnitt dargestellten Grafik gezeigt, weist das tatsächliche Netzwerk viele komplizierte Strukturen auf. Auf den ersten Blick ist es schwierig, die Eigenschaften zu erfassen.
Erfassen Sie in einem solchen Fall die Eigenschaften quantitativ mit einem Index. Einige der Indikatoren dienen dem Verständnis des gesamten Netzwerks (global). Es gibt auch Dinge (lokal), die sich auf einen bestimmten Knoten konzentrieren und ihn erfassen.
Hier einige Beispiele für häufig verwendete Indikatoren:
Reihenfolge: Gibt die Anzahl der Kanten an, die der Knoten hat.
Auftragsverteilung: Stellt ein Histogramm der Anzahl der Knoten mit einer bestimmten Reihenfolge dar.
Clusterkoeffizient: Zeigt an, wie eng die Knoten miteinander verbunden sind.
Routenlänge: Die Entfernung von einem Knoten zum anderen.
Zentralität: Gibt an, inwieweit ein Knoten eine zentrale Rolle im Netzwerk spielt.
Berechnen Sie nun für das im vorherigen Abschnitt erstellte Netzwerk den Clusterkoeffizienten und die Mediationszentralität. Schauen wir uns die Funktionen an.
In diesem Netzwerk Der Clusterkoeffizient ist die Verbindungsdichte zwischen Wörtern Die Mediationszentralität repräsentiert den Grad der Drehscheibe eines Wortes in einem Netzwerk.
Vergleichen des durchschnittlichen Clusterkoeffizienten für jedes Netzwerk, nicht fehlgeschlagene Sprache und unterbrochene Sprache Sie können sehen, dass die Wörter der Rede, die gebrochen sind, enger miteinander verbunden sind.
Auch wenn Sie die Top 5 Wörter mit hoher Mediationszentralität vergleichen Wörter über Obon-Feiertage sind in der nicht reduzierten Sprache enthalten Es kann gefolgert werden, dass Baseballwörter am frühen Morgen eine zentrale Rolle in der zusammengebrochenen Sprache spielen.
① Sprechen ist kein Fehler
<Durchschnittlicher Clusterkoeffizient> 0.051924357
<Top 5 Wörter mit hoher Vermittlungszentralität>
Urlaub, Obon, hier, wenige, Morgengrauen
② Eine Geschichte, die kaputt ist
<Durchschnittlicher Clusterkoeffizient> 0.069563257
<Top 5 Wörter mit hoher Vermittlungszentralität>
Lass uns dieses Mal am frühen Morgen Baseball spielen, er
Klicken Sie hier für Anwendungsbeispiele
import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx
import matplotlib.pyplot as plt
#Geben Sie das Verzeichnis init100 an
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
#Erstellen Sie eine Liste mit Flags und Äußerungen
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)
#Entfernen Sie Duplikate und extrahieren Sie nur nicht gebrochene Äußerungen
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']
#Morphologische Analyse von Janome
t = Tokenizer()
morpO = []
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', '')
for token in t.tokenize(reg_row):
tmp1.append(token.surface)
tmp2 = ' '.join(tmp1)
morpO.append(tmp2)
tmp1 = []
# TF-Erstellen Sie eine nach IDF-Wert gewichtete Word-Dokumentmatrix
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()
#In das DataFrame-Format konvertieren und Korrelationsmatrix erstellen
dtmO = pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(),
index=morpO)
corr_matrixO = dtmO.corr().abs()
#Erstellen eines nicht fehlerhaften Sprachdatensatzes
corr_stackO = corr_matrixO.stack()
index = pd.Series(corr_stackO.index.values)
value = pd.Series(corr_stackO.values)
tmp3 = []
tmp4 = []
for i in range(0, len(index)):
if value[i] >= 0.5 and value[i] < 1.0:
tmp1 = str(index[i][0]) + ' ' + str(index[i][1])
tmp2 = [s for s in tmp1.split()]
tmp3.append(tmp2)
tmp4 = np.append(tmp4, value[i])
tmp3 = pd.DataFrame(tmp3)
tmp3 = tmp3.rename(columns={0: 'node1', 1: 'node2'})
tmp4 = pd.DataFrame(tmp4)
tmp4 = tmp4.rename(columns={0: 'weight'})
df_corlistO = pd.concat([tmp3, tmp4], axis=1)
#Erstellen Sie ein ungerichtetes Diagramm
G_corlistO = nx.from_pandas_edgelist(df_corlistO, 'node1', 'node2', ['weight'])
#Für nicht fehlerhafte Sprachdatensätze
#① Berechnung des durchschnittlichen Clusterkoeffizienten
print('Durchschnittlicher Clusterkoeffizient')
print(nx.average_clustering(G_corlistO, weight='weight'))
print()
#② Berechnung der Mediationszentralität
bc = nx.betweenness_centrality(G_corlistO, 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.
(Ungerichteter Graph G, der im vorherigen Abschnitt erstellt wurde_corlistO)
②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.
(Ungerichteter Graph G, der im vorherigen Abschnitt erstellt wurde_corlistO)
②weight
Gibt die Kante mit der Zahl an, die als Gewicht verwendet werden soll. Wenn Keine, werden alle Kantengewichte als gleich betrachtet.
Extraktion von Ähnlichkeitsnetzwerkthemen
Ein Netzwerk besteht aus mehreren Teilnetzwerken (= Communities). Jeder Knoten in der Community zeichnet sich dadurch aus, dass er am Rand eng miteinander verbunden ist.
Sie können es in Teilnetzwerke unterteilen, indem Sie die spärlichen Kanten eines Netzwerks entfernen. Mit anderen Worten, die Community kann extrahiert werden = Netzwerke mit hoher Ähnlichkeit können extrahiert werden.
Das Netzwerk teilen
Wir verwenden einen Index namens Modularity.
Modularität Von "Verhältnis der Anzahl der Kanten in der Community zur Gesamtzahl der Kanten in einem Netzwerk" "Für die Gesamtreihenfolge aller Knoten in einem Netzwerk (gleich der Anzahl der Kanten im Netzwerk x 2) Quantifizieren Sie die Qualität der Aufteilung, indem Sie den Prozentsatz der Gesamtreihenfolge der Knoten in der Community abziehen.
Je höher der Modularitätswert ist, desto enger sind die Knoten in der Community.
Lassen Sie uns nun die Community mithilfe von Modularität extrahieren. Nicht gebrochene Äußerungen und gebrochene Äußerungen in ihren jeweiligen Netzwerken Als ich die Wörter der Community mit der größten Anzahl von Knoten überprüfte, erhielt ich die folgenden Ergebnisse.
① Sprechen ist kein Fehler
Obon, Ende, nur, Ruhe, Schnitt, Ärger, wenige, Heimkehr, Vergessen, Faulheit, Morgendämmerung, Fortsetzung, aufeinanderfolgende Feiertage, Konzentration
② Eine Geschichte, die kaputt ist
Bitte, ungefähr, ungefähr, dann nimm, was, Sucht, natürlich gut, Arbeit, Voreingenommenheit, Spaltung, Gefahr, Warten, Verstand, Zeit, Ernährung, Wachsamkeit, Schlaf, Essen
Für nicht kollabierte Äußerungen, zum Beispiel "Es gibt nur wenige Obon-Feiertage und es ist schwierig, nach Hause zu gehen", "Wenn aufeinanderfolgende Feiertage fortgesetzt werden, werde ich nach den Feiertagen faul sein". Sie können sich vorstellen, dass es ein Thema gibt.
Zu den Äußerungen, die gebrochen werden, gehören beispielsweise "Versuchen Sie, die Ernährung der Diät nicht zu beeinflussen" und "genug Schlaf zu bekommen". Es scheint ein Thema zu geben.
Ebenso sollten Sie anhand der Wörter erraten können, welche Themen in anderen Communities enthalten sind.
Extraktion von Communities durch Modularität
greedy_modularity_communities(G, weight=None)
①G
Diagramm angeben.
(Ungerichteter Graph G, der im vorherigen Abschnitt erstellt wurde_corlistO)
②weight
Gibt die Kante mit der Zahl an, die als Gewicht verwendet werden soll. Wenn Keine, werden alle Kantengewichte als gleich betrachtet.
Klicken Sie hier für Anwendungsbeispiele
import os
import json
import pandas as pd
import numpy as np
import re
from janome.tokenizer import Tokenizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx
import matplotlib.pyplot as plt
from networkx.algorithms.community import greedy_modularity_communities
#Geben Sie das Verzeichnis init100 an
file_path = './6110_nlp_preprocessing_data/init100/'
file_dir = os.listdir(file_path)
#Erstellen Sie eine Liste mit Flags und Äußerungen
label_text = []
for file in file_dir[:20]:
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)
#Entfernen Sie Duplikate und extrahieren Sie nur nicht gebrochene Äußerungen
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']
#Morphologische Analyse von Janome
t = Tokenizer()
morpO = []
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', '')
for token in t.tokenize(reg_row):
tmp1.append(token.surface)
tmp2 = ' '.join(tmp1)
morpO.append(tmp2)
tmp1 = []
# TF-Erstellen Sie eine nach IDF-Wert gewichtete Word-Dokumentmatrix
morpO_array = np.array(morpO)
tfidf_vecO = TfidfVectorizer(use_idf=True)
morpO_tfidf_vecs = tfidf_vecO.fit_transform(morpO_array)
morpO_tfidf_array = morpO_tfidf_vecs.toarray()
#In das DataFrame-Format konvertieren und Korrelationsmatrix erstellen
dtmO = pd.DataFrame(morpO_tfidf_array, columns=tfidf_vecO.get_feature_names(),
index=morpO)
corr_matrixO = dtmO.corr().abs()
#Erstellen eines nicht fehlerhaften Sprachdatensatzes
corr_stackO = corr_matrixO.stack()
index = pd.Series(corr_stackO.index.values)
value = pd.Series(corr_stackO.values)
tmp3 = []
tmp4 = []
for i in range(0, len(index)):
if value[i] >= 0.5 and value[i] < 1.0:
tmp1 = str(index[i][0]) + ' ' + str(index[i][1])
tmp2 = [s for s in tmp1.split()]
tmp3.append(tmp2)
tmp4 = np.append(tmp4, value[i])
tmp3 = pd.DataFrame(tmp3)
tmp3 = tmp3.rename(columns={0: 'node1', 1: 'node2'})
tmp4 = pd.DataFrame(tmp4)
tmp4 = tmp4.rename(columns={0: 'weight'})
df_corlistO = pd.concat([tmp3, tmp4], axis=1)
#Erstellen Sie ein ungerichtetes Diagramm
G_corlistO = nx.from_pandas_edgelist(df_corlistO, 'node1', 'node2', ['weight'])
#Für nicht fehlerhafte Sprachdatensätze
#Gemeinschaftsextraktion
cm_corlistO = list(greedy_modularity_communities(G_corlistO, weight='weight'))
#Zeigen Sie Knoten an, die zu jeder Community gehören
cm_corlistO
Recommended Posts