web-dev-qa-db-fra.com

Résolution de coréférence en python nltk en utilisant Stanford coreNLP

Stanford CoreNLP fournit une résolution de coréférence comme mentionné ici , également ce fil , ce , fournit quelques informations sur son implémentation en Java.

Cependant, j'utilise python et NLTK et je ne sais pas comment puis-je utiliser la fonctionnalité de résolution Coreference de CoreNLP dans mon code python. J'ai pu mis en place StanfordParser en NLTK, c'est mon code jusqu'à présent.

from nltk.parse.stanford import StanfordDependencyParser
stanford_parser_dir = 'stanford-parser/'
eng_model_path = stanford_parser_dir  + "stanford-parser-models/edu/stanford/nlp/models/lexparser/englishRNN.ser.gz"
my_path_to_models_jar = stanford_parser_dir  + "stanford-parser-3.5.2-models.jar"
my_path_to_jar = stanford_parser_dir  + "stanford-parser.jar"

Comment puis-je utiliser la résolution de coréférence de CoreNLP en python?

pythonnlpnltkstanford-nlp
12
Riken Shah

Comme mentionné par @Igor Vous pouvez essayer le wrapper python implémenté dans ce dépôt GitHub: https://github.com/dasmith/stanford-corenlp-python

Ce dépôt contient deux fichiers principaux: corenlp.py client.py

Effectuez les modifications suivantes pour faire fonctionner coreNLP:

  1. Dans le corenlp.py, changez le chemin du dossier corenlp. Définissez le chemin où votre machine locale contient le dossier corenlp et ajoutez le chemin à la ligne 144 de corenlp.py

    if not corenlp_path: corenlp_path = <path to the corenlp file>

  2. Le numéro de version du fichier jar dans "corenlp.py" est différent. Réglez-le en fonction de la version corenlp que vous avez. Changez-le à la ligne 135 de corenlp.py

    jars = ["stanford-corenlp-3.4.1.jar", "stanford-corenlp-3.4.1-models.jar", "joda-time.jar", "xom.jar", "jollyday.jar"]

Dans ce cas, remplacez 3.4.1 par la version jar que vous avez téléchargée.

  1. Exécutez la commande:

    python corenlp.py

Cela démarrera un serveur

  1. Exécutez maintenant le programme client principal

    python client.py

Cela fournit un dictionnaire et vous pouvez accéder au coref en utilisant 'coref' comme clé:

Par exemple: John est un informaticien. Il aime coder.

{
     "coref": [[[["a Computer Scientist", 0, 4, 2, 5], ["John", 0, 0, 0, 1]], [["He", 1, 0, 0, 1], ["John", 0, 0, 0, 1]]]]
}

J'ai essayé cela sur Ubuntu 16.04. Utilisez Java version 7 ou 8.

8
Deesha

stanfordcorenlp , le wrapper relativement nouveau, peut fonctionner pour vous.

Supposons que le texte soit " Barack Obama est né à Hawaï. Il est le président. Obama a été élu en 2008. "

enter image description here

Le code:

# coding=utf-8

import json
from stanfordcorenlp import StanfordCoreNLP

nlp = StanfordCoreNLP(r'G:\JavaLibraries\stanford-corenlp-full-2017-06-09', quiet=False)
props = {'annotators': 'coref', 'pipelineLanguage': 'en'}

text = 'Barack Obama was born in Hawaii.  He is the president. Obama was elected in 2008.'
result = json.loads(nlp.annotate(text, properties=props))

num, mentions = result['corefs'].items()[0]
for mention in mentions:
    print(mention)

Chaque "mention" ci-dessus est un dict Python comme ceci:

{
  "id": 0,
  "text": "Barack Obama",
  "type": "PROPER",
  "number": "SINGULAR",
  "gender": "MALE",
  "animacy": "ANIMATE",
  "startIndex": 1,
  "endIndex": 3,
  "headIndex": 2,
  "sentNum": 1,
  "position": [
    1,
    1
  ],
  "isRepresentativeMention": true
}
6
Lynten

Le CoreNLP de Stanford a maintenant un officiel Python appelé StanfordNLP, comme vous pouvez le lire dans le site Web de StanfordNLP .

L'API native ne semble pas pour prendre en charge le processeur coref encore, mais vous pouvez utiliser l'interface CoreNLPClient pour appeler le CoreNLP "standard" (l'original Java Java) de Python.

Ainsi, après avoir suivi les instructions pour configurer le Python ici , vous pouvez obtenir la chaîne de référence comme ça:

from stanfordnlp.server import CoreNLPClient

text = 'Barack was born in Hawaii. His wife Michelle was born in Milan. He says that she is very smart.'
print(f"Input text: {text}")

# set up the client
client = CoreNLPClient(properties={'annotators': 'coref', 'coref.algorithm' : 'statistical'}, timeout=60000, memory='16G')

# submit the request to the server
ann = client.annotate(text)    

mychains = list()
chains = ann.corefChain
for chain in chains:
    mychain = list()
    # Loop through every mention of this chain
    for mention in chain.mention:
        # Get the sentence in which this mention is located, and get the words which are part of this mention
        # (we can have more than one Word, for example, a mention can be a pronoun like "he", but also a compound noun like "His wife Michelle")
        words_list = ann.sentence[mention.sentenceIndex].token[mention.beginIndex:mention.endIndex]
        #build a string out of the words of this mention
        ment_Word = ' '.join([x.Word for x in words_list])
        mychain.append(ment_Word)
    mychains.append(mychain)

for chain in mychains:
    print(' <-> '.join(chain))
2
rtrtrt

Peut-être que cela fonctionne pour vous? https://github.com/dasmith/stanford-corenlp-python Sinon, vous pouvez essayer de combiner les deux vous-même en utilisant http://www.jython.org/ =

1
Igor