> ## Documentation Index
> Fetch the complete documentation index at: https://docs.abbyy.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Beispiel-Extraktionsregeln
> Praxisbeispiele für NLP-Extraktionsregeln — letztes Vorkommen einer Entität, Geldbeträge in Worten und Ziffern, Segmenterkennung, Gruppierung von Vertragsparteien und Zuordnung von Datum und Uhrzeit.
Dieser Abschnitt enthält einige Beispiel-Extraktionsregeln, die mit dem Code-Editor erstellt wurden, der mehr Flexibilität als die grafische Benutzeroberfläche bietet (siehe den Abschnitt [Syntax](/de/vantage/documentation/advanced-designer/activities/nlp-extraction-rules/code-syntax/syntax) für eine detaillierte Beschreibung der verwendeten Syntax).
## Die letzte Instanz einer benannten Entität finden
In diesem Beispiel wird eine Extraktionsregel verwendet, um den Namen der Organisation des Mieters in einem Mietvertrag zu ermitteln. Dieser Name erscheint nach den Namen aller anderen Organisationen und lässt sich nicht mit den Einstellungen in der GUI extrahieren, wo Sie nur **Instanzen > Erste** auswählen können. Sie können jedoch eine Extraktionsregel verwenden, um nach dem Namen der Organisation zu suchen, der unmittelbar vor dem in Klammern gesetzten Wort „Tenant“ steht.
Zuerst identifizieren wir das Schlüsselwort „Tenant“ als Hilfssuchelement. Als Nächstes suchen wir nach dem Namen der Organisation, der vor diesem Schlüsselwort vorkommt. In diesem Beispiel gibt es zwei dazwischenliegende Token — eine öffnende Klammer und ein Anführungszeichen — daher begrenzen wir den Abstand auf drei Token, mit etwas Sicherheitsmarge. Wenn Ihre Dokumente mehr dazwischenliegende Token aufweisen, die das Schlüsselwort vom Namen der Organisation trennen, erhöhen Sie diese Zahl entsprechend.
```
// Wir suchen nur nach einer Instanz
~TenantName
// Organisationsnamen finden, der vor dem Schlüsselwort "Tenant" steht
// und durch maximal drei Token davon getrennt ist
// Die dazwischenliegenden Token dürfen keinen weiteren Organisationsnamen enthalten
[ t: @NEROrganization ]+ [ ~@NEROrganization ~@kw_Tenant ]{0,3} [ @kw_Tenant ]
=>
TenantName( t );
```
### Beispiel
## Extrahieren eines Geldbetrags, der sowohl ausgeschrieben als auch als Zahl angegeben ist
In diesem Beispiel wird eine Extraktionsregel mit regulären Ausdrücken verwendet, um einen Geldbetrag zu finden, der zuerst ausgeschrieben und anschließend in runden Klammern als Ziffern angegeben ist, zum Beispiel:
Zweitausendeinhundertsiebenundvierzig Dollar und sechzig Cent (\$2,147.60)
Zweitausendeinhundertsiebenundvierzig Dollar und sechzig Cent (als Zahl: \$2,147.60)
```
// Die Variable a erhält die benannte Entität Money, die nicht in Ziffern vorliegt
// und noch keiner anderen Instanz des Suchelements Money zugewiesen wurde
[ a: @NERMoney( same ) ~@Money ~/\d+/ ]+
[ br: '(' ]
// Das Fragezeichen bedeutet, dass die Wörter „in numbers" optional sind
// Die Symbole ^ und $ bedeuten, dass die gesamte Zeichenkette dem regulären Ausdruck entsprechen muss
// Die Option i bedeutet, dass beim Abgleich die Groß- und Kleinschreibung ignoriert wird
( [ e1: /^in$/i ] [ e2: /^numbers$/i ] [ e3: ':' ]? )?
// Die Variable b erhält die benannte Entität Money, die innerhalb der Klammern platziert ist
[ b: @NERMoney( same ) ~@Money ]+
=>
Money( a + br + e1 + e2 + e3 + b );
```
### Beispiel
## Segmente mithilfe von Schlüsselwörtern finden
In diesem Beispiel werden Extraktionsregeln verwendet, um Segmente zu finden, die von der Aktivität Segmentation nicht zuverlässig erkannt werden können. Die Regeln suchen nach Schlüsselwörtern, die ein Segment einleiten oder abschließen, und extrahieren den dazwischenliegenden Text.
Wir gehen davon aus, dass unsere Dokumente nummerierte Überschriften der zweiten Ebene in Großbuchstaben enthalten, zum Beispiel: 1.1 PREMISES, 2.3 LIABILITY AND INDEMNITY und so weiter. Außerdem nehmen wir an, dass wir die Überschriften der ersten Ebene bereits in ein Suchelement namens „kw\_Heading1“ extrahiert haben (die entsprechende Extraktionsregel wird der Kürze halber weggelassen).
Zunächst suchen wir nach Schlüsselwörtern, die jeden Absatz des Dokuments einleiten, und extrahieren sie in ein Suchelement namens „kw\_Heading2“. Anschließend legen wir den Text zwischen zwei aufeinanderfolgenden Schlüsselwörtern in ein Suchelement namens „Segment“ ab.
In der aktuellen Version von Advanced Designer ist der Code-Editor nur für Suchelemente verfügbar, die zur Erkennung benannter Entitäten verwendet werden. Als Workaround können Sie, um Text wie Überschriften oder Segmente per Code zu extrahieren, einfach ein Suchelement für eine der unterstützten benannten Entitäten (zum Beispiel **Organization**) erstellen und den Regelcode in den Code-Editor dieses Elements eingeben.
```
// Suche nach einer nummerierten Überschrift der zweiten Ebene mit bis zu fünf Wörtern in Großbuchstaben
// Die Überschriftsnummer kann als ein Token gefunden werden: 1.1
[ t1: /\d{1,2}\.\d{1,2}/ ] [ t2: ]{1,5}
=>
kw_Heading2( t1 + t2 );
// Die Überschriftsnummer kann als drei separate Token gefunden werden: 1, Punkt, 1
[ t1: /\d{1,2}/ ] [ t2: '.' ] [ t3: /\d{1,2}/ ] [ t4: ]{1,5}
=>
kw_Heading2( t1 + t2 + t3 + t4 );
```
```
// Finde das Textsegment zwischen zwei aufeinanderfolgenden Abschnittsüberschriften
// Schließe auch alle Überschriften der ersten Ebene aus
[ @kw_Heading2 ] [ interval: ~@kw_Heading2 ~@kw_Heading1 ]+
=>
Root.Segment( interval );
```
### Beispiel
In diesem Beispiel werden „3.1 FIRSTLY“ und „3.2 SECONDLY“ in das Suchelement `kw_Heading2` extrahiert. Anschließend wird der Text zwischen jeweils zwei aufeinanderfolgenden Vorkommen des Suchelements `kw_Heading2` in eine Instanz des Suchelements `Segment` extrahiert.
## Gruppierung der Informationen zu jeder Entität
In diesem Beispiel werden Extraktionsregeln verwendet, um sicherzustellen, dass die Angaben zu jeder Partei eines Vertrags korrekt gruppiert werden (d. h. der Name und die Adresse jeder Partei gehören zu einer Gruppeninstanz und werden nicht auf mehrere Instanzen verteilt oder mit den Angaben der anderen Partei vermischt).
Die Idee ist, identifizierende Informationen über eine Partei zu finden, die immer zuerst erscheinen. Es gibt mehrere Möglichkeiten, dies zu erreichen, je nachdem, wie Verträge formuliert sind.
In diesem Beispiel gehen wir davon aus, dass der Name jeder Organisation immer zuerst kommt, gefolgt von ihrer Adresse und Rolle im Vertrag. Daher werden wir:
1. Nach Organisationsnamen suchen, für jeden gefundenen Namen eine neue Instanz des Gruppensuchelements `Party_Group` erstellen und dessen untergeordnetes Suchelement mit dem Namen „`Organization_Name`“ ausfüllen.
2. Nach der Adresse und der Rolle suchen, die höchstens, sagen wir, 20 Token von jeder Instanz des Organisationsnamens entfernt sind, die Instanz von `Party_Group` aufrufen, die das übergeordnete Element des Organisationsnamens ist, und die untergeordneten Suchelemente „`Address`“ und „`Role`“ in dieser Instanz ausfüllen.
Daten werden nur innerhalb des Segments gesucht, das von der Segmentation-Aktivität gefunden und als Eingabefeld mit dem Namen „Parties\_Segment“ an die Extraction-Rules-Aktivität übergeben wurde.
```
// Organisationsnamen suchen und für jeden eine neue Gruppeninstanz erstellen
[ org: @NEROrganization( same ) ~@Party_Group.Organization_Name @Parties_Segment ]+
=>
// Neue Instanz von Party_Group erstellen und Organization_Name befüllen
Party_Group.Organization_Name( org );
```
```
// Suchen Sie nun nach der Adresse, die durch maximal 20 Token
// vom Organisationsnamen getrennt ist
// und die noch keiner der Organisationen in Party_Group zugewiesen wurde
[ org: @Party_Group.Organization_Name( same ) ]+
[ ~@NERAddress ]{0,20}
[ t: @NERAddress( same ) ~@Party_Group.Address @Parties_Segment ]+
=>
// Greifen Sie auf die Instanz von Party_Group zu, die das übergeordnete Element des Organisationsnamens ist
// und füllen Sie deren untergeordnetes Element Address aus
parent( obj( org )).Address( t );
```
```
// Dasselbe für die Rolle wiederholen
// Um die Rolle zu finden, Schlüsselwörter verwenden
[ org: @Party_Group.Organization_Name( same ) ]+
[ ~("Tenant" | "Landlord" | "Broker") ]{0,20}
[ t: "Tenant" | "Landlord" | "Broker" ~@Party_Group.Role @Parties_Segment ]+
=>
parent( obj( org )).Role( t );
```
### Beispiel
Die Suchelemente werden wie folgt extrahiert:
Im Datenformular können Sie außerdem sehen, dass Name, Adresse und Rolle jedes Unternehmens jeweils unter einer separaten Gruppeninstanz zusammengefasst sind:
Die Angaben zu jeder Organisation sind zusammen gruppiert, was die Instanznummern in Klammern zeigen.
## Datum und Uhrzeit gemeinsam finden
In diesem Beispiel wird eine Extraktionsregel verwendet, um eine Kombination aus Uhrzeit und Datum zu ermitteln.
Zuerst verwenden wir ein Suchelement namens „Time“ vom Typ **Wert aus regulärem Ausdruck** (der verwendete reguläre Ausdruck lautet `[1]?\d:\d{2}\s+(([ap]\.m\.)|([AP]M))?`). Anschließend suchen wir nach einer in der Nähe befindlichen benannten Entität **Date**. Abschließend verketten wir die gefundenen Token-Sequenzen und weisen das Ergebnis einem Suchelement namens „TimeAndDate“ zu.
### Regel zum gemeinsamen Extrahieren von Datum und Uhrzeit
```
// Verwenden Sie einen Wert aus dem Suchelement für reguläre Ausdrücke, um die Uhrzeit zu finden
// Verwenden Sie @NERDate, um eine benannte Entität vom Typ Datum in der Nähe der Uhrzeit zu finden
[ time: @Time ~@TimeAndDate ]+ [ t: ~@NERDate ]{0,3} [ date: @NERDate( same ) ]+
=>
// Kombinieren Sie die Werte, um sie in ein Feld zu schreiben
// Nur aufeinanderfolgende Token-Sequenzen können kombiniert werden, daher wird auch das Hilfstoken hinzugefügt
TimeAndDate( time + t + date );
```
### Beispiel
