100 langues de traitement frappent 2020 "pour Google Colaboratory"

Puisque la faculté a été reflétée de la Faculté des sciences de Gorigori et de l'école doctorale au laboratoire de traitement du langage, je suis un débutant dans le traitement de chaînes de caractères. Si vous avez des questions, veuillez les signaler. Vous pouvez l'utiliser en le copiant tel quel.

Comment installer MeCab sur Google Collaboration, comment écrire Matplotlib en japonais, etc. Mis à jour de temps en temps

Section 1 [Mouvement préparatoire]

1. Ordre inverse des chaînes Permalien

Récupère une chaîne dans laquelle les caractères de la chaîne "souligné" sont disposés à l'envers (de la fin au début)

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

Je l'ai essayé de deux manières. Python se débattait sobrement parce que je n'avais touché qu'à l'informatique numérique. Si vous avez du temps libre, vous pouvez continuer de plus en plus après avoir revu!

2. «Patatokukashi»

qiita.rb

#1 de la chaîne de caractères "Patatokukashi",3,5,Retirez le 7ème caractère et obtenez la chaîne de caractères concaténée.
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" Permalien

qiita.rb

#Récupérez la chaîne de caractères "Patatokukashi" en reliant alternativement les caractères "Pattocar" + "Taxi" depuis le début.

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

04. Symbole d'élément

qiita.rb

s = 'Hi He Lied Because Boron Could Not Oxidize Fluorine. New Nations Might Also Sign Peace Security Clause. Arthur King Can.'
#Est décomposé en mots, 1, 5, 6, 7, 8, 9, 15, 16,Le 19e mot est le premier caractère et les autres mots sont les deux premiers caractères et la position du mot dans la chaîne de caractères extraite.
#Créez un tableau associatif (type de dictionnaire ou type de carte) à (quel nombre de mots depuis le début).

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 Créez une fonction qui crée un n-gramme à partir d'une séquence donnée (chaîne, liste, etc.). Utilisez cette fonction pour obtenir le mot bi-gramme et la lettre bi-gramme à partir de la phrase "Je suis un PNL"

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. Réunion

Trouvez le jeu de bi-grammes de caractères contenu dans "paraparaparadise" et "paragraphe" comme X et Y, respectivement, et trouvez le jeu de somme, le jeu de produits et le jeu de différences de X et Y, respectivement. En outre, découvrez si le bi-gram'se'est inclus dans X et Y.

qiita.rb

s1 = "paraparaparadise"
s2 = "paragraph"

w1=n_gram_moji(s1,2)
w2=n_gram_moji(s2,2)
print(type(w1))
print('L'ensemble de somme est', w1 | w2)
print('L'ensemble de produits est', w1 & w2)
print('L'ensemble de différences est', w1 - w2)

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

07. Génération de déclaration par modèle Permalien

Implémentez une fonction qui prend les arguments x, y, z et renvoie la chaîne "y at x is z". De plus, x = 12, y = "température",

qiita.rb

z=22.Comme 4, vérifiez le résultat de l'exécution
def temple(x,y,z):
  print(x,'de temps',y,'Est',z)

temple(12,'Température',22.4)

08. Cryptographie

Implémentez le chiffrement de fonction qui convertit chaque caractère de la chaîne de caractères donnée selon les spécifications suivantes. Remplacer par (219 --character code) caractères si minuscules Afficher les autres caractères tels quels Utilisez cette fonction pour crypter / décrypter les messages en anglais.

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 Créez un programme qui réorganise aléatoirement l'ordre des autres caractères, en laissant le premier et le dernier caractère de chaque mot pour la chaîne de mots séparés par des espaces. Cependant, les mots d'une longueur de 4 ou moins ne sont pas réorganisés. Donnez une phrase en anglais appropriée (par exemple, "Je ne pouvais pas croire que je pouvais réellement comprendre ce que je lisais: le pouvoir phénoménal de l'esprit humain.") Et vérifiez le résultat de l'exécution.

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

La seule chose qui compte est de savoir comment insérer la MeCab dans le chapitre 3, alors allons-y d'abord.

Section 2 [Commande UNIX]

Je l'ai écrit moi-même, mais en référence à d'autres personnes

Réponse et impression de 100 problèmes de traitement de la langue - Partie 1

Section 3 [Expression régulière]

Il existe un fichier jawiki-country.json.gz qui exporte les articles Wikipédia au format suivant.

• Les informations sur un article par ligne sont stockées au format JSON

• Dans chaque ligne, le nom de l'article est stocké dans la clé "title" et le corps de l'article est stocké dans l'objet dictionnaire avec la clé "text", et cet objet est écrit au format JSON.

• Le fichier entier est gzippé

• Créez un programme qui effectue le traitement suivant.

20. Lecture des données JSON

Lisez le fichier JSON de l'article Wikipedia et affichez le texte de l'article sur "UK". Dans les problèmes 21-29, exécutez sur le texte de l'article extrait ici.

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'] == "Angleterre":
                break

print(country)

qiita.rb

puts 'code with syntax'

Les données ont disparu ...

Section 4 [analyse morphologique]

Utilisez MeCab pour analyser morphologiquement le texte (neko.txt) du roman de Natsume Soseki "Je suis un chat" et enregistrez le résultat dans un fichier appelé neko.txt.mecab. Utilisez ce fichier pour implémenter un programme qui répond aux questions suivantes.

Pour les problèmes 37, 38, 39, utilisez matplotlib ou 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

Vous pouvez maintenant installer MeCab. Est-ce que! Apt est un système UNIX? ! aptitude est Ubuntu ?? Je ne suis pas sûr de cela. J'ai fait référence à d'autres sites. Activez MeCab dans Colaboratory.

30. Lecture des résultats de l'analyse morphologique

Implémentez un programme qui lit les résultats de l'analyse morphologique (neko.txt.mecab). Cependant, chaque élément morphologique est stocké dans un type de mappage avec la surface, la forme de base (base), une partie du mot (pos) et une partie du mot sous-classification 1 (pos1) comme clés, et une phrase est exprimée sous la forme d'une liste d'éléments morphologiques (type de mappage). Faisons le. Pour le reste des problèmes du chapitre 4, utilisez le programme créé ici.

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

Les données de 30 à 36 ont disparu et elles ont vraiment flétri. C'est facile, alors SKIIIIP!

31. ** Vermalink **

Extrayez toutes les formes de surface du verbe.

32. Permalien, la forme originale du verbe

Extrayez toutes les formes originales du verbe.

33. Permalien "A's B"

Extraire la nomenclature dans laquelle deux nomenclatures sont reliées par "non".

34. Nomenclature Permalien

Extraire la concaténation de nomenclature (noms qui apparaissent consécutivement) avec la correspondance la plus longue Les données ont beaucoup disparu ... je le ferai si j'ai le temps

35. Fréquence d'occurrence des mots

Trouvez les mots qui apparaissent dans la phrase et leur fréquence d'apparition, et classez-les par ordre décroissant de fréquence d'apparition.

qiita.rb

tango = list()
for i in range(len(worddict['pos'])):
  t = worddict['pos'][i]
  if t[:2] == 'nom':
    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)

#[('de', 1611), ('Chose', 1207), ('もde', 981), ('Tu', 973), ('Maître', 932), ('Hmm', 704), ('Yo', 697), ('Homme', 602), ('un', 554), ('quoi', 539), ('je', 481), ('cette', 414),

36. Top 10 des mots les plus fréquents

Afficher 10 mots avec une fréquence d'apparition élevée et leur fréquence d'apparition dans un graphique (par exemple, un graphique à barres) Tout d'abord, commencez par acquérir des polices japonaises. Sinon, d'innombrables tofus apparaîtront lorsqu'ils seront représentés graphiquement.

qiita.rb

!apt-get -y  install fonts-ipafont-gothic
#Supprimez le cache.
!rm /root/.cache/matplotlib/fontlist-v310.json #Cache à effacer

Effacez ce -340v. Cependant, cela semble être différent pour chaque version, et c'était une valeur différente sur d'autres sites. Par conséquent, chaque personne doit confirmer.

qiita.rb

!ls  /root/.cache/matplotlib/
#Ce répertoire peut être obtenu à l'aide du code suivant.
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()

J'ai été très impressionné lorsque cela a été fait. Vous pouvez le faire en japonais. .. .. Si vous avez été au premier cycle ...

37. Top 10 des mots qui coïncident fréquemment avec "chat" Permalien

Affichez 10 mots qui cohabitent souvent avec "chats" (fréquence élevée de cooccurrence) et leur fréquence d'apparition dans un graphique (par exemple, un graphique à barres).

qiita.rb

cooc = dict()
coocdict = dict()
cooclist = list()
for i in range(len(worddict['surface'])):
  t = worddict['pos'][i]
  if (t[:2] != 'Particule' and t[:2] != 'symbole' and t[:3] != 'Verbe auxiliaire'):
    cooclist.append(worddict['surface'][i])
for t in set(cooclist) :
  coocdict[t] = 0
#print(cooclist)
for i in range(len(cooclist)):
  if cooclist[i] == 'Chat':
    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())

Code sale. Il existe d'autres moyens absolument bons. Même si j'étais dans un laboratoire de traitement du langage, je ne connaissais pas le mot cooccurrence, donc c'est devenu un goulot d'étranglement. Ce serait intéressant si je pouvais exprimer un peu ma sensibilité même avec word2vec ou de telles expressions distribuées.

39. Loi de Zipf

Tracez les deux graphiques logarithmiques avec la fréquence d'occurrence des mots sur l'axe horizontal et la fréquence d'occurrence sur l'axe vertical.

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)

Je ne pense pas avoir touché à cela dans le cours de "traitement du langage naturel" auquel j'ai assisté sans permission lorsque j'étais étudiant de premier cycle. Même si une certaine université prend l'initiative de le faire, le chiffre est le même que HP (lorsque le prototype est extrait)

Section 5 [Analyse des dépendances]

Tout d'abord, installez CaboCha.

qiita.rb

#Installez 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
#Créer le fichier de destination spécifié
filename_crfpp = 'crfpp.tar.gz'
!wget "https://drive.google.com/uc?export=download&id=0B4y35FiV1wh7QVR6VXJ5dWExSTQ" -O $filename_crfpp
#Extraire l'archive et déplacer vers le fichier spécifié
!tar zxvf $filename_crfpp
#Déplacé vers CRF et existe dans le répertoire courant.!ls ./Vérifiez à
%cd CRF++-0.58
#Exécutez le fichier de script appelé configure dans this. Il n'y a pas de commande avec ce nom
!./configure
#Il techniquera s'il est dans l'environnement en cours d'exécution avec configure. Si elle est désactivée, un makefile sera créé et exécuté avec le make ci-dessous sans aucune option.
!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

Commande à utiliser en Python

qiita.rb

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

Utilisez CaboCha pour effectuer une analyse de dépendance du texte (neko.txt) du roman de Natsume Soseki "Je suis un chat", et enregistrez le résultat dans un fichier appelé neko.txt.cabocha. Utilisez ce fichier pour implémenter un programme qui répond aux questions suivantes.

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. Lecture du résultat de l'analyse des dépendances (morphologie)

Implémentez la classe Morph qui représente la morphologie. Cette classe a une forme de surface (surface), une forme de base (base), un mot de partie (pos) et une sous-classification de mot de partie 1 (pos1) en tant que variables membres. De plus, lisez le résultat de l'analyse de CaboCha (neko.txt.cabocha), exprimez chaque phrase comme une liste d'objets Morph et affichez la chaîne d'éléments morphologiques de la troisième phrase.

41. Lecture du résultat de l'analyse des dépendances (phrase / dépendance) Permalien

En plus de 40, implémentez la classe de clause Chunk. Cette classe contient une liste d'éléments morph (objets Morph) (morphs), une liste de numéros d'index de clause associés (dst) et une liste de numéros d'index de clause d'origine (srcs) associés comme variables membres. De plus, lisez le résultat de l'analyse de CaboCha du texte d'entrée, exprimez une phrase sous forme d'une liste d'objets Chunk et affichez la chaîne de caractères et le contact de la phrase de la huitième phrase. Pour le reste des problèmes du chapitre 5, utilisez le programme créé ici.

40 et 41 ont tout fait en même temps. Parce qu'il a un héritage en morceaux et en morphologie.

qiita.rb

class Morph:
  def __init__(self, line):
    line = line.replace('\t',',').split(',')
    self.surface =  line[0]
    #Nya Nya n'a pas de forme de base, car elle ne peut pas être traitée
    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] == '*'):
          #Le morceau est terminé et stocké
          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)

Plus tard, je l'ai créé sous forme de liste pour une analyse facile. Le résultat de ceci est [Responsable, Responsable, [Chunk]] Représente. Cette partie [chunk] se présente sous la forme de [surface, base, pos, pos1] des mots qui composent le chunk. [Source responsable, destination responsable, [[surface, base, pos, pos1] [surface, base, pos, pos1]]] Par exemple, comme ça.

qiita.rb

[['1', '-1D', [['Je vous remercie', 'Je vous remercie', 'adjectif', 'Indépendance']]]]
[['0', '-1D', [['un', 'un', 'nom', 'nombre']]], ['0', '2D', [['\u3000', '\u3000', 'symbole', 'Vide']]], ['1', '2D', [['je', 'je', 'nom', '代nom'], ['Est', 'Est', 'Particule', '係Particule']]], ['2', '-1D', [['Chat', 'Chat', 'nom', 'un般'], ['alors', 'alors', 'Verbe auxiliaire', '*'], ['y a-t-il', 'y a-t-il', 'Verbe auxiliaire', '*']]]]
[['2', '-1D', [['Chat', 'Chat', 'nom', 'Général'], ['alors', 'alors', 'Verbe auxiliaire', '*'], ['y a-t-il', 'y a-t-il', 'Verbe auxiliaire', '*']]], ['0', '2D', [['Nom', 'Nom', 'nom', 'Général'], ['Est', 'Est', 'Particule', '係Particule']]], ['1', '2D', [['encore', 'encore', 'adverbe', 'Particule類接続']]], ['2', '-1D', [['Non', 'Non', 'adjectif', 'Indépendance']]]]
[['2', '-1D', [['Non', 'Non', 'adjectif', 'Indépendance']]], ['0', '1D', [['\u3000', '\u3000', 'symbole', 'Vide'], ['Où', 'Où', 'nom', '代nom'], ['alors', 'alors', 'Particule', '格Particule']]], ['1', '4D', [['Née', 'Née', 'verbe', 'Indépendance'], ['Ta', 'Ta', '助verbe', '*'], ['Ou', 'Ou', 'Particule', '副Particule／並立Particule／終Particule']]], ['2', '4D', [['Tonto', 'Tonto', 'adverbe', 'Général']]], ['3', '4D', [['S'inscrire', 'S'inscrire', 'nom', 'Changer de connexion'], ['Mais', 'Mais', 'Particule', '格Particule']]], ['4', '-1D', [['つOu', 'つOu', 'verbe', 'Indépendance'], ['Nu', 'Nu', '助verbe', '*']]]]
[['4', '-1D', [['Tsuka', 'Tsuka', 'verbe', 'Indépendance'], ['Nu', 'Nu', '助verbe', '*']]], ['0', '1D', [['quoi', 'quoi', 'nom', '代nom'], ['Mais', 'Mais', 'Particule', '副Particule']]], ['1', '3D', [['faible', 'faible', 'adjectif', 'Indépendance']]], ['2', '3D', [['Humide', 'Humide', 'adverbe', 'Général'], ['Shi', 'Shi', 'verbe', 'Indépendance'], ['Ta', 'Ta', '助verbe', '*']]], ['3', '5D', [['Endroit', 'Endroit', 'nom', '非Indépendance'], ['alors', 'alors', 'Particule', '格Particule']]], ['4', '5D', [['Miaou miaou', 'Miaou miaou', 'nom', 'Général']]], ['5', '7D', [['Pleurs', 'Pleurs', 'verbe', 'Indépendance'], ['main', 'main', 'Particule', '接続Particule']]], ['6', '7D', [['いTa事', 'いTa事', 'nom', 'Général'], ['Seulement', 'Seulement', 'Particule', '副Particule'], ['Est', 'Est', 'Particule', '係Particule']]], ['7', '-1D', [['Mémoire', 'Mémoire', 'nom', 'Changer de connexion'], ['Shi', 'Shi', 'verbe', 'Indépendance'], ['main', 'main', 'Particule', '接続Particule'], ['Est', 'Est', 'verbe', '非Indépendance']]]]
[['7', '-1D', [['Mémoire', 'Mémoire', 'nom', 'Changer de connexion'], ['Shi', 'Shi', 'verbe', 'Indépendance'], ['main', 'main', 'Particule', '接続Particule'], ['Est', 'Est', 'verbe', '非Indépendance']]], ['0', '5D', [['je', 'je', 'nom', '代nom'], ['Est', 'Est', 'Particule', '係Particule']]], ['1', '2D', [['ici', 'ici', 'nom', '代nom'], ['alors', 'alors', 'Particule', '格Particule']]], ['2', '3D', [['début', 'début', 'verbe', 'Indépendance'], ['main', 'main', 'Particule', '接続Particule']]], ['3', '4D', [['Humain', 'Humain', 'nom', 'Général'], ['Cette', 'Cette', 'Particule', '格Particule']]], ['4', '5D', [['chose', 'chose', 'nom', '非Indépendance'], ['À', 'À', 'Particule', '格Particule']]], ['5', '-1D', [['Vous voyez', 'Vous voyez', 'verbe', 'Indépendance'], ['Ta', 'Ta', '助verbe', '*']]]]
[['5', '-1D', [['Vous voyez', 'Vous voyez', 'verbe', 'Indépendance'], ['Ta', 'Ta', '助verbe', '*']]], ['0', '8D', [['De plus,', 'De plus,', 'conjonction', '*']]], ['1', '2D', [['après', 'après', 'nom', 'Général'], ['alors', 'alors', 'Particule', '格Particule']]], ['2', '8D', [['Ecoutez', 'Ecoutez', 'verbe', 'Indépendance'], ['Quand', 'Quand', 'Particule', '接続Particule']]], ['3', '8D', [['Il', 'Il', 'nom', '代nom'], ['Est', 'Est', 'Particule', '係Particule']]], ['4', '5D', [['Étudiant', 'Étudiant', 'nom', 'Général'], ['Quandいう', 'Quandいう', 'Particule', '格Particule']]], ['5', '8D', [['Humain', 'Humain', 'nom', 'Général'], ['Pendant ~', 'Pendant ~', 'nom', 'suffixe'], ['alors', 'alors', 'Particule', '格Particule']]], ['6', '7D', [['Ichiban', 'Ichiban', 'nom', 'Avocat possible']]], ['7', '8D', [['Mal', 'Mal', 'nom', '形容verbe語幹'], ['Nana', 'Nana', '助verbe', '*']]], ['8', '-1D', [['Course', 'Course', 'nom', 'Général'], ['alors', 'alors', '助verbe', '*'], ['Ah', 'Ah', '助verbe', '*'], ['Ta', 'Ta', '助verbe', '*'], ['alors', 'alors', 'nom', 'Spécial'], ['Est', 'Est', '助verbe', '*']]]]

Cela m'a pris plusieurs heures pour clarifier cela. Eh bien, je ne connaissais pas la police de classe, donc je suis content de l'avoir fait. Je ne vois toujours pas vraiment la signification de la classe. N'est-il généralement pas possible de créer une fonction à l'intérieur d'une fonction en Python?

42. Affichage de la phrase de l'intéressé et de l'intéressé

Extrayez tout le texte de la clause d'origine et de la clause associée au format délimité par des tabulations. Cependant, n'émettez pas de symboles tels que les signes de ponctuation.

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] != 'symbole'):
        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
je suis un chat
¥n
Sans nom
Pas encore
¥n
Où êtes-vous né
Né ou pas
Je ne comprends pas
Je n'ai aucune idée
¥n
Tout ce qui est sombre
Dans un endroit sombre
Dans un endroit humide
Pleurer sur place
Miaou miaou pleurer
Je pleure et me souviens
Je me souviens seulement de ce que j'étais
¥n

43. Extraire les clauses contenant la nomenclature relative aux clauses contenant des verbes

Lorsque des clauses contenant une nomenclature se rapportent à des clauses contenant des verbes, extrayez-les dans un format délimité par des tabulations. Cependant, n'émettez pas de symboles tels que les signes de ponctuation.

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] != 'symbole'):
        surface += se [0]
      if se [2] == 'nom':
        hanteiki_meisi = 1 #L'état où la nomenclature existe dans la clause
      if se [2] == 'verbe':
        hanteiki_dousi = 1 #L'état dans lequel le verbe existe dans la clause

    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. Visualisation des arbres dépendants

Visualisez l'arbre de dépendance d'une phrase donnée sous forme de graphe orienté. Pour la visualisation, il est conseillé de convertir l'arborescence de dépendances dans le langage DOT et d'utiliser Graphviz. De plus, pour visualiser des graphiques dirigés directement à partir de Python, utilisez pydot.

qiita.rb

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

#chunk_la phrase est(Dépendant, destination)Taple
def graph_maker(chunk_sentence):
  graph = pydot.graph_from_edges(chunk_sentence, directed=True)
  graph.write_png("./result.png ")
  #Chargement des images
  im = Image.open("./result.png ")
  #Convertir l'image en tableau
  im_list = np.asarray(im)
  #coller
  plt.imshow(im_list)
  #afficher
  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] != 'symbole'):
        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. Extraction de modèles de cas verbaux

Je voudrais considérer la phrase utilisée cette fois comme un corpus et enquêter sur les cas possibles de prédicats japonais. Considérez le verbe comme un prédicat et le verbe auxiliaire de la phrase liée au verbe comme une casse, et affichez le prédicat et la casse dans un format délimité par des tabulations. Cependant, assurez-vous que la sortie répond aux spécifications suivantes.

• Dans une clause contenant un verbe, la forme de base du verbe le plus à gauche est utilisée comme prédicat.
• La casse est le mot auxiliaire lié au prédicat
• S'il y a plusieurs mots auxiliaires (phrases) liés au prédicat, arrangez tous les mots auxiliaires dans l'ordre du dictionnaire, séparés par des espaces.

Prenons l'exemple de la phrase (8e phrase de neko.txt.cabocha) que "j'ai vu un être humain pour la première fois ici". Cette phrase contient deux verbes, «commencer» et «voir», et la phrase liée à «commencer» est analysée comme «ici», et la phrase liée à «voir» est analysée comme «je suis» et «chose». Devrait produire la sortie suivante.

À voir

Enregistrez la sortie de ce programme dans un fichier et vérifiez les éléments suivants à l'aide des commandes UNIX.

Une combinaison de prédicats et de modèles de cas qui apparaissent fréquemment dans le corpus Modèles de casse des verbes "faire", "voir" et "donner" (organiser par ordre de fréquence d'apparition dans le corpus)

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] != 'symbole'):
 #       word += se [0]
        if se [2] == 'Particule':
          hanteiki_meisi = 1 #L'état où la nomenclature existe dans la clause
          josi = se[0]
        if se [2] == 'verbe':
          hanteiki_dousi = 1 #L'état dans lequel le verbe existe dans la clause
          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. Exploration de la syntaxe des verbes fonctionnels

Je voudrais prêter attention uniquement au cas où le verbe wo case contient un nom de connexion sa-hen. Modifiez 46 programmes pour répondre aux spécifications suivantes.

• Uniquement lorsque la phrase consistant en "Sahen connectant nom + (auxiliaire)" est liée au verbe
• Le prédicat est "nom de connexion Sahen + est la forme de base du + verbe", et quand il y a plusieurs verbes dans une phrase, le verbe le plus à gauche est utilisé.
• S'il y a plusieurs mots auxiliaires (phrases) liés au prédicat, arrangez tous les mots auxiliaires dans l'ordre du dictionnaire, séparés par des espaces.
• S'il y a plusieurs clauses liées au prédicat, arrangez tous les termes séparés par des espaces (alignez-vous sur l'ordre des mots auxiliaires).
• Par exemple, la sortie suivante doit être obtenue à partir de la phrase "Le maître répondra à la lettre, même si elle vient à un autre endroit."

Quand je réponds à la lettre, mon mari

Enregistrez la sortie de ce programme dans un fichier et vérifiez les éléments suivants à l'aide des commandes UNIX.

• Prédicats qui apparaissent fréquemment dans le corpus (nomenclature de connexion sahénienne + + verbe)
• Prédicats et modèles de verbes qui apparaissent fréquemment dans le corpus

qiita.rb

puts 'code with syntax'

48. Extraction des chemins de la nomenclature aux racines

Pour une clause contenant toute la nomenclature de la phrase, extrayez le chemin de cette clause jusqu'à la racine de l'arborescence de syntaxe. Cependant, le chemin sur l'arbre de syntaxe doit satisfaire aux spécifications suivantes.

Chaque clause est représentée par une séquence morphologique (superficielle) De la clause de début à la clause de fin du chemin, concaténez les expressions de chaque clause avec "->" A partir de la phrase "J'ai vu un être humain pour la première fois ici" (8ème phrase de neko.txt.cabocha), la sortie suivante devrait être obtenue.

je suis->vu
ici->Commencer avec->Humain->Des choses->vu
Humain->Des choses->vu
Des choses->vu

qiita.rb

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

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

# setu = (Numéro de dépendance, numéro de contact, expression)
  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)
La première ligne
je suis-->Être un chat
2e ligne
Nom est-->Non
encore-->Non
3e ligne
où-->Est né-->Ne pas utiliser
Est né-->Ne pas utiliser
Tonto-->Ne pas utiliser
J'ai un indice-->Ne pas utiliser

49. Extraction de chemins de dépendance entre nomenclature

Extrayez le chemin de dépendance le plus court qui relie toutes les paires de nomenclatures de la phrase. Cependant, lorsque les numéros de clause de la paire de nomenclatures sont i et j (i <j), le chemin de dépendance doit satisfaire aux spécifications suivantes.

• Similaire au problème 48, le chemin exprime la représentation de chaque clause de la clause de début à la clause de fin (chaîne d'élément morphologique de surface) en les concaténant avec "->".
• Remplacer la nomenclature contenue dans les clauses i et j par X et Y, respectivement.

De plus, la forme du chemin de dépendance peut être considérée des deux manières suivantes.

• Si la clause j existe sur le chemin de la clause i à la racine de l'arbre de syntaxe: Afficher le chemin de la clause i à la clause j
• Autre que ce qui précède, lorsque la clause i et la clause j se croisent en une clause commune k sur le chemin de la clause j à la racine de l'arbre de syntaxe: le chemin immédiatement avant la clause i vers la clause k et le chemin immédiatement avant la clause j vers la clause k, clause Affichez le contenu de k en les connectant avec "|"

Par exemple, la sortie suivante doit être obtenue à partir de la phrase "J'ai vu un être humain pour la première fois ici" (8ème phrase de neko.txt.cabocha).

X est|En Y->Commencer avec->Humain->Des choses|vu
X est|Appelé Y->Des choses|vu
X est|Oui|vu
En X->Commencer avec-> Y
En X->Commencer avec->Humain-> Y
Appelé X-> Y

Section 6 [Apprentissage automatique]

Dans ce chapitre, à l'aide de l'ensemble de données d'agrégateur d'actualités publié par Fabio Gasparetti, des tâches pour classer les en-têtes d'articles d'actualité dans les catégories «entreprise», «science et technologie», «divertissement» et «santé» (catégorie)

50. Obtention et mise en forme des données

Téléchargez News Aggregator Data Set et suivez la procédure ci-dessous pour former les données d'entraînement (train.txt) et les données de vérification (valid.txt). ， Créez des données d'évaluation (test.txt).

1. Décompressez le fichier zip téléchargé et lisez l'explication de readme.txt.
2. N'extrayez que les cas (articles) dont les sources d'information (éditeurs) sont «Reuters», «Huffington Post», «Businessweek», «Contactmusic.com» et «Daily Mail».
3. Triez au hasard les cas extraits.
4. Divisez 80% des observations extraites en données d'apprentissage et les 10% restants en données de vérification et en données d'évaluation, et enregistrez-les sous les noms de fichier train.txt, valid.txt et test.txt, respectivement. Écrivez un cas par ligne dans le fichier et utilisez le format délimité par des tabulations du nom de la catégorie et de l'en-tête de l'article (ce fichier sera réutilisé plus tard dans le problème 70). Après avoir créé les données d'entraînement et les données d'évaluation, vérifiez le nombre de cas dans chaque catégorie.

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
#Données à mettre en réseau
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()
#Sélection des données
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)
#Randomiser et diviser les données
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)
#Description des données
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. Extraction d'entités

Extrayez les fonctionnalités des données d'entraînement, des données de vérification et des données d'évaluation, puis enregistrez-les sous les noms de fichier train.feature.txt, valid.feature.txt et test.feature.txt, respectivement. N'hésitez pas à concevoir les fonctionnalités susceptibles d'être utiles pour la catégorisation. La ligne de base minimale serait un titre d'article converti en une chaîne de mots.

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('Les chiffres correspondent → Le travail ci-dessus a été effectué normalement')

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('[Partie d'un fichier valide]')
  print(t[:100])

52. Apprentissage

Apprenez le modèle de régression logistique à l'aide des données d'entraînement construites en 51. Revue de la régression logistique => Problème de classification, pas de régression

Revue de la régression logistique => Problème de classification, pas de régression

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

Réduit aux problèmes d'optimisation cette fois

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

Et définissez la fonction softmax

==>

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

ici,

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

Quand le premier terme est calculé

$\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} $

Une nouvelle fonction u est définie pour différencier le deuxième terme.

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

S'il est défini, ce sera comme suit.

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

En conséquence, la différenciation de $ f $ peut être exprimée comme suit. En résumé, la valeur différentielle pour la rétropropagation de l'erreur peut être exprimée comme suit.

$ \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

Si vous le rendez un peu plus neuronal. $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 $

Cette fois, sélectionnez ce dernier

Modifier les données

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'])

Je dois convertir le texte en vecteur, donc le code à convertir

qiita.rb

#Vectorisation des caractères
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np

#Enfin seule la pièce est extraite
def summary (data):
  text = list()
  for xx in data:
    text.append((xx[0]))
  return text

#La réponse à l'étiquette est-elle un vecteur?
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]

#L'argument est 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

#Ajout de vecteur (non utilisé)
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
#Est-ce finalement un vecteur?
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()
#Division de vecteur
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])
#Passez le vecteur à Numpy
vec_train = np.array(vec_train)
vec_valid= np.array(vec_valid)
#Réponses et vectorisation des éditeurs
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'])

#Combiner les vecteurs d'entrée
vec_train = np.concatenate([vec_train, vec_train_publisher],axis = 1)
vec_valid = np.concatenate([vec_valid, vec_valid_publisher],1)

print("Dimension d'entrée",vec_train.shape)
print('Dimension d'étiquette (réponse)',vec_train_ans.shape)
print("Vecteur de nom d'éditeur",vec_train_publisher.shape)

#Dimension d'entrée(10684, 12783)
#Dimension d'étiquette (réponse)(10684, 4)
#Vecteur de nom d'éditeur(10684, 5)

Coder pour apprendre

qiita.rb

import numpy as np
from sklearn.metrics import accuracy_score

#Empêcher le contenu du journal de devenir 0
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 #Utilisez le tanh intégré numpy(Empêcher le débordement d'exp)

W, b = np.random.uniform(-0.08, 0.08, size = ( vec_train.shape[1],4)), np.zeros(shape = (4,)).astype('float32')
#Apprentissage
def train (x, t, eps = 1):
    global W , b
    batch_size = x.shape[0]
    y = sigmoid(np.matmul(x, W) + b) # shape: (batch_size,Nombre de dimensions de sortie) #matmaul:produit intérieur
    #Rétropropagation
    cost = (- t * np_log(y) - (1 - t) * np_log(1 - y)).mean()
    delta = y - t # shape: (batch_size,Nombre de dimensions de sortie) 

    #Mise à jour des paramètres
    dW = np.matmul(x.T, delta) / batch_size # shape: (Nombre de dimensions d'entrée,Nombre de dimensions de sortie)
    db = np.matmul(np.ones(shape=(batch_size,)), delta) / batch_size # shape: (Nombre de dimensions de sortie,)
    W -= eps * dW
    b -= eps * db

    return cost
#Vérification
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
#la mise en oeuvre
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

Puisque le nombre d'étiquettes est de 5, le taux de réponse correcte minimum est de 20%. Le taux de réponse correct de 65% est-il généralement une bonne valeur? ?? (Je n'ai pas vraiment compris la vectorisation du texte, et c'est devenu assez rare. Vous pouvez voir que vous surapprenez Je viens de faire un retour logistique dans la classe d'un certain professeur de deep learning dans la classe des études supérieures, et je l'ai implémenté après application.

54. Mesure du taux de réponse correcte

Mesurer le taux de réponse correct du modèle de régression logistique appris en 52 sur les données d'apprentissage et les données d'évaluation.

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('Le taux de réponse correct est', j/(y.shape[0]))  
print('Le taux de réponse correct est (commande)= ', accuracy_score(y_pred.argmax(axis = 1), vec_valid_ans.ar
gmax( axis = 1)))

55. Création d'une matrice de confusion

Créer une matrice de confusion du modèle de régression logistique appris en 52 sur les données d'entraînement et les données d'évaluation.

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. Mesure de la précision, du rappel et du score F1

Mesurer la précision, le rappel et le score F1 du modèle de régression logistique appris en 52 sur les données d'évaluation. Trouvez la précision, le rappel et le score F1 pour chaque catégorie, et intégrez les performances de chaque catégorie avec une micro-moyenne et une macro-moyenne.

La revue

Taux de rappel: pourcentage d'échantillons réellement positifs qui ont répondu correctement

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

Singularité: pourcentage du nombre de données que vous ne souhaitez pas discriminer, mais pas réellement discriminées Taux de conformité: Le pourcentage du nombre de données discriminées qui est correct (le pourcentage des images discriminées qui est l'image réelle)

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

Valeur prédictive négative: Du nombre de données discriminées qui ne font pas l'objet de discrimination, le pourcentage d'images qui reçoivent une réponse correcte (autres que des chats!) Sont en réalité des images autres que des chats. Pourcentage)

Valeur F1 ・ ・ ・ La valeur F1 (mesure F1) est une moyenne harmonisée de précision et de rappel.

$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

URL de référence

Réponse et impression de 100 problèmes de traitement de la langue - Partie 1 [Activez MeCab dans Colaboratory. ] (https://qiita.com/pytry3g/items/897ae738b8fbd3ae7893) Cours d'apprentissage profond Apprentissage automatique ~ Fonctionnalités de texte (CountVectorizer, TfidfVectorizer) ~ Python