Wie finden Sie den kürzesten Abhängigkeit Pfad zwischen zwei Wörtern in Python?

Dein problem kann leicht gedacht werden, als ein graph-problem, wo wir haben, um den kürzesten Pfad zwischen zwei Knoten.

Konvertieren Ihre Abhängigkeit von den Parsen in einem Diagramm, müssen wir zunächst mit der Tatsache auseinandersetzen, dass es darum geht, wie ein string. Sie wollen um dieses zu erhalten:

'nsubj(are-5, Robots-1)\nxsubj(remind-8, Robots-1)\namod(culture-4, popular-3)\nprep_in(Robots-1, culture-4)\nroot(ROOT-0, are-5)\nadvmod(are-5, there-6)\naux(remind-8, to-7)\nxcomp(are-5, remind-8)\ndobj(remind-8, us-9)\ndet(awesomeness-12, the-11)\nprep_of(remind-8, awesomeness-12)\namod(agency-16, unbound-14)\namod(agency-16, human-15)\nprep_of(awesomeness-12, agency-16)'

wie folgt Aussehen:

[('are-5', 'Robots-1'), ('remind-8', 'Robots-1'), ('culture-4', 'popular-3'), ('Robots-1', 'culture-4'), ('ROOT-0', 'are-5'), ('are-5', 'there-6'), ('remind-8', 'to-7'), ('are-5', 'remind-8'), ('remind-8', 'us-9'), ('awesomeness-12', 'the-11'), ('remind-8', 'awesomeness-12'), ('agency-16', 'unbound-14'), ('agency-16', 'human-15'), ('awesomeness-12', 'agency-16')]

Diese Weise können Sie füttern die Tupel-Liste ein graph Konstruktor von der networkx - Modul, analysieren Sie die Liste und erstellen Sie ein Diagramm für Sie, plus geben Sie eine saubere Methode, die gibt Ihnen die Länge des kürzesten Weges zwischen zwei gegebenen Knoten.

Notwendigen Importe

import re
import networkx as nx
from practnlptools.tools import Annotator

So kommen Sie zu Ihrem string in den gewünschten Tupel-Liste format

annotator = Annotator()
text = """Robots in popular culture are there to remind us of the awesomeness of unbound human agency."""
dep_parse = annotator.getAnnotations(text, dep_parse=True)['dep_parse']

dp_list = dep_parse.split('\n')
pattern = re.compile(r'.+?\((.+?), (.+?)\)')
edges = []
for dep in dp_list:
    m = pattern.search(dep)
    edges.append((m.group(1), m.group(2)))

, Wie das Diagramm

graph = nx.Graph(edges)  # Well that was easy

Wie die Berechnung des kürzesten Pfades der Länge

print(nx.shortest_path_length(graph, source='Robots-1', target='awesomeness-12'))

Dieses Skript wird zeigen, dass der kürzeste Weg angesichts der Abhängigkeit analysieren ist tatsächlich der Länge 2, da ist man von Robots-1 zu awesomeness-12 durch remind-8

1. xsubj(remind-8, Robots-1) 
2. prep_of(remind-8, awesomeness-12)

Wenn Sie nicht wie dieses Ergebnis, möchten Sie vielleicht denken über das filtern bestimmter Abhängigkeiten, in diesem Fall nicht möglich, die xsubj Abhängigkeit Hinzugefügt werden, um den graph.

Diese Antwort stützt sich auf Stanford CoreNLP zu erhalten, die Abhängigkeit Struktur eines Satzes. Es borgt sich einiges an code aus HugoMailhot ist Antwort bei der Verwendung von networkx.

Bevor den code ausgeführt wird, muss man:

1. sudo pip install pycorenlp (python-Schnittstelle für Stanford CoreNLP)
2. Download Der Stanford CoreNLP

3. Starten Stanford CoreNLP-server wie folgt:

   java -mx4g -cp "*" edu.stanford.nlp.pipeline.StanfordCoreNLPServer -port 9000 -timeout 50000

Dann kann man den folgenden code ausführen, um zu finden, die kürzeste Abhängigkeit Pfad zwischen zwei Wörtern:

import networkx as nx
from pycorenlp import StanfordCoreNLP
from pprint import pprint

nlp = StanfordCoreNLP('http://localhost:{0}'.format(9000))
def get_stanford_annotations(text, port=9000,
                             annotators='tokenize,ssplit,pos,lemma,depparse,parse'):
    output = nlp.annotate(text, properties={
        "timeout": "10000",
        "ssplit.newlineIsSentenceBreak": "two",
        'annotators': annotators,
        'outputFormat': 'json'
    })
    return output

# The code expects the document to contains exactly one sentence.
document =  'Robots in popular culture are there to remind us of the awesomeness of'\
            'unbound human agency.'
print('document: {0}'.format(document))

# Parse the text
annotations = get_stanford_annotations(document, port=9000,
                                       annotators='tokenize,ssplit,pos,lemma,depparse')
tokens = annotations['sentences'][0]['tokens']

# Load Stanford CoreNLP's dependency tree into a networkx graph
edges = []
dependencies = {}
for edge in annotations['sentences'][0]['basic-dependencies']:
    edges.append((edge['governor'], edge['dependent']))
    dependencies[(min(edge['governor'], edge['dependent']),
                  max(edge['governor'], edge['dependent']))] = edge

graph = nx.Graph(edges)
#pprint(dependencies)
#print('edges: {0}'.format(edges))

# Find the shortest path
token1 = 'Robots'
token2 = 'awesomeness'
for token in tokens:
    if token1 == token['originalText']:
        token1_index = token['index']
    if token2 == token['originalText']:
        token2_index = token['index']

path = nx.shortest_path(graph, source=token1_index, target=token2_index)
print('path: {0}'.format(path))

for token_id in path:
    token = tokens[token_id-1]
    token_text = token['originalText']
    print('Node {0}\ttoken_text: {1}'.format(token_id,token_text))

Ausgabe:

document: Robots in popular culture are there to remind us of the awesomeness of unbound human agency.
path: [1, 5, 8, 12]
Node 1  token_text: Robots
Node 5  token_text: are
Node 8  token_text: remind
Node 12 token_text: awesomeness

Beachten Sie, dass Stanford CoreNLP kann online getestet werden: http://nlp.stanford.edu:8080/parser/index.jsp

Dieser Antwort wurde getestet mit der Stanford CoreNLP 3.6.0., pycorenlp 0.3.0 und python 3.5 x64 auf Windows 7 SP1 x64 Ultimate.