[PYTHON] 100 Sprachverarbeitung klopfen 2020 "für Google Colaboratory"

Da sich die Fakultät von der Gorigori-Fakultät für Naturwissenschaften und von der Graduiertenschule bis zum Sprachverarbeitungslabor widerspiegelte, bin ich ein Anfänger in der Zeichenfolgenverarbeitung. Wenn Sie Fragen haben, melden Sie diese bitte. Sie können es verwenden, indem Sie es so kopieren, wie es ist.

Wie installiere ich MeCab in Google Collaboration, wie schreibe ich Matplotlib auf Japanisch usw. Von Zeit zu Zeit aktualisiert

Abschnitt 1 [Vorbereitungsbewegung]

1. Umgekehrte Reihenfolge der Zeichenfolgen Permalink

Holen Sie sich eine Zeichenfolge, in der die Zeichen der Zeichenfolge "betont" umgekehrt angeordnet sind (vom Ende bis zum Anfang)

qiita.rb

target='stressed'
def reverse(target):
  length_target = len(target)
  w=target
  rve=''    
  for i in range(length_target):
    rve += w[length_target - i-1]
  return rve

print(reverse(target))
print(target[::-1])

Ich habe es auf zwei Arten versucht. Python kämpfte nüchtern, weil ich nur die numerische Datenverarbeitung berührt hatte. Wenn Sie Freizeit haben, können Sie nach der Überprüfung immer mehr weiterkommen!

2. "Patatokukashi"

qiita.rb

#1 der Zeichenkette "Patatokukashii",3,5,Nehmen Sie das 7. Zeichen heraus und erhalten Sie die verkettete Zeichenfolge.
w='Patatoku Kashii'
w_even = ""
w_odd = ''
j=0
for i in w:
  if ( j % 2 == 0):
    w_even += w[j]
  if (j % 2 == 1):
    w_odd += w[j]
  j+=1

print(w_even,w_odd)

3. "Pat car" + "Tax" = "Patatokukasie" Permalink

qiita.rb

#Holen Sie sich die Zeichenkette "Patatokukashi", indem Sie die Zeichen "Pattocar" + "Tax" von Anfang an abwechselnd verbinden.

w=''
for i in range(max(len(w_even),len(w_odd))):
  w += w_even[i]
  w += w_odd[i]
w 

04. Elementsymbol

qiita.rb

s = 'Hi He Lied Because Boron Could Not Oxidize Fluorine. New Nations Might Also Sign Peace Security Clause. Arthur King Can.'
#Wird in Worte zerlegt, 1, 5, 6, 7, 8, 9, 15, 16,Das 19. Wort ist das erste Zeichen, und die anderen Wörter sind die ersten beiden Zeichen und die Position des Wortes aus der extrahierten Zeichenfolge.
#Erstellen Sie ein assoziatives Array (Wörterbuchtyp oder Kartentyp) für (wie viele Wörter von Anfang an).

def Permalink(s):
  s_list = s.split()
  num=len(s_list)
  w={}
  for i in range(num):
    if (i==1-1 or i== 5-1 or i== 6-1 or i== 7-1 or i== 8-1 or i== 9-1 or i== 15-1 or i== 16-1 or i== 19-1):
 #     w.append(s_list[i][0])
       w[i]=(s_list[i][0])
    else:
      w[i]=(s_list[i][0]+s_list[i][1])
  print(w)
  
Permalink(s)

5. n-gram Erstellen Sie eine Funktion, die aus einer bestimmten Sequenz (Zeichenfolge, Liste usw.) ein n-Gramm erstellt. Verwenden Sie diese Funktion, um das Wort Bi-Gramm und den Buchstaben Bi-Gramm aus dem Satz "Ich bin ein NLPer" zu erhalten.

qiita.rb

def n_gram_word(sentense,n):
  sen=sentense.split()
  w={}
  w=set(w)
  num=len(sen)
  for i in range(num - n + 1):
    w0 = ''
    for j in range(n):
      w0 += sen[i+j]
      w0 += ' '
    w.add(w0)
  return w

def n_gram_moji(sentense,n):
  sentense=sentense.replace(' ','')
  sen=list(sentense)
  w={}
  w=set(w)
  num=len(sen)
  for i in range(num - n + 1):
    w0 = ''
    for j in range(n):
      w0 += sen[i+j]
    w.add(w0)
  return w

s='I am an NLPer'
n_gram_word(s,2)

06. Treffen

Suchen Sie den in "paraparaparadise" und "Absatz" enthaltenen Satz von Zeichen-Bi-Gramm als X bzw. Y und suchen Sie den Summensatz, den Produktsatz und den Differenzsatz von X bzw. Y. Finden Sie außerdem heraus, ob das Bi-Gramm in X und Y enthalten ist.

qiita.rb

s1 = "paraparaparadise"
s2 = "paragraph"

w1=n_gram_moji(s1,2)
w2=n_gram_moji(s2,2)
print(type(w1))
print('Die Summe ist', w1 | w2)
print('Das Produktset ist', w1 & w2)
print('Der Differenzsatz ist', w1 - w2)

W={'se'}
print(W<=w1)
print(W<=w2)

07. Anweisungserstellung durch Vorlage Permalink

Implementieren Sie eine Funktion, die die Argumente x, y, z verwendet und die Zeichenfolge "y bei x ist z" zurückgibt. Zusätzlich ist x = 12, y = "Temperatur",

qiita.rb

z=22.Überprüfen Sie als 4 das Ausführungsergebnis
def temple(x,y,z):
  print(x,'von Zeit',y,'Ist',z)

temple(12,'Temperatur',22.4)

08. Kryptographie

Implementieren Sie die Funktionsverschlüsselung, die jedes Zeichen der angegebenen Zeichenfolge gemäß den folgenden Spezifikationen konvertiert. Durch Kleinbuchstaben ersetzen (219 - Zeichencode) Geben Sie andere Zeichen so aus, wie sie sind Verwenden Sie diese Funktion, um englische Nachrichten zu verschlüsseln / entschlüsseln.

qiita.rb

def chipher (s):
#  s=s.lower()
#  s=s.replace(' ', '')
  c=''
  for w in s:
    a = chr(219-ord(w))
    c+=a
  return c

def dechipher(s):
  c=''
  for w in s:
    a=chr(219-ord(w))
    c += a
  return c

s='Neuro Linguistic Programming  has two main definitions: while it began as a set of techniques to understand and codify the underlying elements of genius by modeling the conscious and unconscious behaviors of brilliant communicators and therapists, over the years, it has evolved into a set of frameworks, processes and protocols (the results of modeling) that qualified NLP Practitioners currently use to help evoke effective behavioral changes in clients.'
print(s)
print(chipher(s))
print(dechipher(chipher(s)))

9. Typoglycemia Erstellen Sie ein Programm, das die Reihenfolge der anderen Zeichen zufällig neu anordnet, wobei das erste und das letzte Zeichen jedes Wortes für die Wortfolge durch Leerzeichen getrennt bleiben. Wörter mit einer Länge von 4 oder weniger werden jedoch nicht neu angeordnet. Geben Sie einen geeigneten englischen Satz ein (zum Beispiel: "Ich konnte nicht glauben, dass ich tatsächlich verstehen konnte, was ich las: die phänomenale Kraft des menschlichen Geistes.") Und überprüfen Sie das Ausführungsergebnis.

qiita.rb

import random
def wordc (s):
  s=s.split()
  word=''
  for w in s:
    if len(w)>4:
      a=list(w)
      a.pop(0)
      num=len(w)
      a.pop(num-2)
      aa=list(w)
      random.shuffle(a)
      a.insert(0,aa[0])
      a.insert(len(w),aa[len(w)-1])
      w=''.join(a)
    word += w
    word += ' '
  return word
#s='volcano'
s='Neuro Linguistic Programming  has two main definitions: while it began as a set of techniques to understand and codify the underlying elements of genius by modeling the conscious and unconscious behaviors of brilliant communicators and therapists, over the years, it has evolved into a set of frameworks, processes and protocols (the results of modeling) that qualified NLP Practitioners currently use to help evoke effective behavioral changes in clients.'

print(wordc(s))

Das einzige, was zählt, ist, wie das MeCab in Kapitel 3 eingefügt wird. Lassen Sie uns also zuerst fortfahren.

Abschnitt 2 [UNIX-Befehl]

Ich habe es selbst geschrieben, aber mit Bezug auf andere Leute

Antwort und Eindruck von 100 Sprachverarbeitungsklopfen - Teil 1

Abschnitt 3 [Regulärer Ausdruck]

Es gibt eine Datei jawiki-country.json.gz, die Wikipedia-Artikel im folgenden Format exportiert.

• Informationen zu einem Artikel pro Zeile werden im JSON-Format gespeichert

• In jeder Zeile wird der Artikelname im Schlüssel "title" und der Artikelkörper im Wörterbuchobjekt mit dem Schlüssel "text" gespeichert, und dieses Objekt wird im JSON-Format ausgeschrieben.

• Die gesamte Datei wird komprimiert

• Erstellen Sie ein Programm, das die folgende Verarbeitung ausführt.

20. JSON-Daten lesen

Lesen Sie die JSON-Datei des Wikipedia-Artikels und zeigen Sie den Artikeltext zu "UK" an. Führen Sie in den Problemen 21-29 den hier extrahierten Artikeltext aus.

qiita.rb

!wget http://www.cl.ecei.tohoku.ac.jp/nlp100/data/jawiki-country.json.gz

qiita.rb

## 20
import json, gzip
with gzip.open('jawiki-country.json.gz', 'rt') as f:
    country = json.loads(f.readline())
    while(country):
            country = json.loads(f.readline())
            if country['title'] == "England":
                break

print(country)

qiita.rb

puts 'code with syntax'

Die Daten verschwanden ...

Abschnitt 4 [morphologische Analyse]

Verwenden Sie MeCab, um den Text (neko.txt) von Natsume Sosekis Roman "Ich bin eine Katze" morphologisch zu analysieren und das Ergebnis in einer Datei namens neko.txt.mecab zu speichern. Verwenden Sie diese Datei, um ein Programm zu implementieren, das die folgenden Fragen beantwortet.

Verwenden Sie für die Probleme 37, 38, 39 matplotlib oder Gnuplot.

qiita.rb

!wget http://www.cl.ecei.tohoku.ac.jp/nlp100/data/neko.txt
with open ('./neko.txt') as f:
  t = tagger.parse(f.read())
  with open ('./neko.txt.mecab', mode = 'w') as ff:
    ff.write(t)

qiita.rb

!apt install aptitude
!aptitude install mecab libmecab-dev mecab-ipadic-utf8 git make curl xz-utils file -y
!pip install mecab-python3==0.7

Sie können jetzt MeCab installieren. Ist! Apt ein UNIX-System? ! Eignung ist Ubuntu? Ich bin mir darüber nicht sicher. Ich habe auf andere Websites verwiesen. Aktivieren Sie MeCab im Labor.

30. Lesen der Ergebnisse der morphologischen Analyse

Implementieren Sie ein Programm, das die Ergebnisse der morphologischen Analyse liest (neko.txt.mecab). Jedes morphologische Element wird jedoch in einem Zuordnungstyp mit der Oberfläche, der Grundform (Basis), einem Teil des Wortes (pos) und einem Teil der Wortunterklassifizierung 1 (pos1) als Schlüssel gespeichert, und ein Satz wird als Liste morphologischer Elemente (Zuordnungstyp) ausgedrückt. Machen wir das. Verwenden Sie für die restlichen Probleme in Kapitel 4 das hier erstellte Programm.

qiita.rb

with open ('./neko.txt.mecab') as f:
  line = f.readline()
  worddict = dict()
  surface = list()
  pronaunce = list()
  base = list()
  pos = list()
  pos1 = list()
  while 'EOS' not in line:
    t = line.split('\t')
    surface.append(t[0])
    pronaunce.append(t[1])
    base.append(t[2])
    pos.append(t[3])
    pos1.append(t[4])
    line = f.readline()
worddict['surface'] = surface
worddict['pronaunce'] = pronaunce
worddict['base'] = base
worddict['pos'] = pos
worddict['pos1'] = pos1

Die Daten von 30 bis 36 verschwanden und es verdorrte wirklich. Es ist einfach, also SKIIIIP!

31. ** Vermalink **

Extrahieren Sie alle Oberflächenformen des Verbs.

32. Permalink, die ursprüngliche Form des Verbs

Extrahieren Sie alle Originalformen des Verbs.

33. "A's B" Permalink

Extrahieren Sie die Nomenklatur, in der zwei Nomenklaturen durch "Nein" verbunden sind.

34. Nomenklatur Permalink

Extrahieren Sie die Verkettung der Nomenklatur (Substantive, die nacheinander erscheinen) mit der längsten Übereinstimmung Die Daten sind viel verschwunden ... Ich werde es tun, wenn ich Zeit habe

35. Häufigkeit des Auftretens von Wörtern

Suchen Sie die Wörter, die im Satz erscheinen, und ihre Häufigkeit des Auftretens, und ordnen Sie sie in absteigender Reihenfolge der Häufigkeit des Auftretens an.

qiita.rb

tango = list()
for i in range(len(worddict['pos'])):
  t = worddict['pos'][i]
  if t[:2] == 'Substantiv':
    tango.append(worddict['surface'][i])
word_d = dict()
for t in set(tango):
  word_d[t] = tango.count(t)
wordsort = sorted(word_d.items(), key = lambda  x:-x[1])
print (wordsort)

#[('von', 1611), ('Ding', 1207), ('もvon', 981), ('Du', 973), ('Meister', 932), ('Hmm', 704), ('Yo', 697), ('Mann', 602), ('einer', 554), ('Was', 539), ('ich', 481), ('Dies', 414),

36. Top 10 der häufigsten Wörter

Zeigen Sie 10 Wörter mit hoher Häufigkeit des Auftretens und ihrer Häufigkeit des Auftretens in einem Diagramm an (z. B. einem Balkendiagramm). Beginnen Sie zunächst mit dem Erwerb japanischer Schriftarten. Andernfalls werden in der Grafik unzählige Tofus angezeigt.

qiita.rb

!apt-get -y  install fonts-ipafont-gothic
#Löschen Sie den Cache.
!rm /root/.cache/matplotlib/fontlist-v310.json #Cache gelöscht werden

Löschen Sie diese -340v. Es scheint jedoch für jede Version anders zu sein, und es war ein anderer Wert auf anderen Websites. Daher muss jede Person bestätigen.

qiita.rb

!ls  /root/.cache/matplotlib/
#Dieses Verzeichnis kann mit dem folgenden Code abgerufen werden.
matplotlib.get_cachedir()

qiita.rb

wordhead = dict(wordsort[:10])
print(type(wordhead))
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(font='IPAGothic')

plt.bar(wordhead.keys(),wordhead.values())
plt.show()

Ich war ziemlich beeindruckt, als das erledigt war. Sie können es auf Japanisch tun. .. .. Wenn Sie in den Tagen des Studiums gewesen sind ...

37. Top 10 Wörter, die häufig zusammen mit "cat" Permalink vorkommen

Zeigen Sie 10 Wörter, die häufig zusammen mit "Katzen" auftreten (hohe Häufigkeit des gemeinsamen Auftretens), und deren Häufigkeit des Auftretens in einem Diagramm (z. B. einem Balkendiagramm) an.

qiita.rb

cooc = dict()
coocdict = dict()
cooclist = list()
for i in range(len(worddict['surface'])):
  t = worddict['pos'][i]
  if (t[:2] != 'Partikel' and t[:2] != 'Symbol' and t[:3] != 'Hilfsverb'):
    cooclist.append(worddict['surface'][i])
for t in set(cooclist) :
  coocdict[t] = 0
#print(cooclist)
for i in range(len(cooclist)):
  if cooclist[i] == 'Katze':
    coocdict[cooclist[i-1]] = coocdict[cooclist[i-1]] + 1
    coocdict[cooclist[i+1]] = coocdict[cooclist[i+1]] + 1
coocsort = sorted (coocdict.items(), key = lambda x: -x[1])
coochead = dict(coocsort[:10])
plt.bar(coochead.keys(), coochead.values())

Schmutziger Code. Es gibt absolut gute Wege. Obwohl ich in einem Sprachverarbeitungslabor war, kannte ich das Wort nicht gleichzeitig, so dass es zu einem Engpass wurde. Es wäre interessant, wenn ich meine Sensibilität auch mit word2vec oder solchen verteilten Ausdrücken ein wenig ausdrücken könnte.

39. Zipfs Gesetz

Zeichnen Sie beide logarithmischen Graphen mit der Häufigkeit des Auftretens von Wörtern auf der horizontalen Achse und der Häufigkeit des Auftretens auf der vertikalen Achse.

qiita.rb

ziplow = dict()
for t in set(worddict['base']):
  ziplow[t] = worddict['base'].count(t)
import math
zipsort = sorted(ziplow.items(), key = lambda x:-x[1])
zipsort[:100]
zipplot= list()
logi=list()
for i in range(len(set(worddict['base']))):
  logi.append(math.log10(i+1))
  zipplot.append(math.log10(zipsort[i][1]))
print(zipplot[:][0])
plt.scatter(logi, zipplot)

Ich glaube nicht, dass ich dies in der Klasse "Verarbeitung natürlicher Sprache" angesprochen habe, an der ich als Student ohne Erlaubnis teilgenommen habe. Obwohl eine bestimmte Universität die Initiative ergreift, ist die Zahl dieselbe wie bei HP (wenn der Prototyp extrahiert wird).

Abschnitt 5 [Abhängigkeitsanalyse]

Installieren Sie zuerst CaboCha.

qiita.rb

#Installieren Sie Mecab
!apt install aptitude
!aptitude install mecab libmecab-dev mecab-ipadic-utf8 git make curl xz-utils file -y
!pip install mecab-python3==0.7

qiita.rb

import os
#Erstellen Sie die angegebene Zieldatei
filename_crfpp = 'crfpp.tar.gz'
!wget "https://drive.google.com/uc?export=download&id=0B4y35FiV1wh7QVR6VXJ5dWExSTQ" -O $filename_crfpp
#Extrahieren Sie das Archiv und verschieben Sie es in die angegebene Datei
!tar zxvf $filename_crfpp
#Nach CRF verschoben und im aktuellen Verzeichnis vorhanden.!ls ./Überprüfen Sie bei
%cd CRF++-0.58
#Führen Sie hier die Skriptdatei configure aus. Es gibt keinen Befehl mit diesem Namen
!./configure
#Es wird technisch, wenn es in der laufenden Umgebung mit configure ist. Wenn diese Option deaktiviert ist, wird ein Makefile erstellt und mit dem folgenden Make ohne Optionen ausgeführt.
!make
!make install
%cd ..
os.environ['LD_LIBRARY_PATH'] += ':/usr/local/lib' 

qiita.rb

FILE_ID = "0B4y35FiV1wh7SDd1Q1dUQkZQaUU"
FILE_NAME = "cabocha.tar.bz2"
!wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=$FILE_ID' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=$FILE_ID" -O $FILE_NAME && rm -rf /tmp/cookies.txt
!tar -xvf cabocha.tar.bz2

%cd cabocha-0.69
!./configure --with-mecab-config=`which mecab-config` --with-charset=UTF8
!make
!make check
!make install
%cd ..
!cabocha --version

Befehl zur Verwendung in Python

qiita.rb

%cd cabocha-0.69/python
!python setup.py build_ext
!python setup.py install
!ldconfig
%cd ../..

Verwenden Sie CaboCha, um eine Abhängigkeitsanalyse des Textes (neko.txt) von Natsume Sosekis Roman "Ich bin eine Katze" durchzuführen, und speichern Sie das Ergebnis in einer Datei namens neko.txt.cabocha. Verwenden Sie diese Datei, um ein Programm zu implementieren, das die folgenden Fragen beantwortet.

qiita.rb

!wget http://www.cl.ecei.tohoku.ac.jp/nlp100/data/neko.txt
import CaboCha
c = CaboCha.Parser()
with open ('neko.txt') as f:
  with open ('neko.txt.cabocha', mode = 'w') as ff:
    line = f.readline()
    while line:
      ff.write(c.parse(line).toString(CaboCha.FORMAT_LATTICE))
      line = f.readline()

40. Lesen des Ergebnisses der Abhängigkeitsanalyse (Morphologie)

Implementieren Sie die Klasse Morph, die die Morphologie darstellt. Diese Klasse hat eine Oberflächenform (Oberfläche), eine Basisform (Basis), ein Teilwort (pos) und eine Teilwortunterklassifikation 1 (pos1) als Elementvariablen. Lesen Sie außerdem das Analyseergebnis von CaboCha (neko.txt.cabocha), drücken Sie jeden Satz als Liste von Morph-Objekten aus und zeigen Sie die morphologische Elementzeichenfolge des dritten Satzes an.

41. Lesen des Abhängigkeitsanalyseergebnisses (Phrase / Abhängigkeit) Permalink

Implementieren Sie zusätzlich zu 40 die Klauselklasse Chunk. Diese Klasse verfügt über eine Liste von Morph-Elementen (Morph-Objekten) (Morphs), eine Liste verwandter Klauselindexnummern (dst) und eine Liste verwandter ursprünglicher Klauselindexnummern (srcs) als Mitgliedsvariablen. Lesen Sie außerdem das Analyseergebnis von CaboCha des Eingabetextes, drücken Sie einen Satz als Liste von Chunk-Objekten aus und zeigen Sie die Zeichenfolge und den Kontakt der Phrase des achten Satzes an. Verwenden Sie für die restlichen Probleme in Kapitel 5 das hier erstellte Programm.

40 und 41 haben alles auf einmal gemacht. Weil es Vererbung in Brocken und Morphologie hat.

qiita.rb

class Morph:
  def __init__(self, line):
    line = line.replace('\t',',').split(',')
    self.surface =  line[0]
    #Nya Nya hat keine Grundform, da sie nicht verarbeitet werden kann
    self.base = line[0]
    self.pos = line[1]
    self.pos1 = line[2]

  def out_morph(self):
    print(type(self.surface))

  def listmaker (self):
    t = [self.surface, self.base, self.pos, self.pos1]
    return t

class Chunk(Morph):
  def __init__(self, line):
    l_sp = line[0].split(' ')
    self.srcs = l_sp[1]
    self.dst = l_sp[2]
    m = []
    for i in range(len(line)):
      if i != 0:
        m.append (Morph(line[i]).listmaker())
    self.morph = m
    


  def __str__(self):
    c = [self.srcs, self.dst, self.morph]
    return c

with open ('neko.txt.cabocha') as f:
  text = f.read()
  t = [ r for r in text.split('EOS') if r != '\n']

  for text_EOS in t:
    line_chunk = list()
    a = 0
    b = 0
    num = 2
    t = [ r for r in text_EOS.split('\n') if r != '']
    for t in text_EOS.split('\n'):
      if (a == 1):
        num = 3
      if t != '':
        if a == len(text_EOS.split('\n'))-num:
          line_chunk.append(line)

        elif (t[0] == '*'):
          #Chunk ist fertig und gespeichert
          if line_chunk != '':
            line_chunk.append(line)
          line = list()
          line.append(t)

        elif(t[0] != '*'):
          line.append(t)

        a = a +1  
    b = b +1
    chunk = [Chunk(c).__str__() for c in line_chunk]
    print(chunk)

Später habe ich es in Form einer Liste zur einfachen Analyse erstellt. Das Ergebnis ist [Verantwortliche Quelle, Verantwortliche Partei, [Chunk]] Repräsentiert. Dieser [Chunk] -Teil hat die Form von [Oberfläche, Basis, Pos, Pos1] der Wörter, aus denen der Chunk besteht. [Verantwortliche Quelle, Verantwortliches Ziel, [[Oberfläche, Basis, pos, pos1] [Oberfläche, Basis, pos, pos1]]] Zum Beispiel so.

qiita.rb

[['1', '-1D', [['Vielen Dank', 'Vielen Dank', 'Adjektiv', 'Unabhängigkeit']]]]
[['0', '-1D', [['einer', 'einer', 'Substantiv', 'Nummer']]], ['0', '2D', [['\u3000', '\u3000', 'Symbol', 'Leer']]], ['1', '2D', [['ich', 'ich', 'Substantiv', '代Substantiv'], ['Ist', 'Ist', 'Partikel', '係Partikel']]], ['2', '-1D', [['Katze', 'Katze', 'Substantiv', 'einer般'], ['damit', 'damit', 'Hilfsverb', '*'], ['Gibt es', 'Gibt es', 'Hilfsverb', '*']]]]
[['2', '-1D', [['Katze', 'Katze', 'Substantiv', 'Allgemeines'], ['damit', 'damit', 'Hilfsverb', '*'], ['Gibt es', 'Gibt es', 'Hilfsverb', '*']]], ['0', '2D', [['Name', 'Name', 'Substantiv', 'Allgemeines'], ['Ist', 'Ist', 'Partikel', '係Partikel']]], ['1', '2D', [['noch', 'noch', 'Adverb', 'Partikel類接続']]], ['2', '-1D', [['Nein', 'Nein', 'Adjektiv', 'Unabhängigkeit']]]]
[['2', '-1D', [['Nein', 'Nein', 'Adjektiv', 'Unabhängigkeit']]], ['0', '1D', [['\u3000', '\u3000', 'Symbol', 'Leer'], ['Wo', 'Wo', 'Substantiv', '代Substantiv'], ['damit', 'damit', 'Partikel', '格Partikel']]], ['1', '4D', [['Geboren', 'Geboren', 'Verb', 'Unabhängigkeit'], ['Ta', 'Ta', '助Verb', '*'], ['Oder', 'Oder', 'Partikel', '副Partikel／並立Partikel／終Partikel']]], ['2', '4D', [['Tonto', 'Tonto', 'Adverb', 'Allgemeines']]], ['3', '4D', [['Registrieren', 'Registrieren', 'Substantiv', 'Verbindung ändern'], ['Aber', 'Aber', 'Partikel', '格Partikel']]], ['4', '-1D', [['つOder', 'つOder', 'Verb', 'Unabhängigkeit'], ['Nu', 'Nu', '助Verb', '*']]]]
[['4', '-1D', [['Tsuka', 'Tsuka', 'Verb', 'Unabhängigkeit'], ['Nu', 'Nu', '助Verb', '*']]], ['0', '1D', [['Was', 'Was', 'Substantiv', '代Substantiv'], ['Aber', 'Aber', 'Partikel', '副Partikel']]], ['1', '3D', [['dim', 'dim', 'Adjektiv', 'Unabhängigkeit']]], ['2', '3D', [['Feuchtigkeit', 'Feuchtigkeit', 'Adverb', 'Allgemeines'], ['Shi', 'Shi', 'Verb', 'Unabhängigkeit'], ['Ta', 'Ta', '助Verb', '*']]], ['3', '5D', [['Platz', 'Platz', 'Substantiv', '非Unabhängigkeit'], ['damit', 'damit', 'Partikel', '格Partikel']]], ['4', '5D', [['Miau Miau', 'Miau Miau', 'Substantiv', 'Allgemeines']]], ['5', '7D', [['Weinen', 'Weinen', 'Verb', 'Unabhängigkeit'], ['Hand', 'Hand', 'Partikel', '接続Partikel']]], ['6', '7D', [['いTa事', 'いTa事', 'Substantiv', 'Allgemeines'], ['Nur', 'Nur', 'Partikel', '副Partikel'], ['Ist', 'Ist', 'Partikel', '係Partikel']]], ['7', '-1D', [['Erinnerung', 'Erinnerung', 'Substantiv', 'Verbindung ändern'], ['Shi', 'Shi', 'Verb', 'Unabhängigkeit'], ['Hand', 'Hand', 'Partikel', '接続Partikel'], ['Ist', 'Ist', 'Verb', '非Unabhängigkeit']]]]
[['7', '-1D', [['Erinnerung', 'Erinnerung', 'Substantiv', 'Verbindung ändern'], ['Shi', 'Shi', 'Verb', 'Unabhängigkeit'], ['Hand', 'Hand', 'Partikel', '接続Partikel'], ['Ist', 'Ist', 'Verb', '非Unabhängigkeit']]], ['0', '5D', [['ich', 'ich', 'Substantiv', '代Substantiv'], ['Ist', 'Ist', 'Partikel', '係Partikel']]], ['1', '2D', [['Hier', 'Hier', 'Substantiv', '代Substantiv'], ['damit', 'damit', 'Partikel', '格Partikel']]], ['2', '3D', [['Start', 'Start', 'Verb', 'Unabhängigkeit'], ['Hand', 'Hand', 'Partikel', '接続Partikel']]], ['3', '4D', [['Mensch', 'Mensch', 'Substantiv', 'Allgemeines'], ['Das', 'Das', 'Partikel', '格Partikel']]], ['4', '5D', [['Ding', 'Ding', 'Substantiv', '非Unabhängigkeit'], ['Zu', 'Zu', 'Partikel', '格Partikel']]], ['5', '-1D', [['Sie sehen', 'Sie sehen', 'Verb', 'Unabhängigkeit'], ['Ta', 'Ta', '助Verb', '*']]]]
[['5', '-1D', [['Sie sehen', 'Sie sehen', 'Verb', 'Unabhängigkeit'], ['Ta', 'Ta', '助Verb', '*']]], ['0', '8D', [['Außerdem,', 'Außerdem,', 'Verbindung', '*']]], ['1', '2D', [['nach', 'nach', 'Substantiv', 'Allgemeines'], ['damit', 'damit', 'Partikel', '格Partikel']]], ['2', '8D', [['Hör mal zu', 'Hör mal zu', 'Verb', 'Unabhängigkeit'], ['Wann', 'Wann', 'Partikel', '接続Partikel']]], ['3', '8D', [['Es', 'Es', 'Substantiv', '代Substantiv'], ['Ist', 'Ist', 'Partikel', '係Partikel']]], ['4', '5D', [['Schüler', 'Schüler', 'Substantiv', 'Allgemeines'], ['Wannいう', 'Wannいう', 'Partikel', '格Partikel']]], ['5', '8D', [['Mensch', 'Mensch', 'Substantiv', 'Allgemeines'], ['Während ~', 'Während ~', 'Substantiv', 'Suffix'], ['damit', 'damit', 'Partikel', '格Partikel']]], ['6', '7D', [['Ichiban', 'Ichiban', 'Substantiv', 'Anwalt möglich']]], ['7', '8D', [['Böse', 'Böse', 'Substantiv', '形容Verb語幹'], ['Nana', 'Nana', '助Verb', '*']]], ['8', '-1D', [['Rennen', 'Rennen', 'Substantiv', 'Allgemeines'], ['damit', 'damit', '助Verb', '*'], ['Ah', 'Ah', '助Verb', '*'], ['Ta', 'Ta', '助Verb', '*'], ['damit', 'damit', 'Substantiv', 'Besondere'], ['Ist', 'Ist', '助Verb', '*']]]]

Ich habe mehrere Stunden gebraucht, um das zu klären. Nun, ich kannte die Klassenschrift nicht und bin froh, dass ich sie gemacht habe. Ich sehe die Bedeutung der Klasse immer noch nicht wirklich. Ist es normalerweise nicht möglich, eine Funktion innerhalb einer Funktion in Python zu erstellen?

42. Anzeige des Satzes der betroffenen Person und der betroffenen Person

Extrahieren Sie den gesamten Text der ursprünglichen Klausel und der zugehörigen Klausel in tabulatorgetrenntem Format. Geben Sie jedoch keine Symbole wie Satzzeichen aus.

qiita.rb

for sentence in chunk_transed[1:100]:
  setu = []
  print('¥n')
  for chunk in sentence[1:]:
    surface = str()
    
    for se in chunk[2]:
      if (se[2] != 'Symbol'):
        surface += se [0]

    if surface != '':
      setu.append([chunk[0], chunk[1],surface])


  for s in (setu):

    if (s[1] != '-1'):
      saki = s[1]

      for ss in setu:
        if ss[0] == saki:
          print(s[2] +'\t\t'+ ss[2])
#
¥n
ich bin eine Katze
¥n
Kein Name
Noch nicht
¥n
Wo wurdest du geboren
Geboren oder nicht
Ich verstehe es nicht
Ich habe keine Ahnung
¥n
Alles dunkel
An einem dunklen Ort
An einem feuchten Ort
Weinen an der Stelle
Miau miau weinen
Ich weine und erinnere mich
Ich erinnere mich nur an das, was ich war
¥n

43. Extrahieren Sie Klauseln mit Nomenklaturen in Bezug auf Klauseln mit Verben

Wenn sich Klauseln mit Nomenklatur auf Klauseln mit Verben beziehen, extrahieren Sie sie in einem durch Tabulatoren getrennten Format. Geben Sie jedoch keine Symbole wie Satzzeichen aus.

qiita.rb

for sentence in chunk_transed[1:100]:
  setu = []
  print('¥n')
  for chunk in sentence[1:]:
    surface = str()
    hanteiki_meisi = 0 
    hanteiki_dousi = 0 
    for se in chunk[2]:
      if (se[2] != 'Symbol'):
        surface += se [0]
      if se [2] == 'Substantiv':
        hanteiki_meisi = 1 #Der Zustand, in dem die Nomenklatur in der Klausel vorhanden ist
      if se [2] == 'Verb':
        hanteiki_dousi = 1 #Der Zustand, in dem das Verb in der Klausel existiert

    if surface != '':
      setu.append([chunk[0], chunk[1],surface, hanteiki_meisi, hanteiki_dousi])


  for s in (setu):

    if (s[1] != '-1') and (s[3] == 1):
      saki = s[1]
      for ss in setu:
        if (ss[0] == saki) and ss[4] == 1:
          print(s[2] +'\t\t'+ ss[2])

44. Visualisierung abhängiger Bäume

Visualisieren Sie den Abhängigkeitsbaum eines bestimmten Satzes als gerichteten Graphen. Zur Visualisierung ist es ratsam, den Abhängigkeitsbaum in die DOT-Sprache zu konvertieren und Graphviz zu verwenden. Verwenden Sie pydot, um gerichtete Diagramme direkt aus Python zu visualisieren.

qiita.rb

#coding:utf-8
import numpy as np
from PIL import Image
import pydot_ng as pydot

#chunk_Satz ist(Abhängig, Ziel)Taple
def graph_maker(chunk_sentence):
  graph = pydot.graph_from_edges(chunk_sentence, directed=True)
  graph.write_png("./result.png ")
  #Bilder laden
  im = Image.open("./result.png ")
  #Bild in Array konvertieren
  im_list = np.asarray(im)
  #Einfügen
  plt.imshow(im_list)
  #Anzeige
  plt.show()

def grapf_maker_dot (chunk_sentence):
  graph = pydot.Dot(graph_type='digraph')

qiita.rb

all_edge = []
for sentence in chunk_transed[1:100]:
  setu = []
  for chunk in sentence[1:]:
    surface = str()
    
    for se in chunk[2]:
      if (se[2] != 'Symbol'):
        surface += se [0]

    if surface != '':
      setu.append([chunk[0], chunk[1],surface])
  #setu habun
  all_edge_sentence = []
  for s in (setu):
    
    if (s[1] != '-1'):
      saki = s[1]

      for ss in setu:
        if ss[0] == saki:
          edge_sentense = ((s[2] , ss[2]))
          all_edge_sentence.append(edge_sentense)
  all_edge.append(all_edge_sentence)

graph_maker(tuple(all_edge[22]))

45. Extraktion von Verbfallmustern

Ich möchte den diesmal verwendeten Satz als Korpus betrachten und die möglichen Fälle japanischer Prädikate untersuchen. Stellen Sie sich das Verb als Prädikat und das Hilfsverb der Phrase, die sich auf das Verb bezieht, als Fall vor und geben Sie das Prädikat und den Fall in einem durch Tabulatoren getrennten Format aus. Stellen Sie jedoch sicher, dass die Ausgabe den folgenden Spezifikationen entspricht.

• In einer Klausel, die ein Verb enthält, wird die Grundform des Verbs ganz links als Prädikat verwendet.
• Der Fall ist das Hilfswort, das sich auf das Prädikat bezieht
• Wenn das Prädikat mehrere Hilfswörter (Phrasen) enthält, ordnen Sie alle Hilfswörter in Wörterbuchreihenfolge an, die durch Leerzeichen getrennt sind.

Betrachten Sie den Beispielsatz (8. Satz von neko.txt.cabocha), der besagt, dass "ich hier zum ersten Mal einen Menschen gesehen habe". Dieser Satz enthält zwei Verben, "begin" und "see", und die Phrase, die sich auf "begin" bezieht, wird als "here" analysiert, und die Phrase, die sich auf "see" bezieht, wird als "I am" und "thing" analysiert. Sollte die folgende Ausgabe erzeugen.

Sehen

Speichern Sie die Ausgabe dieses Programms in einer Datei und überprüfen Sie die folgenden Elemente mit UNIX-Befehlen.

Eine Kombination von Prädikaten und Fallmustern, die häufig im Korpus vorkommen Fallmuster der Verben "do", "see" und "give" (in der Reihenfolge der Häufigkeit des Auftretens im Korpus anordnen)

qiita.rb

kaku = dict()
for sentence in chunk_transed[1:]:
  setu = []
  for chunk in sentence[1:]:
    josi = ''
    dousi = ''
    hanteiki_meisi = 0 
    hanteiki_dousi = 0 
    for se in chunk[2]:
      if (se[2] != 'Symbol'):
 #       word += se [0]
        if se [2] == 'Partikel':
          hanteiki_meisi = 1 #Der Zustand, in dem die Nomenklatur in der Klausel vorhanden ist
          josi = se[0]
        if se [2] == 'Verb':
          hanteiki_dousi = 1 #Der Zustand, in dem das Verb in der Klausel existiert
          dousi = se[1]

    if surface != '':
      setu.append([chunk[0], chunk[1],josi, dousi, hanteiki_meisi, hanteiki_dousi])


  for s in (setu):

    if (s[1] != '-1') and (s[4] == 1):
      saki = s[1]
      for ss in setu:
        if (ss[0] == saki) and ss[5] == 1:
          if ss[3] in set(kaku.keys()):
            kaku[ss[3]].append(s[2])
          else:
            kaku[ss[3]] = [s[2]]

text = str()
for keys, values in kaku.items():
  values_sort = sorted(set(values))
  josi = keys + '\t'
  for v in values_sort:
    josi += v + ' '
  josi = josi + '\n'
  text += josi
  print(josi)
with open ('./kaku.txt' , mode ='w') as f:
  f.write(text)

47. Mining der funktionalen Verbsyntax

Ich möchte nur auf den Fall achten, in dem das Verb wo case ein Sa-hen-Verbindungsnomen enthält. Ändern Sie 46 Programme, um die folgenden Spezifikationen zu erfüllen.

• Nur wenn die Phrase bestehend aus "Sahen-Verbindungsnomen + (Hilfsverb)" mit dem Verb verwandt ist
• Das Prädikat lautet "Sahen-Verbindungsnomen + ist die Grundform von + Verb". Wenn die Phrase mehrere Verben enthält, wird das Verb ganz links verwendet.
• Wenn das Prädikat mehrere Hilfswörter (Phrasen) enthält, ordnen Sie alle Hilfswörter in Wörterbuchreihenfolge an, die durch Leerzeichen getrennt sind.
• Wenn es mehrere Klauseln gibt, die sich auf das Prädikat beziehen, ordnen Sie alle Begriffe durch Leerzeichen getrennt an (richten Sie sie nach der Reihenfolge der Hilfswörter aus).
• Zum Beispiel sollte die folgende Ausgabe aus dem Satz erhalten werden: "Der Meister wird auf den Brief antworten, auch wenn er an einen anderen Ort kommt."

Wenn ich auf den Brief antworte, mein Mann

Speichern Sie die Ausgabe dieses Programms in einer Datei und überprüfen Sie die folgenden Elemente mit UNIX-Befehlen.

• Prädikate, die häufig im Korpus vorkommen (Sahen-Verbindungsnomenklatur + + Verb)
• Prädikate und Verbmuster, die häufig im Korpus vorkommen

qiita.rb

puts 'code with syntax'

48. Extrahieren von Pfaden von der Nomenklatur zu den Wurzeln

Extrahieren Sie für eine Klausel, die die gesamte Nomenklatur des Satzes enthält, den Pfad von dieser Klausel zum Stamm des Syntaxbaums. Der Pfad im Syntaxbaum muss jedoch die folgenden Spezifikationen erfüllen.

Jede Klausel wird durch eine (oberflächliche) morphologische Sequenz dargestellt Verketten Sie von der Startklausel bis zur Endklausel des Pfads die Ausdrücke jeder Klausel mit "->". Aus dem Satz "Ich habe hier zum ersten Mal einen Menschen gesehen" (8. Satz von neko.txt.cabocha) sollte die folgende Ausgabe erhalten werden.

ich bin->sah
Hier->Beginnen mit->Mensch->Dinge->sah
Mensch->Dinge->sah
Dinge->sah

qiita.rb

i= 0
for sentence in chunk_transed[1:10]:
  i = i + 1
  setu = []
  print(i, 'Linie')
  for chunk in sentence[1:]:
    surface = str()
    
    for se in chunk[2]:
      if (se[2] != 'Symbol'):
        surface += se [0]

    if surface != '':
      setu.append([chunk[0], chunk[1],surface])

# setu = (Abhängigkeitsnummer, Kontaktnummer, Ausdruck)
  koubunki = ''
  for s in (setu):
    if (s[1] != '-1'):
      saki = s[1]
      koubunki = s[2]
      for ss in setu:

        if ss[0] == saki:
          koubunki += ' --> ' + ss[2]
          saki = ss[1]
          
      print(koubunki)
Die erste Zeile
ich bin-->Sei eine Katze
2. Zeile
Name ist-->Nein
noch-->Nein
3. Zeile
wo-->Wurde geboren-->Verwende nicht
Wurde geboren-->Verwende nicht
Tonto-->Verwende nicht
Ich habe eine Ahnung-->Verwende nicht

49. Extraktion von Abhängigkeitspfaden zwischen Nomenklatur

Extrahieren Sie den kürzesten Abhängigkeitspfad, der alle Nomenklaturpaare im Satz verbindet. Wenn jedoch die Klauselnummern des Nomenklaturpaars i und j sind (i <j), muss der Abhängigkeitspfad die folgenden Spezifikationen erfüllen.

• Ähnlich wie bei Problem 48 drückt der Pfad die Darstellung jeder Klausel von der Startklausel bis zur Endklausel (oberflächenmorphologische Elementzeichenfolge) aus, indem sie mit "->" verkettet werden.
• Ersetzen Sie die in den Abschnitten i und j enthaltene Nomenklatur durch X bzw. Y.

Darüber hinaus kann die Form des Abhängigkeitspfads auf zwei Arten betrachtet werden.

• Wenn Klausel j im Pfad von Klausel i zum Stammverzeichnis des Syntaxbaums vorhanden ist: Zeigen Sie den Pfad von Klausel i zu Klausel j an
• Anders als oben, wenn sich Klausel i und Klausel j an einer gemeinsamen Klausel k auf dem Pfad von Klausel j zur Wurzel des Syntaxbaums überschneiden: der Pfad unmittelbar vor Klausel i zu Klausel k und der Pfad unmittelbar vor Klausel j zu Klausel k, Klausel Zeigen Sie den Inhalt von k an, indem Sie ihn mit "|" verbinden.

Die folgende Ausgabe sollte beispielsweise aus dem Satz "Ich habe hier zum ersten Mal einen Menschen gesehen" (8. Satz von neko.txt.cabocha) erhalten werden.

X ist|In Y.->Beginnen mit->Mensch->Dinge|sah
X ist|Genannt Y.->Dinge|sah
X ist|Y.|sah
In X.->Beginnen mit-> Y
In X.->Beginnen mit->Mensch-> Y
X genannt-> Y

Abschnitt 6 [Maschinelles Lernen]

In diesem Kapitel verwenden wir den von Fabio Gasparetti veröffentlichten News Aggregator-Datensatz, um die Überschriften von Nachrichtenartikeln in die Kategorien "Business", "Wissenschaft und Technologie", "Unterhaltung" und "Gesundheit" zu klassifizieren.

50. Daten erhalten und gestalten

Laden Sie News Aggregator Data Set herunter und folgen Sie den nachstehenden Anweisungen, um Trainingsdaten (train.txt) und Verifizierungsdaten (valid.txt) zu trainieren. ， Erstellen Sie Bewertungsdaten (test.txt).

1. Entpacken Sie die heruntergeladene Zip-Datei und lesen Sie die Erklärung zu readme.txt.
2. Extrahieren Sie nur Fälle (Artikel), deren Informationsquellen (Herausgeber) "Reuters", "Huffington Post", "Businessweek", "Contactmusic.com" und "Daily Mail" sind.
3. Sortieren Sie die extrahierten Fälle nach dem Zufallsprinzip.
4. Teilen Sie 80% der extrahierten Fälle in Trainingsdaten und die restlichen 10% in Verifizierungsdaten und Bewertungsdaten auf und speichern Sie sie unter den Dateinamen train.txt, valid.txt bzw. test.txt. Schreiben Sie einen Fall pro Zeile in die Datei und verwenden Sie das durch Tabulatoren getrennte Format des Kategorienamens und der Artikelüberschrift (diese Datei wird später in Problem 70 wiederverwendet). Überprüfen Sie nach dem Erstellen der Trainingsdaten und Bewertungsdaten die Anzahl der Fälle in jeder Kategorie.

qiita.rb

!wget https://archive.ics.uci.edu/ml/machine-learning-databases/00359/NewsAggregatorDataset.zip
import zipfile
with zipfile.ZipFile('./NewsAggregatorDataset.zip') as existing_zip:
    existing_zip.extractall('./')
with open('./readme.txt') as f:
  text = f.read()
  print(text)

qiita.rb

from sklearn.model_selection import train_test_split
import random
#Daten zum Array
with open('./newsCorpora.csv') as f:
  text = f.readline()
  allinfo = []
  print([r for r in text.replace('\n', '').split('\t') if r != ''])
  while text:
    allinfo.append([r for r in text.replace('\n', '').split('\t') if r != ''])
    text = f.readline()
#Datenauswahl
selectinfo = []
for info in allinfo:
  if info[3] == 'Reuters'or info[3] == 'Huffington Post'or info[3] =='Businessweek'or info[3] =='Contactmusic.com'or info[3] =='Daily Mail':
    selectinfo.append(info)
#Daten randomisieren und teilen
random.shuffle(selectinfo)
print(selectinfo[:50])
train , testandaccess = train_test_split(selectinfo,train_size = 0.8)
valid, test = train_test_split(testandaccess, train_size = 0.5)
#Beschreibung der Daten
with open ('./train.txt', mode = 'w') as f:
  train_txt = str()
  for t in train:
    for i in range(len(t)):
      if i == len(t) -1:
        train_txt += t[i] + '\n'
      else:
        train_txt += t[i] + '\t'
  f.write(train_txt)
with open ('./valid.txt', mode = 'w') as f:
  valid_txt = str()
  for t in valid:
    for i in range(len(t)):
      if i == len(t) -1:
        valid_txt += t[i] + '\n'
      else:
        valid_txt += t[i] + '\t'
  f.write(valid_txt)
with open ('./test.txt', mode = 'w') as f:
  test_txt = str()
  for t in test:
    for i in range(len(t)):
      if i == len(t) -1:
        test_txt += t[i] + '\n'
      else:
        test_txt += t[i] + '\t'
  f.write(test_txt)

51. Merkmalsextraktion

Extrahieren Sie die Funktionen aus den Trainingsdaten, Verifizierungsdaten und Bewertungsdaten und speichern Sie sie unter den Dateinamen train.feature.txt, valid.feature.txt bzw. test.feature.txt. Entwerfen Sie die Funktionen, die für die Kategorisierung wahrscheinlich nützlich sind. Die minimale Grundlinie wäre eine Artikelüberschrift, die in eine Wortfolge konvertiert wird.

qiita.rb

with open('./train.txt') as f:
  with open('./valid.txt') as ff:
    with open('./test.txt') as fff:
      i = 0
      name = ['train', 'valid', 'test']
      FF = [f,ff,fff]
      data_dict = dict() 
      for F in FF:
        text = F.readline()
        a = 'feature_' + name[i]
        array = []
        while text:
          t = ([r for r in text.replace('\n', '').split('\t') if r != ''])
          tt = [t[i] for i in range(len(t)) if i == 1 or i == 3 or i == 4 ]
          array.append(tt)
          text = F.readline()
        data_dict[a] = array
        i = i + 1

print(len(valid))
print(len(data_dict['feature_valid']))
print('Die Zahlen stimmen überein → Die obige Arbeit wurde normal ausgeführt')

with open('./train.feature.txt', mode = 'w') as f:
  with open('./valid.feature.txt', mode = 'w') as ff:
    with open('./test.feature.txt', mode = 'w') as fff:
      name = ['feature_train', 'feature_valid', 'feature_test']
      FF = [f,ff,fff]

      for i in range(len(FF)):
          txt = str()
          for t in data_dict[name[i]]:

            for l in range(len(t)):
              if l == len(t) -1:
                txt += t[l] + '\n'
              else:
                txt += t[l] + '\t'
          FF[i].write(txt)
with open('./valid.feature.txt') as f:
  t = f.read()
  print('[Teil der gültigen Datei]')
  print(t[:100])

52. Lernen

Lernen Sie das logistische Regressionsmodell anhand der in 51 erstellten Trainingsdaten. Überprüfung der logistischen Regression => Klassifizierungsproblem, keine Regression

Überprüfung der logistischen Regression => Klassifizierungsproblem, keine Regression

L(\theta) = \sum_{i=0}^{N} \log p(x | y)

Reduziert auf Optimierungsprobleme diesmal

$p(x | y)|_{y_i = 1} = f = \frac{1} {1 + \exp( -{\theta^{ T}} {\bf x} ) } $

Und definieren Sie die Softmax-Funktion

==>

$ \theta_i <= \theta_i + \eta \frac{\partial L}{\partial \theta_i} $

Hier,

\frac{\partial L}{\partial \theta_i} = \frac{\partial L}{\partial f_{\theta}(x)}\frac{\partial f_{\theta}(x)}{\partial \theta_i}

Wenn der erste Term berechnet wird

$\frac{\partial L}{\partial \theta_i} = \frac{y_i - f_{\theta}(x)}{f_{\theta}(x)(1-f_{\theta}(x))}\frac{\partial f_{\theta}(x)}{\partial \theta_i} $

Eine neue Funktion u wird definiert, um den zweiten Term zu unterscheiden.

$u = 1 + e^{-{\bf \theta}^{\mathrm{T}}{\bf x}} $

Wenn es definiert ist, ist es wie folgt.

\frac {\partial u}{\partial \theta_i} = \frac {\partial}{\partial \theta_i} exp(-(x_1\theta_1 + \cdot\cdot\cdot+x_N\theta_N)) = -x_i e^{-{\bf \theta}^{\mathrm{T}}{\bf x}}

Infolgedessen kann die Differenzierung von $ f $ wie folgt ausgedrückt werden. Zusammenfassend kann der Differenzwert für die Rückausbreitung von Fehlern wie folgt ausgedrückt werden.

$ \frac{\partial f_{\theta}(x)} {\partial u} \frac {\partial u}{\partial \theta_i} = f_{\theta}(1-f_{\theta})x_i $

\frac{\partial L}{\partial \theta_i} = \sum_{i=0}^{N} (y^{i} - f_{\theta}(x)) {\bf x}_i

Wenn Sie es etwas neuronaler machen. $f = \frac{1} {1 + \exp( - {\bf x} ) } $

$ \delta = {\bf y} - {\bf t} $

$\nabla_{\bf W} E = \frac{1}{N}\delta {\bf x}^{\mathrm{T}} $

$\nabla_{\bf b} E = \frac{1}{N}\delta \mathbb{1}_N $

${\bf W} \leftarrow {\bf W} - \epsilon \nabla_{\bf W} E $

${\bf b} \leftarrow {\bf b} - \epsilon \nabla_{\bf b} E $

Wählen Sie diesmal Letzteres aus

Daten bearbeiten

qiita.rb

with open('./train.feature.txt') as f:
  with open('./valid.feature.txt') as ff:
    with open('./test.feature.txt') as fff:
      i = 0
      name = ['train', 'valid', 'test']
      FF = [f,ff,fff]
      data_dict = dict() 
      for F in FF:
        text = F.readline()
        a = 'feature_' + name[i]
        array = []
        while text:
          tt = ([r for r in text.replace('\n', '').split('\t') if r != ''])
          #tt = [t[i] for i in range(len(t)) if i == 1 or i == 3 or i == 4 ]
          array.append(tt)
          text = F.readline()
        data_dict[a] = array
        i = i + 1
print(data_dict['feature_train'])
x, y = dict(), dict()
for n in name:
  a = 'feature_' + n
  data = data_dict[a]
  x[a] = [[r[0], r[1]] for r in data ]
  t[a] = [r[2] for r in data ]
print(x['feature_train'])
print(t['feature_train'])

Ich muss den Text in einen Vektor konvertieren, also den Code konvertieren

qiita.rb

#Zeichenvektorisierung
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np

#Schließlich wird nur das Teil extrahiert
def summary (data):
  text = list()
  for xx in data:
    text.append((xx[0]))
  return text

#Ist die Etikettenantwort ein Vektor?
def ans_to_vector (text):
  vec = list()
  for tt in text:
    if tt == 'b':
      vec.append(0)
    if tt == 'e':
      vec.append(1)
    if tt == 't':
      vec.append(2)
    if tt == 'm':
      vec.append(3)
  return np.eye(len(np.unique(vec)))[vec]

#Das Argument ist x[''feature']
def publisher_to_vector (text):
  vec = list()
  for tt in text:
    if tt[1] == 'Reuters':
      vec.append(0)
    if tt[1] == 'Huffington Post':
      vec.append(1)
    if tt[1] == 'Businessweek':
      vec.append(2)
    if tt[1] == 'Contactmusic.com':
      vec.append(3)
    if tt[1] == 'Daily Mail':
      vec.append(4)
  
  onehotvec = np.eye(len(np.unique(vec)))[vec]
  return np.array(onehotvec)

#TfidfVectorizer
def texttovec(textlist):
  vec = TfidfVectorizer().fit_transform(textlist)
  return vec

#Vektoraddition (nicht verwendet)
def vecplusvec (vec1, vec2):
  v = list()
  for v1, v2 in zip(vec1, vec2):
    print(v1[None,:].shape, v2[None,:].shape )
    v.append(v1 + v2[None, :])
    print('A')
  return v
#Ist es endlich ein Vektor?
text_train = summary(x['feature_train'])
text_valid = summary(x['feature_valid'])
text = text_train + (text_valid)
vec_text = TfidfVectorizer().fit_transform(text_train).toarray()
#Vektorsplit
vec_train, vec_valid = list(), list()
for i in range(vec_text.shape[0]):
  if i < len(text_train):
    vec_train.append(vec_text[i])
  if i < len(text_valid):
    vec_valid.append(vec_text[i])
#Übergeben Sie den Vektor an Numpy
vec_train = np.array(vec_train)
vec_valid= np.array(vec_valid)
#Antworten und Publisher-Vektorisierung
vec_train_ans = ans_to_vector((t['feature_train']))
vec_valid_ans = ans_to_vector((t['feature_valid']))
vec_train_publisher = publisher_to_vector(x['feature_train'])
vec_valid_publisher = publisher_to_vector(x['feature_valid'])

#Kombinieren Sie Eingabevektoren
vec_train = np.concatenate([vec_train, vec_train_publisher],axis = 1)
vec_valid = np.concatenate([vec_valid, vec_valid_publisher],1)

print("Eingabedimension",vec_train.shape)
print('Beschriftungsdimension (Antwortdimension)',vec_train_ans.shape)
print("Name des Herausgebers",vec_train_publisher.shape)

#Eingabedimension(10684, 12783)
#Beschriftungsdimension (Antwortdimension)(10684, 4)
#Name des Herausgebers(10684, 5)

Codierung zum Lernen

qiita.rb

import numpy as np
from sklearn.metrics import accuracy_score

#Verhindern Sie, dass der Inhalt des Protokolls 0 wird
def np_log(x):
    return np.log(np.clip(a=x, a_min=1e-10, a_max=1e+10))

def sigmoid(x):
#     return 1 / (1 + np.exp(- x))
    return np.tanh(x * 0.5) * 0.5 + 0.5 #Verwenden Sie numpy eingebaute Tanh(Überlauf von exp verhindern)

W, b = np.random.uniform(-0.08, 0.08, size = ( vec_train.shape[1],4)), np.zeros(shape = (4,)).astype('float32')
#Lernen
def train (x, t, eps = 1):
    global W , b
    batch_size = x.shape[0]
    y = sigmoid(np.matmul(x, W) + b) # shape: (batch_size,Anzahl der Ausgangsdimensionen) #matmaul:Innenprodukt
    #Backpropagation
    cost = (- t * np_log(y) - (1 - t) * np_log(1 - y)).mean()
    delta = y - t # shape: (batch_size,Anzahl der Ausgangsdimensionen) 

    #Parameteraktualisierung
    dW = np.matmul(x.T, delta) / batch_size # shape: (Anzahl der Eingangsdimensionen,Anzahl der Ausgangsdimensionen)
    db = np.matmul(np.ones(shape=(batch_size,)), delta) / batch_size # shape: (Anzahl der Ausgangsdimensionen,)
    W -= eps * dW
    b -= eps * db

    return cost
#Überprüfung
def valid(x, t):
    y = sigmoid(np.matmul(x, W) + b)
    cost = (- t * np_log(y) - (1 - t) * np_log(1 - y)).mean()
    return cost, y
#Implementierung
for epoch in range(3):
    for x, t in zip(vec_train, vec_train_ans):
        cost = train(x[None, :], t[None, :])
    cost, y_pred = valid(vec_valid, vec_valid_ans)
    print('EPOCH: {}, Valid Cost: {:.3f}, Valid Accuracy: {:.3f}'.format(
        epoch + 1,
        cost,
        accuracy_score(vec_valid_ans.argmax(axis=1), y_pred.argmax(axis=1))
    ))

qiita.rb

#EPOCH: 1, Valid Cost: 0.477, Valid Accuracy: 0.647
#EPOCH: 2, Valid Cost: 0.573, Valid Accuracy: 0.598
#EPOCH: 3, Valid Cost: 0.638, Valid Accuracy: 0.570

Da die Anzahl der Etiketten 5 beträgt, beträgt die minimale richtige Antwortrate 20%. Ist die richtige Antwortrate von 65% ein allgemein guter Wert? ?? (Ich habe die Vektorisierung des Textes nicht wirklich verstanden und es wurde ziemlich spärlich. Sie können sehen, dass Sie überlernen Ich habe gerade eine logistische Rückkehr in die Klasse eines bestimmten Deep-Learning-Lehrers in der Graduiertenschulklasse gemacht und diese nach der Bewerbung umgesetzt.

54. Messung der richtigen Antwortrate

Messen Sie die korrekte Antwortrate des in 52 erlernten logistischen Regressionsmodells anhand der Trainingsdaten und Bewertungsdaten.

qiita.rb

y = np.round(y_pred, 2)
j = 0
for i in range(y.shape[0]):  
  if (y_pred.argmax(axis = 1)[i] == vec_valid_ans.argmax( axis = 1)[i]):
    j = j +1
print('Die richtige Antwortrate ist', j/(y.shape[0]))  
print('Die richtige Antwortrate ist (Befehl)= ', accuracy_score(y_pred.argmax(axis = 1), vec_valid_ans.ar
gmax( axis = 1)))

55. Erstellen einer Verwirrungsmatrix

Erstellen Sie eine Verwirrungsmatrix des in 52 erlernten logistischen Regressionsmodells für die Trainingsdaten und Bewertungsdaten.

qiita.rb

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_pred.argmax(axis = 1), vec_valid_ans.argmax( axis = 1))
print(cm)

56. Messung von Präzision, Rückruf und F1-Punktzahl

Messen Sie die Präzision, den Rückruf und den F1-Score des in 52 anhand der Bewertungsdaten erlernten logistischen Regressionsmodells. Ermitteln Sie die Genauigkeit, den Rückruf und die F1-Bewertung für jede Kategorie und integrieren Sie die Leistung für jede Kategorie in den Mikro- und Makro-Durchschnitt.

Rezension

Rückrufrate: Prozentsatz der tatsächlich positiven Proben, die richtig geantwortet haben

recall = \frac{TP}{TP+FN}

Singularität: Der Prozentsatz der Anzahl der Daten, die Sie nicht unterscheiden möchten, die nicht tatsächlich diskriminiert wurden (wie viel war die richtige Antwort unter den Daten außer Katzen?) Konformitätsrate: Der Prozentsatz der Anzahl der diskriminierten Daten, der korrekt ist (der Prozentsatz der diskriminierten Bilder, der das tatsächliche Bild ist).

precision = \frac{TP}{TP+FP}

Negativer Vorhersagewert: Von der Anzahl der diskriminierten Daten, die keiner Diskriminierung unterliegen, ist der Prozentsatz der Bilder, die korrekt beantwortet werden (außer Katzen!), Tatsächlich andere Bilder als Katzen. Prozentsatz)

F1-Wert ・ ・ ・ Der F1-Wert (F1-Maß) ist ein harmonisierter Durchschnitt aus Präzision und Rückruf.

$F1 = \frac{2TP}{2TP + FP + FN} $

qiita.rb

from sklearn.metrics import classification_report
print(classification_report(vec_valid_ans.argmax( axis = 1), y_pred.argmax(axis = 1)))

qiita.rb

              precision    recall  f1-score   support

           0       0.63      0.77      0.69       588
           1       0.71      0.63      0.67       518
           2       0.13      0.12      0.13       145
           3       0.17      0.07      0.10        85

    accuracy                           0.60      1336
   macro avg       0.41      0.40      0.40      1336
weighted avg       0.58      0.60      0.58      1336

Referenz-URL

Antwort und Eindruck von 100 Sprachverarbeitungsklopfen - Teil 1 [Aktivieren Sie MeCab im Labor. ]] (https://qiita.com/pytry3g/items/897ae738b8fbd3ae7893) Deep Learning Klasse Maschinelles Lernen ~ Textfunktionen (CountVectorizer, TfidfVectorizer) ~ Python