Eine Bibliothek zur Schnittstelle mit der OpenNLP (Open Natural Language Processing) -Bibliothek von Funktionen. Nicht alle Funktionen werden noch implementiert.
Zusätzliche Informationen/Dokumentation:
Lesen Sie die Quelle von Marginalia
[clojure-opennlp " 0.5.0 " ] ; ; uses Opennlp 1.9.0Clojure-opennlp funktioniert mit Clojure 1.5+
( use 'clojure.pprint) ; just for this documentation
( use 'opennlp.nlp)
( use 'opennlp.treebank) ; treebank chunking, parsing and linking lives hereSie müssen die Verarbeitungsfunktionen mithilfe der Modelldateien erstellen. Diese gehen davon aus, dass Sie aus dem Stammprojektverzeichnis auslaufen. Sie können die Modelldateien auch vom OpenNLP-Projekt unter http://opennlp.sourceforge.net/models-1.5 herunterladen
( def get-sentences ( make-sentence-detector " models/en-sent.bin " ))
( def tokenize ( make-tokenizer " models/en-token.bin " ))
( def detokenize ( make-detokenizer " models/english-detokenizer.xml " ))
( def pos-tag ( make-pos-tagger " models/en-pos-maxent.bin " ))
( def name-find ( make-name-finder " models/namefind/en-ner-person.bin " ))
( def chunker ( make-treebank-chunker " models/en-chunker.bin " ))Die Werkzeugschöpfer sind Multimethods, sodass Sie auch eines der Tools mit einem Modell anstelle eines Dateinamens erstellen können (Sie können ein Modell mit den Trainingswerkzeugen in SRC/OpenNLP/Tools/Train.clj erstellen):
( def tokenize ( make-tokenizer my-tokenizer-model)) ; ; etc, etcVerwenden Sie dann die Funktionen, die Sie erstellt haben, um Operationen im Text auszuführen:
Sätze erkennen:
( pprint ( get-sentences " First sentence. Second sentence? Here is another one. And so on and so forth - you get the idea... " ))
[ " First sentence. " , " Second sentence? " , " Here is another one. " ,
" And so on and so forth - you get the idea... " ]Tokenisierung:
( pprint ( tokenize " Mr. Smith gave a car to his son on Friday " ))
[ " Mr. " , " Smith " , " gave " , " a " , " car " , " to " , " his " , " son " , " on " ,
" Friday " ]Erkunden:
( detokenize [ " Mr. " , " Smith " , " gave " , " a " , " car " , " to " , " his " , " son " , " on " , " Friday " ])
" Mr. Smith gave a car to his son on Friday. "Im Idealfall ist s == (detokenize (tokenize s)), die Detoken -Modell XML -Datei ist eine laufende Arbeit. Bitte lassen Sie mich wissen, ob Sie auf etwas stoßen, das nicht korrekt in englischer Sprache entdeckt.
Teil des Speech-Tagging:
( pprint ( pos-tag ( tokenize " Mr. Smith gave a car to his son on Friday. " )))
([ " Mr. " " NNP " ]
[ " Smith " " NNP " ]
[ " gave " " VBD " ]
[ " a " " DT " ]
[ " car " " NN " ]
[ " to " " TO " ]
[ " his " " PRP$ " ]
[ " son " " NN " ]
[ " on " " IN " ]
[ " Friday. " " NNP " ])Name finden:
( name-find ( tokenize " My name is Lee, not John. " ))
( "Lee" " John " )Treebank-Chunking Splits und Tags Phrasen aus einem POS-markierten Satz. Ein bemerkenswerter Unterschied besteht darin, dass es eine Liste von Strukturen mit der Folgendes zurückgibt: Phrase und: Tag -Tasten, wie unten angezeigt:
( pprint ( chunker ( pos-tag ( tokenize " The override system is meant to deactivate the accelerator when the brake pedal is pressed. " ))))
({ :phrase [ " The " " override " " system " ], :tag " NP " }
{ :phrase [ " is " " meant " " to " " deactivate " ], :tag " VP " }
{ :phrase [ " the " " accelerator " ], :tag " NP " }
{ :phrase [ " when " ], :tag " ADVP " }
{ :phrase [ " the " " brake " " pedal " ], :tag " NP " }
{ :phrase [ " is " " pressed " ], :tag " VP " })Für nur die Sätze:
( phrases ( chunker ( pos-tag ( tokenize " The override system is meant to deactivate the accelerator when the brake pedal is pressed. " ))))
([ " The " " override " " system " ] [ " is " " meant " " to " " deactivate " ] [ " the " " accelerator " ] [ " when " ] [ " the " " brake " " pedal " ] [ " is " " pressed " ])Und mit nur Saiten:
( phrase-strings ( chunker ( pos-tag ( tokenize " The override system is meant to deactivate the accelerator when the brake pedal is pressed. " ))))
( "The override system " " is meant to deactivate " " the accelerator " " when " " the brake pedal " " is pressed " )Dokumentenkategorisierung:
Weitere Beispiele finden Sie unter opennlp.test.tools.Train.
( def doccat ( make-document-categorizer " my-doccat-model " ))
( doccat " This is some good text " )
" Happy " Die Wahrscheinlichkeiten, die OpenNLP für einen bestimmten Vorgang liefert, sind gegebenenfalls als Metadaten für das Ergebnis erhältlich, sofern zutreffend:
( meta ( get-sentences " This is a sentence. This is also one. " ))
{ :probabilities ( 0.9999054310803004 0.9941126097177366 )}
( meta ( tokenize " This is a sentence. " ))
{ :probabilities ( 1.0 1.0 1.0 0.9956236737394807 1.0 )}
( meta ( pos-tag [ " This " " is " " a " " sentence " " . " ]))
{ :probabilities ( 0.9649410482478001 0.9982592902509803 0.9967282012835504 0.9952498677248117 0.9862225658078769 )}
( meta ( chunker ( pos-tag [ " This " " is " " a " " sentence " " . " ])))
{ :probabilities ( 0.9941248001899835 0.9878092935921453 0.9986106511439116 0.9972975733070356 0.9906377695586069 )}
( meta ( name-find [ " My " " name " " is " " John " ]))
{ :probabilities ( 0.9996272005494383 0.999999997485361 0.9999948113868132 0.9982291838206192 )} Sie können opennlp.nlp/*beam-size* (die Standardeinstellung 3) für den POS-Tagger und den TreeBank-Parser mit:
( binding [*beam-size* 1 ]
( def pos-tag ( make-pos-tagger " models/en-pos-maxent.bin " ))) Sie können opennlp.treebank/*advance-percentage* (der Standardwert 0,95) für den TreeBank-Parser mit:
( binding [*advance-percentage* 0.80 ]
( def parser ( make-treebank-parser " parser-model/en-parser-chunking.bin " )))HINWEIS: Die TreeBank -Parsen ist sehr maßgeschneidert intensiv. Stellen Sie sicher, dass Ihr JVM eine ausreichende Menge an Speicher zur Verfügung hat (mit etwas wie -xmx512m), oder Sie werden bei Verwendung eines Baumbank -Parsers keinen Haufenraum mehr haben.
Treebank Parsing erhält einen eigenen Abschnitt, weil es komplex ist.
Beachten Sie keines des TreeBank-Parser-Modells ist im Git-Repo enthalten. Sie müssen es separat vom OpenNLP-Projekt herunterladen.
Erstellen:
( def treebank-parser ( make-treebank-parser " parser-model/en-parser-chunking.bin " ))Um den Treebank-Parser zu verwenden, passieren Sie eine Reihe von Sätzen mit ihren Token, die durch Whitespace getrennt sind (vorzugsweise mit Tokenize)
( treebank-parser [ " This is a sentence . " ])
[ " (TOP (S (NP (DT This)) (VP (VBZ is) (NP (DT a) (NN sentence))) (. .))) " ]Um die Treebank-Parser-Zeichenfolge in etwas Leichter für Clojure zu verwandeln, verwenden Sie die Funktion (make tree ...):
( make-tree ( first ( treebank-parser [ " This is a sentence . " ])))
{ :chunk { :chunk ({ :chunk { :chunk " This " , :tag DT}, :tag NP} { :chunk ({ :chunk " is " , :tag VBZ} { :chunk ({ :chunk " a " , :tag DT} { :chunk " sentence " , :tag NN}), :tag NP}), :tag VP} { :chunk " . " , :tag .}), :tag S}, :tag TOP}Hier ist der Datenbetrag, der in ein wenig lesbareres Format aufgeteilt ist:
{ :tag TOP
:chunk { :tag S
:chunk ({ :tag NP
:chunk { :tag DT
:chunk " This " }}
{ :tag VP
:chunk ({ :tag VBZ
:chunk " is " }
{ :tag NP
:chunk ({ :tag DT
:chunk " a " }
{ :tag NN
:chunk " sentence " })})}
{ :tag .
:chunk " . " })}}Hoffentlich macht es ein bisschen klarer, eine verschachtelte Karte. Wenn jemand anderes Vorschläge für bessere Möglichkeiten hat, diese Informationen darzustellen, senden Sie mir gerne eine E -Mail oder einen Patch.
Die Treebank -Parsen wird an dieser Stelle als Beta angesehen.
( use 'opennlp.tools.filters)
( pprint ( nouns ( pos-tag ( tokenize " Mr. Smith gave a car to his son on Friday. " ))))
([ " Mr. " " NNP " ]
[ " Smith " " NNP " ]
[ " car " " NN " ]
[ " son " " NN " ]
[ " Friday " " NNP " ])
( pprint ( verbs ( pos-tag ( tokenize " Mr. Smith gave a car to his son on Friday. " ))))
([ " gave " " VBD " ])( use 'opennlp.tools.filters)
( pprint ( noun-phrases ( chunker ( pos-tag ( tokenize " The override system is meant to deactivate the accelerator when the brake pedal is pressed " )))))
({ :phrase [ " The " " override " " system " ], :tag " NP " }
{ :phrase [ " the " " accelerator " ], :tag " NP " }
{ :phrase [ " the " " brake " " pedal " ], :tag " NP " })( pos-filter determiners #"^DT" )
#'user/determiners
( doc determiners)
-------------------------
user/determiners
([elements__52__auto__])
Given a list of pos-tagged elements, return only the determiners in a list.
( pprint ( determiners ( pos-tag ( tokenize " Mr. Smith gave a car to his son on Friday. " ))))
([ " a " " DT " ])Sie können auch Treebank-Chunk-Filter mit (Chunk-Filter ...) erstellen
( chunk-filter fragments #"^FRAG$" )
( doc fragments)
-------------------------
opennlp.nlp/fragments
([elements__178__auto__])
Given a list of treebank-chunked elements, return only the fragments in a list.Es gibt einige Methoden, mit denen Sie bei der Markierung von Methoden faul sein können, je nach gewünschter Vorgang die entsprechende Methode:
#'opennlp.tools.lazy/lazy-get-sentences
#'opennlp.tools.lazy/lazy-tokenize
#'opennlp.tools.lazy/lazy-tag
#'opennlp.tools.lazy/lazy-chunk
#'opennlp.tools.lazy/sentence-seq
Hier erfahren Sie, wie man sie benutzt:
( use 'opennlp.nlp)
( use 'opennlp.treebank)
( use 'opennlp.tools.lazy)
( def get-sentences ( make-sentence-detector " models/en-sent.bin " ))
( def tokenize ( make-tokenizer " models/en-token.bin " ))
( def pos-tag ( make-pos-tagger " models/en-pos-maxent.bin " ))
( def chunker ( make-treebank-chunker " models/en-chunker.bin " ))
( lazy-get-sentences [ " This body of text has three sentences. This is the first. This is the third. " " This body has only two. Here's the last one. " ] get-sentences)
; ; will lazily return:
([ " This body of text has three sentences. " " This is the first. " " This is the third. " ] [ " This body has only two. " " Here's the last one. " ])
( lazy-tokenize [ " This is a sentence. " " This is another sentence. " " This is the third. " ] tokenize)
; ; will lazily return:
([ " This " " is " " a " " sentence " " . " ] [ " This " " is " " another " " sentence " " . " ] [ " This " " is " " the " " third " " . " ])
( lazy-tag [ " This is a sentence. " " This is another sentence. " ] tokenize pos-tag)
; ; will lazily return:
(([ " This " " DT " ] [ " is " " VBZ " ] [ " a " " DT " ] [ " sentence " " NN " ] [ " . " " . " ]) ([ " This " " DT " ] [ " is " " VBZ " ] [ " another " " DT " ] [ " sentence " " NN " ] [ " . " " . " ]))
( lazy-chunk [ " This is a sentence. " " This is another sentence. " ] tokenize pos-tag chunker)
; ; will lazily return:
(({ :phrase [ " This " ], :tag " NP " } { :phrase [ " is " ], :tag " VP " } { :phrase [ " a " " sentence " ], :tag " NP " }) ({ :phrase [ " This " ], :tag " NP " } { :phrase [ " is " ], :tag " VP " } { :phrase [ " another " " sentence " ], :tag " NP " }))Fühlen Sie sich frei, die faulen Funktionen zu verwenden, aber ich bin immer noch nicht zu 100% auf das Layout gesetzt, daher können sie sich in Zukunft ändern. (Vielleicht sieht sie sie anstelle einer Abfolge von Sätzen aus (faul (faul (faul (faul-tekaieren) (faul-get-Sentces ...)))).
Generieren einer faulen Abfolge von Sätzen aus einer Datei mit OpenNlp.tools.lazy/Sätze-Seq:
( with-open [rdr ( clojure.java.io/reader " /tmp/bigfile " )]
( let [sentences ( sentence-seq rdr get-sentences)]
; ; process your lazy seq of sentences however you desire
( println " first 5 sentences: " )
( clojure.pprint/pprint ( take 5 sentences))))Es gibt Code, um Trainingsmodelle für jedes der Tools zu ermöglichen. Bitte beachten Sie die Dokumentation im Training.Markdown
Copyright (C) 2010 Matthew Lee Hinman
Verteilt unter der Eclipse Public Lizenz, genau wie Clojure -Verwendungen. Siehe das Kopieren von Dateien.
