[PYTHON] 100 traitement du langage knock-59: analyse de la formule S

Traitement linguistique 100 coups 2015 ["Chapitre 6: Traitement de texte anglais"](http: //www.cl.ecei) Il s'agit de l'enregistrement de la 59e "Analyse de l'équation S" de .tohoku.ac.jp / nlp100 / # ch6). Créez un analyseur dans un format appelé "S-type". Cela m'a fait penser à un analyseur pour la première fois, mais c'est très profond. Ce coup a duré très longtemps. Quand je l'ai fini, c'est environ 50 lignes, mais il y a beaucoup de place pour l'efficacité. Cette fois, j'ai abandonné l'efficacité et l'ai rendue aussi simple que possible.

Lien de référence

environnement

Chapitre 6: Traitement du texte anglais

contenu de l'étude

Un aperçu des différentes technologies de base pour le traitement du langage naturel grâce au traitement de texte anglais à l'aide de Stanford Core NLP.

Stanford Core NLP, dérivation, balisage de mot partiel, extraction d'expressions propres, analyse de co-référence, analyse de dépendance, analyse de structure de phrase, S-expression

Contenu frappé

Effectuez le traitement suivant sur le texte anglais (nlp.txt).

59. Analyse de la formule S

Lisez le résultat de l'analyse de la structure des phrases de Stanford Core NLP (formule S) et affichez toutes les phrases de nomenclature (NP) dans la phrase. Afficher toute la nomenclature imbriquée.

Supplément de problème (à propos de la "formule S")

Selon Wikipedia "formule S", l'explication suivante.

Une méthode de description formelle de bifurcation ou structure de liste introduite en Lisp et principalement utilisée en Lisp. S est dérivé de Symbol.

Le mécanisme d'expression du langage naturel avec "expression S" est décrit dans Stanford Parser et [Online test tool](http: / Il existe également /nlp.stanford.edu:8080/parser/). Il y avait aussi un package qui analyse les «expressions S» avec Python, mais il semble qu'il ne soit pas beaucoup utilisé, alors j'ai fait de mon mieux en le fabriquant moi-même.

Répondre

Programme de réponse [059. Analysis of S formula.ipynb](https://github.com/YoheiFukuhara/nlp100/blob/master/06.%E8%8B%B1%E8%AA%9E%E3%83%86% E3% 82% AD% E3% 82% B9% E3% 83% 88% E3% 81% AE% E5% 87% A6% E7% 90% 86 / 059.S% E5% BC% 8F% E3% 81% AE% E8% A7% A3% E6% 9E% 90.ipynb)

import re
import xml.etree.ElementTree as ET

reg_split = re.compile(r'''
                         (      #Début de groupe
                         \(|\)  #Groupe de caractères séparés(Commencer la parenthèse ou terminer la parenthèse)
                         )      #Fin du groupe
                         ''', re.VERBOSE)

def output_np(chunks): 
    depth = 1
    output = []

    for chunk in chunks:
        
        #Le début des parenthèses est la profondeur+1
        if chunk == '(':
            depth += 1

        #La fin de la parenthèse est la profondeur-1
        elif chunk == ')':
            depth -= 1
        else:
            
            #Diviser et ajouter à la destination de sortie dans le cas d'un ensemble de paroles et de texte de partie
            sets = chunk.split(' ')
            if len(sets) == 2:
                output.append(sets[1])
        
        #Sortie lorsque la profondeur atteint 0
        if depth == 0:
            print('\t', ' '.join(output))
            break

for parse in \
 ET.parse('./nlp.txt.xml').iterfind('./document/sentences/sentence/parse'):
    
    depth = 0
    print(parse.text)
    
    #Séparer et lister au début et à la fin des parenthèses(Exclure les éléments vides / vides)
    chunks = [chunk.strip() for chunk in reg_split.split(parse.text) 
                if chunk.strip() != '']
        
    #La sortie commence lorsque vous atteignez NP
    for i, chunk in enumerate(chunks):
        if chunk == 'NP':
            output_np(chunks[i+1:])

Répondre au commentaire

Chemin du fichier XML

Il s'agit d'un mappage entre le chemin du fichier XML suivant et l'expression S cible. Le contenu de l'expression S est inclus dans la balise «parse».

Le fichier XML est [GitHub](https://github.com/YoheiFukuhara/nlp100/blob/master/06.%E8%8B%B1%E8%AA%9E%E3%83%86%E3%82%AD% E3% 82% B9% E3% 83% 88% E3% 81% AE% E5% 87% A6% E7% 90% 86 / nlp.txt.xml).

xml:nlp.txt.xml(Extrait)

<root>
  <document>
    <docId>nlp.txt</docId>
    <sentences>
      <sentence id="1">

--Omission--

        <parse>(ROOT (S (PP (IN As) (NP (JJ such))) (, ,) (NP (NN NLP)) (VP (VBZ is) (ADJP (VBN related) (PP (TO to) (NP (NP (DT the) (NN area)) (PP (IN of) (NP (JJ humani-computer) (NN interaction))))))) (. .))) </parse>

Indentons la formule S ci-dessus pour la rendre un peu plus facile à voir. C'est une phrase relativement courte, mais elle est encore longue ... La partie texte de la partie entourée par ce NP (phrase nominale) est combinée et sortie.

(ROOT 
	(S 
		(PP 
			(IN As) 
			(NP 
				(JJ such)
			)
		) 
		(, ,) 
		(NP 
			(NN NLP)
		) 
		(VP 
			(VBZ is) 
			(ADJP 
				(VBN related) 
				(PP 
					(TO to) 
					(NP 
						(NP 
							(DT the) 
							(NN area)
						) 
						(PP 
							(IN of) 
							(NP 
								(JJ humani-computer) 
								(NN interaction)
							)
						)
					)
				)
			)
		) 
	(. .)
	)
)

Rechercher NP dans la boucle principale

C'est là que XML est lu, mis en boucle et recherché NP. La liste est divisée par des expressions régulières et les éléments vides / vides obstructifs sont exclus. Et quand NP arrive, nous appelons la fonction de sortie ʻoutput_np`. Lorsque NP est trouvé par le haut, il est émis, mais dans le cas d'un NP imbriqué, il est inefficace car il passe par la même logique plusieurs fois. Mais je voulais que les choses restent simples, donc je les laisse inefficaces.

python

for parse in \
 ET.parse('./nlp.txt.xml').iterfind('./document/sentences/sentence/parse'):

    depth = 0
    print(parse.text)

    #Séparer et lister au début et à la fin des parenthèses(Exclure les éléments vides / vides)
    chunks = [chunk.strip() for chunk in reg_split.split(parse.text) 
                if chunk.strip() != '']

    #La sortie commence lorsque vous atteignez NP
    for i, chunk in enumerate(chunks):
        if chunk == 'NP':
            output_np(chunks[i+1:])

Section de sortie NP

La profondeur de la formule S est jugée par le début et la fin des parenthèses, et elle est sortie lorsque la partie NP se termine.

python

def output_np(chunks): 
    depth = 1
    output = []

    for chunk in chunks:

        #Le début des parenthèses est la profondeur+1
        if chunk == '(':
            depth += 1

        #La fin de la parenthèse est la profondeur-1
        elif chunk == ')':
            depth -= 1
        else:

            #Diviser et ajouter à la destination de sortie dans le cas d'un ensemble de paroles et de texte de partie
            sets = chunk.split(' ')
            if len(sets) == 2:
                output.append(sets[1])

        #Sortie lorsque la profondeur atteint 0
        if depth == 0:
            print('\t', ' '.join(output))
            break

Résultat de sortie (résultat de l'exécution)

Lorsque le programme est exécuté, le résultat suivant est sorti (premier extrait).

Résultat de sortie(Top extrait)

(ROOT (S (PP (NP (JJ Natural) (NN language) (NN processing)) (IN From) (NP (NNP Wikipedia))) (, ,) (NP (NP (DT the) (JJ free) (NN encyclopedia) (JJ Natural) (NN language) (NN processing)) (PRN (-LRB- -LRB-) (NP (NN NLP)) (-RRB- -RRB-))) (VP (VBZ is) (NP (NP (NP (DT a) (NN field)) (PP (IN of) (NP (NN computer) (NN science)))) (, ,) (NP (JJ artificial) (NN intelligence)) (, ,) (CC and) (NP (NP (NNS linguistics)) (VP (VBN concerned) (PP (IN with) (NP (NP (DT the) (NNS interactions)) (PP (IN between) (NP (NP (NNS computers)) (CC and) (NP (JJ human) (-LRB- -LRB-) (JJ natural) (-RRB- -RRB-) (NNS languages)))))))))) (. .))) 
	 Natural language processing
	 Wikipedia
	 the free encyclopedia Natural language processing -LRB- NLP -RRB-
	 the free encyclopedia Natural language processing
	 NLP
	 a field of computer science , artificial intelligence , and linguistics concerned with the interactions between computers and human -LRB- natural -RRB- languages
	 a field of computer science
	 a field
	 computer science
	 artificial intelligence
	 linguistics concerned with the interactions between computers and human -LRB- natural -RRB- languages
	 linguistics
	 the interactions between computers and human -LRB- natural -RRB- languages
	 the interactions
	 computers and human -LRB- natural -RRB- languages
	 computers
	 human -LRB- natural -RRB- languages
(ROOT (S (PP (IN As) (NP (JJ such))) (, ,) (NP (NN NLP)) (VP (VBZ is) (ADJP (VBN related) (PP (TO to) (NP (NP (DT the) (NN area)) (PP (IN of) (NP (JJ humani-computer) (NN interaction))))))) (. .))) 
	 such
	 NLP
	 the area of humani-computer interaction
	 the area
	 humani-computer interaction
(ROOT (S (S (NP (NP (JJ Many) (NNS challenges)) (PP (IN in) (NP (NN NLP)))) (VP (VBP involve) (S (NP (NP (JJ natural) (NN language) (NN understanding)) (, ,) (SBAR (WHNP (WDT that)) (S (VP (VBZ is)))) (, ,)) (VP (VBG enabling) (NP (NNS computers)) (S (VP (TO to) (VP (VB derive) (NP (NN meaning)) (PP (IN from) (NP (ADJP (JJ human) (CC or) (JJ natural)) (NN language) (NN input)))))))))) (, ,) (CC and) (S (NP (NNS others)) (VP (VBP involve) (NP (JJ natural) (NN language) (NN generation)))) (. .))) 
	 Many challenges in NLP
	 Many challenges
	 NLP
	 natural language understanding , that is ,
	 natural language understanding
	 computers
	 meaning
	 human or natural language input
	 others
	 natural language generation