prose

Prosa

prose ist eine natürliche Sprachverarbeitungsbibliothek (im Moment nur Englisch) in reinem Go . Es unterstützt Tokenisierung, Segmentierung, Speech-Tagging und Namentity Extraction.

Eine detailliertere Zusammenfassung der Leistung der Bibliothek finden Sie hier: Einführung von prose v2.0.0: NLP zum Aufnehmen bringen.

Installation

$ go get github.com/jdkato/prose/v2 

Verwendung

Inhalt

• Überblick
• Token
• Segmentierung
• Tagging
• Ner

Überblick

 package main

import (
    "fmt"
    "log"

    "github.com/jdkato/prose/v2"
)

func main () {
    // Create a new document with the default configuration:
    doc , err := prose . NewDocument ( "Go is an open-source programming language created at Google." )
    if err != nil {
        log . Fatal ( err )
    }

    // Iterate over the doc's tokens:
    for _ , tok := range doc . Tokens () {
        fmt . Println ( tok . Text , tok . Tag , tok . Label )
        // Go NNP B-GPE
        // is VBZ O
        // an DT O
        // ...
    }

    // Iterate over the doc's named-entities:
    for _ , ent := range doc . Entities () {
        fmt . Println ( ent . Text , ent . Label )
        // Go GPE
        // Google GPE
    }

    // Iterate over the doc's sentences:
    for _ , sent := range doc . Sentences () {
        fmt . Println ( sent . Text )
        // Go is an open-source programming language created at Google.
    }
}

Der Dokumentenerstellungsprozess hält die folgende Abfolge von Schritten fest:

 tokenization -> POS tagging -> NE extraction
            
             segmentation

Jeder Schritt kann deaktiviert sein (unter der Annahme, dass spätere Schritte nicht erforderlich sind), indem die entsprechende Funktionsoption bestanden wird. Um beispielsweise die benannte Entraktion zu deaktivieren, würden Sie Folgendes durchführen:

 doc , err := prose . NewDocument (
        "Go is an open-source programming language created at Google." ,
        prose . WithExtraction ( false ))

Token

prose enthält einen Tokenschütze, der moderner Text verarbeiten kann, einschließlich der unten gezeigten Nicht-Wort-Zeichenspannen.

Typ	Beispiel
E -Mail -Adressen	[email protected]
Hashtags	#trending
Erwähnungen	@jdkato
URLs	https://github.com/jdkato/prose
Emoticons	:-) , >:( , o_0 usw.

 package main

import (
    "fmt"
    "log"

    "github.com/jdkato/prose/v2"
)

func main () {
    // Create a new document with the default configuration:
    doc , err := prose . NewDocument ( "@jdkato, go to http://example.com thanks :)." )
    if err != nil {
        log . Fatal ( err )
    }

    // Iterate over the doc's tokens:
    for _ , tok := range doc . Tokens () {
        fmt . Println ( tok . Text , tok . Tag )
        // @jdkato NN
        // , ,
        // go VB
        // to TO
        // http://example.com NN
        // thanks NNS
        // :) SYM
        // . .
    }
}

Segmentierung

prose enthält einen der genauesten verfügbaren Satzsegmentierer, gemäß den goldenen Regeln, die von den Entwicklern des pragmatic_segmenter erstellt wurden.

Name	Sprache	Lizenz	Grs (Englisch)	Grs (andere)	Geschwindigkeit†
Pragmatischer Segmentierer	Rubin	MIT	98,08% (51/52)	100,00%	3.84 s
Prosa	Gehen	MIT	75,00% (39/52)	N / A	0,96 s
Taktvoller	Rubin	GNU GPLV3	65,38% (34/52)	48,57%	46,32 s
OpenNLP	Java	APLV2	59,62% (31/52)	45,71%	1,27 s
Standford Corenlp	Java	GNU GPLV3	59,62% (31/52)	31,43%	0,92 s
Splitta	Python	APLV2	55,77% (29/52)	37,14%	N / A
Punkt	Python	APLV2	46,15% (24/52)	48,57%	1,79 s
SRX Englisch	Rubin	GNU GPLV3	30,77% (16/52)	28,57%	6.19 s
Scapel	Rubin	GNU GPLV3	28,85% (15/52)	20,00%	0,13 s

† Die Originaltests wurden mit einem MacBook Pro 3,7 GHz Quad-Core Intel Xeon E5 prose .

 package main

import (
    "fmt"
    "strings"

    "github.com/jdkato/prose/v2"
)

func main () {
    // Create a new document with the default configuration:
    doc , _ := prose . NewDocument ( strings . Join ([] string {
        "I can see Mt. Fuji from here." ,
        "St. Michael's Church is on 5th st. near the light." }, " " ))

    // Iterate over the doc's sentences:
    sents := doc . Sentences ()
    fmt . Println ( len ( sents )) // 2
    for _ , sent := range sents {
        fmt . Println ( sent . Text )
        // I can see Mt. Fuji from here.
        // St. Michael's Church is on 5th st. near the light.
    }
}

Tagging

prose enthält einen Tagger basierend auf dem "schnellen und genauen" POS -Tagger von TextBlob. Im Folgenden finden Sie einen Vergleich seiner Leistung mit der Implementierung desselben Taggers durch NLTK auf dem Treebank Corpus:

Bibliothek	Genauigkeit	5-Run-Durchschnitt (Sec)
NLTK	0,893	7.224
prose	0,961	2.538

(Weitere Informationen finden Sie scripts/test_model.py .)

Die vollständige Liste der unterstützten POS -Tags finden Sie unten.

ETIKETT	BESCHREIBUNG
(	Linksrunde Klammer
)	Runde Halterung
,	Komma
:	Doppelpunkt
.	Zeitraum
''	Schließungszitatmarke
``	Eröffnungszitatzeichen
#	Zahlenzeichen
$	Währung
CC	Konjunktion, Koordination
CD	Kardinalzahl
DT	Bestimmer
EX	existenziell dort
FW	fremdes Wort
IN	Konjunktion, Unterordnung oder Präposition
JJ	Adjektiv
JJR	Adjektiv, vergleichend
JJS	Adjektiv, superlativ
LS	Listen Sie die Elementmarkierung auf
MD	Verb, Modal Auxiliary
NN	Substantiv, Singular oder Masse
NNP	Substantiv, richtig Singular
NNPS	Substantiv, richtiger Plural
NNS	Substantiv, Plural
PDT	Vorderminer
POS	Besitzergreifend
PRP	Pronomen, persönlich
PRP$	Pronomen, besitzergreifend
RB	Adverb
RBR	Adverb, vergleichend
RBS	Adverb, superlativ
RP	Adverb, Partikel
SYM	Symbol
TO	Infinitival zu
UH	Zwischenruf
VB	Verb, Basisform
VBD	Verb, Vergangenheitsform
VBG	Verb, Gerund oder präsentiertes Partizip
VBN	Verb, Partizip Past
VBP	Verb, Nicht-Dritt-Person Singular Gegenwart
VBZ	Verb, 3. Person Singular Gegenwart
WDT	WH-DETERMINER
WP	Wh-Pronoun, persönlich
WP$	Wh-Pronoun, besitzergreifend
WRB	wh-adverb

Ner

prose v2.0.0 enthält eine viel verbesserte Version des Chunk -Pakets von V1.0.0, das Personen ( PERSON ) und geografische/politische Einheiten ( GPE ) standardmäßig identifizieren kann.

 package main

import (
    "github.com/jdkato/prose/v2"
)

func main () {
    doc , _ := prose . NewDocument ( "Lebron James plays basketball in Los Angeles." )
    for _ , ent := range doc . Entities () {
        fmt . Println ( ent . Text , ent . Label )
        // Lebron James PERSON
        // Los Angeles GPE
    }
}

Um diese Funktion nützlicher zu machen, haben wir es jedoch unkompliziert gemacht, Ihre eigenen Modelle für bestimmte Anwendungsfälle zu trainieren. Siehe Wunderkind + prose : Radikal effizienter Maschinenunterricht in GO für ein Tutorial.