[PYTHON] [Traitement du langage 100 coups 2020] Chapitre 5: Analyse des dépendances
introduction
Version 2020 de 100 coups de traitement du langage, qui est célèbre comme une collection de problèmes de traitement du langage naturel, a été publié. Cet article résume les résultats de la résolution Chapitre 5: Analyse des dépendances des chapitres 1 à 10 suivants. Je vais.
- Chapitre 1: Mouvement préparatoire
- Chapitre 2: Commandes UNIX
- Chapitre 3: Expressions régulières
- Chapitre 4: Analyse morphologique --Chapitre 5: Analyse des dépendances
- Chapitre 6: Apprentissage automatique
- Chapitre 7: Vecteur de mot --Chapitre 8: Réseau neuronal
- Chapitre 9: RNN, CNN --Chapitre 10: Traduction automatique
Préparation préalable
Nous utilisons Google Colaboratory pour obtenir des réponses. Pour plus d'informations sur la configuration et l'utilisation de Google Colaboratory, consultez cet article. Le cahier contenant les résultats d'exécution des réponses suivantes est disponible sur github.
Chapitre 5: Analyse des dépendances
Utilisez CaboCha pour effectuer une analyse de dépendance sur le 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.
Tout d'abord, téléchargez les données spécifiées. Si vous exécutez la commande suivante sur la cellule de Google Colaboratory, le fichier cible sera téléchargé dans le répertoire courant.
!wget https://nlp100.github.io/data/neko.txt
Ensuite, installez CaboCha et MeCab et CRF ++ requis pour exécuter CaboCha.
#Installez MeCab
!apt install mecab libmecab-dev mecab-ipadic-utf8
# CRF++Téléchargez / décompressez / installez le fichier source de
FILE_ID = "0B4y35FiV1wh7QVR6VXJ5dWExSTQ"
FILE_NAME = "crfpp.tar.gz"
!wget 'https://docs.google.com/uc?export=download&id=$FILE_ID' -O $FILE_NAME
!tar xvf crfpp.tar.gz
%cd CRF++-0.58
!./configure && make && make install && ldconfig
%cd ..
#Télécharger / décompresser / installer les fichiers source CaboCha
FILE_ID = "0B4y35FiV1wh7SDd1Q1dUQkZQaUU"
FILE_NAME = "cabocha-0.69.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-0.69.tar.bz2
%cd cabocha-0.69
!./configure -with-charset=utf-8 && make && make check && make install && ldconfig
%cd ..
Une fois l'installation terminée, nous effectuerons immédiatement l'analyse des dépendances.
En exécutant la commande suivante, le résultat de l'analyse des dépendances de neko.txt sera affiché sous la forme `` `` neko.txt.cabocba.
!cabocha -f1 -o neko.txt.cabocha neko.txt
Vérifiez le résultat de la sortie.
#Vérifiez le nombre de lignes
!wc -l ./neko.txt.cabocha
production
297283 ./neko.txt.cabocha
#Vérifiez les 15 premières lignes
!head -15 ./neko.txt.cabocha
production
* 0 -1D 0/0 0.000000
Un nom,nombre,*,*,*,*,un,Ichi,Ichi
EOS
EOS
* 0 2D 0/0 -0.764522
symbole,Vide,*,*,*,*, , ,
* 1 2D 0/1 -0.764522
Mon nom,Synonyme,Général,*,*,*,je,Wagahai,Wagahai
Est un assistant,Assistance,*,*,*,*,Est,C,sensationnel
* 2 -1D 0/2 0.000000
Chat substantif,Général,*,*,*,*,Chat,chat,chat
Avec verbe auxiliaire,*,*,*,Spécial,Type continu,Est,De,De
Un verbe d'aide,*,*,*,Cinq étapes, La ligne Al,Forme basique,y a-t-il,Al,Al
.. symbole,Phrase,*,*,*,*,。,。,。
EOS
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.
class Morph:
def __init__(self, morph):
surface, attr = morph.split('\t')
attr = attr.split(',')
self.surface = surface
self.base = attr[6]
self.pos = attr[0]
self.pos1 = attr[1]
filename = './neko.txt.cabocha'
sentences = []
morphs = []
with open(filename, mode='r') as f:
for line in f:
if line[0] == '*': #Lignes représentant les relations de dépendance: Ignorer
continue
elif line != 'EOS\n': #Autre que la fin de la phrase: appliquer Morph et ajouter à la liste de morphologie
morphs.append(Morph(line))
else: #Fin de phrase: Ajouter une liste d'éléments morphologiques à la liste de phrases
sentences.append(morphs)
morphs = []
#Vérification
for m in sentences[2]:
print(vars(m))
production
{'surface': '\u3000', 'base': '\u3000', 'pos': 'symbole', 'pos1': 'Vide'}
{'surface': 'je', 'base': 'je', 'pos': 'nom', 'pos1': '代nom'}
{'surface': 'Est', 'base': 'Est', 'pos': 'Particule', 'pos1': '係Particule'}
{'surface': 'Chat', 'base': 'Chat', 'pos': 'nom', 'pos1': 'Général'}
{'surface': 'alors', 'base': 'Est', 'pos': 'Verbe auxiliaire', 'pos1': '*'}
{'surface': 'y a-t-il', 'base': 'y a-t-il', 'pos': 'Verbe auxiliaire', 'pos1': '*'}
{'surface': '。', 'base': '。', 'pos': 'symbole', 'pos1': 'Phrase'}
41. Lecture du résultat de l'analyse des dépendances (expression / dépendance)
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.
Une phrase est représentée par une liste d'objets phrase, un objet phrase a une liste d'objets chunk en tant qu'éléments et un objet clause a une liste d'objets morph en tant qu'éléments. En plus de la classe Chunk``` de, Phrase est implémentée. Notez que la création d'une liste de numéros d'index de clause d'origine associés (`` `` srcs), qui est un élément de l'objet Chunk```, nécessite toutes les informations de clause d'une phrase, donc `` Phrase``` Créé lorsque l'objet est initialisé.
class Chunk():
def __init__(self, morphs, dst):
self.morphs = morphs
self.dst = dst
self.srcs = []
class Sentence():
def __init__(self, chunks):
self.chunks = chunks
for i, chunk in enumerate(self.chunks):
if chunk.dst != -1:
self.chunks[chunk.dst].srcs.append(i)
filename = './neko.txt.cabocha'
sentences = []
chunks = []
morphs = []
with open(filename, mode='r') as f:
for line in f:
if line[0] == '*': #Lignes représentant les relations de dépendance: appliquez Chunk aux informations de la phrase précédente et ajoutez-la à la liste de phrases+Obtenez le contact de la phrase immédiatement après
if len(morphs) > 0:
chunks.append(Chunk(morphs, dst))
morphs = []
dst = int(line.split(' ')[2].rstrip('D'))
elif line != 'EOS\n': #Autre que la fin de la phrase: appliquer Morph et ajouter à la liste de morphologie
morphs.append(Morph(line))
else: #Fin de phrase: Le bloc est appliqué aux informations de la phrase précédente et ajouté à la liste de phrases.+Appliquer la phrase à la liste des clauses et l'ajouter à la liste des clauses
chunks.append(Chunk(morphs, dst))
sentences.append(Sentence(chunks))
morphs = []
chunks = []
dst = None
#Vérification
for chunk in sentences[7].chunks:
print([morph.surface for morph in chunk.morphs], chunk.dst, chunk.srcs)
production
['je', 'Est'] 5 []
['ici', 'alors'] 2 []
['début', 'main'] 3 [1]
['Humain', 'Cette'] 4 [2]
['chose', 'À'] 5 [3]
['Vous voyez', 'Ta', '。'] -1 [0, 4]
- Comme vous l'avez souligné dans le commentaire, le résultat de l'analyse de dépendance de cette phrase de CaboCha ne semble pas correct. Dans cet article, nous l'utilisons tel quel selon les instructions de l'énoncé du problème, mais soyez prudent lorsque vous publiez les résultats.
42. Affichage de la phrase de l'intéressé et de l'intéressé
Extrayez tout le texte de la clause originale et de la clause liée au format délimité par des tabulations. Cependant, n'émettez pas de symboles tels que les signes de ponctuation.
Après cela, sauf indication contraire, la sortie est confirmée par la 8ème phrase comme en 41.
sentence = sentences[7]
for chunk in sentence.chunks:
if int(chunk.dst) != -1:
modifier = ''.join([morph.surface if morph.pos != 'symbole' else '' for morph in chunk.morphs])
modifiee = ''.join([morph.surface if morph.pos != 'symbole' else '' for morph in sentence.chunks[int(chunk.dst)].morphs])
print(modifier, modifiee, sep='\t')
production
j'ai vu
Pour la première fois ici
Pour la première fois appelé humain
Êtres humains
j'ai vu quelque chose
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 au format délimité par des tabulations. Cependant, n'émettez pas de symboles tels que les signes de ponctuation.
sentence = sentences[7]
for chunk in sentence.chunks:
if int(chunk.dst) != -1:
modifier = ''.join([morph.surface if morph.pos != 'symbole' else '' for morph in chunk.morphs])
modifier_pos = [morph.pos for morph in chunk.morphs]
modifiee = ''.join([morph.surface if morph.pos != 'symbole' else '' for morph in sentence.chunks[int(chunk.dst)].morphs])
modifiee_pos = [morph.pos for morph in sentence.chunks[int(chunk.dst)].morphs]
if 'nom' in modifier_pos and 'verbe' in modifiee_pos:
print(modifier, modifiee, sep='\t')
production
j'ai vu
Pour la première fois ici
j'ai vu quelque chose
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.
Un graphe est créé en créant une paire de clauses de la source et de la destination et en le passant au graph_from_edges``` de pydot.
De plus, comme il n'est pas possible de distinguer le moment où la même phrase de chaîne de caractères apparaît plusieurs fois dans une phrase avec la couche de surface telle quelle, elle est affichée avec un identifiant à la fin.
#Installation de la police d'affichage japonaise
!apt install fonts-ipafont-gothic
import pydot
from IPython.display import Image,display_png
from graphviz import Digraph
sentence = sentences[7]
edges = []
for id, chunk in enumerate(sentence.chunks):
if int(chunk.dst) != -1:
modifier = ''.join([morph.surface if morph.pos != 'symbole' else '' for morph in chunk.morphs] + ['(' + str(id) + ')'])
modifiee = ''.join([morph.surface if morph.pos != 'symbole' else '' for morph in sentence.chunks[int(chunk.dst)].morphs] + ['(' + str(chunk.dst) + ')'])
edges.append([modifier, modifiee])
n = pydot.Node('node')
n.fontname = 'IPAGothic'
g = pydot.graph_from_edges(edges, directed=True)
g.add_node(n)
g.write_png('./ans44.png')
display_png(Image('./ans44.png'))
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 phrase contenant un verbe, utilisez la forme de base du verbe le plus à gauche 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.
Enregistrez la sortie de ce programme dans un fichier et vérifiez les éléments suivants à l'aide des commandes UNIX.
--Combinaison de prédicats et de modèles de cas qui apparaissent fréquemment dans le corpus ―― Les modèles de casse des verbes «faire», «voir» et «donner» (organiser par ordre de fréquence d'apparition dans le corpus)
with open('./ans45.txt', 'w') as f:
for sentence in sentences:
for chunk in sentence.chunks:
for morph in chunk.morphs:
if morph.pos == 'verbe': # chunkの左から順番にverbeを探す
cases = []
for src in chunk.srcs: #Rechercher un verbe auxiliaire à partir du bloc d'origine du verbe trouvé
cases = cases + [morph.surface for morph in sentence.chunks[src].morphs if morph.pos == 'Particule']
if len(cases) > 0: #Si un mot auxiliaire est trouvé, il est trié dans l'ordre du dictionnaire après la déduplication et la sortie.
cases = sorted(list(set(cases)))
line = '{}\t{}'.format(morph.base, ' '.join(cases))
print(line, file=f)
break
#Vérification
!cat ./ans45.txt | sort | uniq -c | sort -nr | head -n 10
production
2414
1395 Tsukuka
676
608
330 saisir
319 voir
270 je pense
260
238 Par conséquent
237
!cat ./ans45.txt | grep 'Faire' | sort | uniq -c | sort -nr | head -n 5
production
1151
751
308
130
109
!cat ./ans45.txt | grep 'à voir' | sort | uniq -c | sort -nr | head -n 5
production
344 Voir
107 Voir
35 à voir
27 Voir
22 de voir
!cat ./ans45.txt | grep 'donner' | sort | uniq -c | sort -nr | head -n 5
production
5 donner
3 pour donner
3 pour donner
2 Il suffit de donner
1 donner seulement à
46. Extraction d'informations sur le cadre de la casse verbale
Modifiez le programme> 45 et affichez le terme (la clause elle-même liée au prédicat) au format délimité par des tabulations suivant le modèle de prédicat et de cas. En plus des 45 spécifications, répondez aux spécifications suivantes.
--Le terme est une chaîne de mots de la clause liée au prédicat (il n'est pas nécessaire de supprimer le mot auxiliaire de fin)
- S'il existe plusieurs clauses liées au prédicat, disposez-les dans le même standard et dans le même ordre que les mots auxiliaires, séparés par des espaces.
with open('./ans46.txt', 'w') as f:
for sentence in sentences:
for chunk in sentence.chunks:
for morph in chunk.morphs:
if morph.pos == 'verbe': # chunkの左から順番にverbeを探す
cases = []
modi_chunks = []
for src in chunk.srcs: #Rechercher un verbe auxiliaire à partir du bloc d'origine du verbe trouvé
case = [morph.surface for morph in sentence.chunks[src].morphs if morph.pos == 'Particule']
if len(case) > 0: #Pour les blocs contenant des mots auxiliaires, obtenez les mots et termes auxiliaires
cases = cases + case
modi_chunks.append(''.join(morph.surface for morph in sentence.chunks[src].morphs if morph.pos != 'symbole'))
if len(cases) > 0: #Si un ou plusieurs mots auxiliaires sont trouvés, triez-les dans l'ordre du dictionnaire après la déduplication et affichez-les avec les termes.
cases = sorted(list(set(cases)))
line = '{}\t{}\t{}'.format(morph.base, ' '.join(cases), ' '.join(modi_chunks))
print(line, file=f)
break
#Vérification
!cat ./ans46.txt | head -n 10
production
Où naître
Je ne sais pas s'il est né
Où pleurer
La seule chose que je pleurais
Commencez ici
Regarde ce que je vois
Écoutez plus tard
Attrapez-nous
Faire bouillir et attraper
Manger et bouillir
47. Exploration de la syntaxe des verbes fonctionnels
Je voudrais prêter attention uniquement au cas où le verbe wo case contient une nomenclature de connexion sa-hen. Modifiez 46 programmes pour répondre aux spécifications suivantes.
――Seulement lorsque la phrase consistant en "nom de connexion sahen + (verbe auxiliaire)" est liée au verbe Le prédicat est «nom de connexion Sahen + est la forme de base du + verbe», et lorsqu'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).
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
with open('./ans47.txt', 'w') as f:
for sentence in sentences:
for chunk in sentence.chunks:
for morph in chunk.morphs:
if morph.pos == 'verbe': # chunkの左から順番にverbeを探す
for i, src in enumerate(chunk.srcs): #Le morceau original du verbe que j'ai trouvé est "Sahen connectant le nom+Vérifiez s'il est composé de
if len(sentence.chunks[src].morphs) == 2 and sentence.chunks[src].morphs[0].pos1 == 'Changer de connexion' and sentence.chunks[src].morphs[1].surface == 'À':
predicate = ''.join([sentence.chunks[src].morphs[0].surface, sentence.chunks[src].morphs[1].surface, morph.base])
cases = []
modi_chunks = []
for src_r in chunk.srcs[:i] + chunk.srcs[i + 1:]: #Rechercher des mots auxiliaires dans les blocs restants
case = [morph.surface for morph in sentence.chunks[src_r].morphs if morph.pos == 'Particule']
if len(case) > 0: #Pour les blocs contenant des mots auxiliaires, obtenez les mots et termes auxiliaires
cases = cases + case
modi_chunks.append(''.join(morph.surface for morph in sentence.chunks[src_r].morphs if morph.pos != 'symbole'))
if len(cases) > 0: #Si un ou plusieurs mots auxiliaires sont trouvés, triez-les dans l'ordre du dictionnaire après la déduplication et affichez-les avec les termes.
cases = sorted(list(set(cases)))
line = '{}\t{}\t{}'.format(predicate, ' '.join(cases), ' '.join(modi_chunks))
print(line, file=f)
break
#Vérification
!cat ./ans47.txt | cut -f 1 | sort | uniq -c | sort -nr | head -n 10
production
29 réponse
21 Dites bonjour
18 parler
9 Poser une question
8 Faites une sieste
8 querelle
7 imiter
7 Poser des questions
6 Consulter
5 Poser une question
!cat ./ans47.txt | cut -f 1,2 | sort | uniq -c | sort -nr | head -n 10
production
8 Je vais répondre
8 Répondre
6 pour parler
6 pour parler
6 Dites bonjour
5 Je fais une sieste
5 Je vais dire bonjour
5 Pour dire bonjour
5 Dans une querelle
4 En réponse à
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'arbre 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 (de surface) --Concaténer les expressions de chaque clause de la clause de début à la clause de fin du chemin avec "->"
sentence = sentences[7]
for chunk in sentence.chunks:
if 'nom' in [morph.pos for morph in chunk.morphs]: # chunkがnomを含むか確認
path = [''.join(morph.surface for morph in chunk.morphs if morph.pos != 'symbole')]
while chunk.dst != -1: #Ajoutez un morceau à la liste en traçant dst jusqu'à la racine, en commençant par le morceau contenant la nomenclature.
path.append(''.join(morph.surface for morph in sentence.chunks[chunk.dst].morphs if morph.pos != 'symbole'))
chunk = sentence.chunks[chunk.dst]
print(' -> '.join(path))
production
je suis->vu
ici->Commencer avec->Humain->Des choses->vu
Humain->Des choses->vu
Des choses->vu
49. Extraction de chemins de dépendance entre nomenclature
Extraire 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 les 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 $ est sur le chemin de la clause $ i $ à la racine de l'arbre syntaxique: Afficher le chemin de la clause $ i $ à la clause $ j $ --Autre de ce qui précède, lorsque la clause $ i $ et la clause $ j $ se croisent à la 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 la clause $ j Le chemin de $ à juste avant la clause $ k $ et le contenu de la clause $ k $ sont concaténés avec "|" et affichés.
Par exemple
--i-> a-> b-> j-> Si la racine est `` `, alors` `ʻi-> a-> b-> j
i -> a -> k ->racine、j -> b -> k ->racineSi,i -> a | j -> b | k
Ensuite, la nomenclature de $ i $ et $ j $ doit être convertie en X et Y, respectivement, et affichée.
from itertools import combinations
sentence = sentences[7]
nouns = []
for i, chunk in enumerate(sentence.chunks):
if 'nom' in [morph.pos for morph in chunk.morphs]: # nomを含む文節を抽出
nouns.append(i)
for i, j in combinations(nouns, 2): #Créez un chemin pour chaque paire de clauses contenant la nomenclature
path_i = []
path_j = []
while i != j: # i,Suivez dst dans l'ordre jusqu'à ce que j atteigne la même clause
if i < j:
path_i.append(i)
i = sentence.chunks[i].dst
else:
path_j.append(j)
j = sentence.chunks[j].dst
if len(path_j) == 0: #Premier cas
chunk_X = ''.join([morph.surface if morph.pos != 'nom' else 'X' for morph in sentence.chunks[path_i[0]].morphs])
chunk_Y = ''.join([morph.surface if morph.pos != 'nom' else 'Y' for morph in sentence.chunks[i].morphs])
path_XtoY = [chunk_X] + [''.join(morph.surface for morph in sentence.chunks[n].morphs) for n in path_i[1:]] + [chunk_Y]
print(' -> '.join(path_XtoY))
else: #Deuxième cas
chunk_X = ''.join([morph.surface if morph.pos != 'nom' else 'X' for morph in sentence.chunks[path_i[0]].morphs])
chunk_Y = ''.join([morph.surface if morph.pos != 'nom' else 'Y' for morph in sentence.chunks[path_j[0]].morphs])
chunk_k = ''.join([morph.surface for morph in sentence.chunks[i].morphs])
path_X = [chunk_X] + [''.join(morph.surface for morph in sentence.chunks[n].morphs) for n in path_i[1:]]
path_Y = [chunk_Y] + [''.join(morph.surface for morph in sentence.chunks[n].morphs) for n in path_j[1:]]
print(' | '.join([' -> '.join(path_X), ' -> '.join(path_Y), chunk_k]))
production
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->Appelé Y
En X->Commencer avec->Humain->Oui
Appelé X->Oui
en conclusion
Traitement du langage 100 coups sont conçus pour que vous puissiez apprendre non seulement le traitement du langage naturel lui-même, mais également le traitement de données de base et l'apprentissage automatique général. Même ceux qui étudient l'apprentissage automatique dans des cours en ligne pourront pratiquer de très bons résultats, alors essayez-le.
Recommended Posts