shoucheng3/apache__uima-uimaj_cve-2022-32287_3-3-0Java SDK zum Erstellen von Analyse-Pipelines, die unstrukturierte Textdaten mit Annotationen, Typsystemen und modularen Analyse-Engines verarbeiten und anreichern.
[Apache UIMA][UIMA] hilft Ihnen bei der Verwaltung unstrukturierter Daten (wie Texten), die mit nützlichen Informationen angereichert werden. Wenn Sie beispielsweise eine Erwähnung einer Entität in einem Text identifizieren oder diese Entität möglicherweise mit einem Referenzdatensatz verknüpfen möchten, dann bietet Apache UIMA:
Beachten Sie, dass das Apache UIMA Java SDK nur ein Framework zum Erstellen von Analysen bereitstellt, aber keine Analysen selbst liefert. Es gibt jedoch verschiedene Drittanbieter, die auf Apache UIMA aufbauen und Sammlungen von Analysekomponenten oder fertige Lösungen bereitstellen.
Apache UIMA v3.6.0 und höher benötigt Java Version 17 oder höher.
Die Ausführung des Eclipse-Plugin-Toolings für UIMA erfordert, dass Sie Eclipse 4.25 (2022-09) oder höher mit Java 17 oder höher starten.
Die Ausführung des Migrationstools auf Klassendateien erfordert die Verwendung eines Java JDK, nicht eines Java JRE.
Die unterstützten Plattformen sind: Windows, Linux und macOS. Andere Java-Plattformimplementierungen sollten funktionieren, wurden aber nicht umfassend getestet.
Viele der Skripte im Verzeichnis /bin rufen Java auf. Sie verwenden den Wert der Umgebungsvariablen JAVA_HOME, um das zu verwendende Java zu lokalisieren; ist sie nicht gesetzt, rufen sie java auf und erwarten, ein geeignetes Java in Ihrer PATH-Variable zu finden.
Sie können das Apache UIMA Java SDK in den meisten Build-Tools ganz einfach zu Ihrem Projekt hinzufügen, indem Sie es von [Maven Central][MAVEN-CENTRAL] importieren. Wenn Sie beispielsweise Maven verwenden, können Sie die folgende Abhängigkeit zu Ihrem Projekt hinzufügen:
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimaj-core</artifactId>
<version>3.6.0</version>
</dependency>
Als Nächstes geben wir einige kurze Beispiele zur Verwendung des Apache UIMA Java SDK und der Apache uimaFIT-Bibliothek. Apache uimaFIT ist eine separate Abhängigkeit, die Sie hinzufügen können:
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimafit-core</artifactId>
<version>3.6.0</version>
</dependency>
Das Typsystem definiert die Art der Informationen, die wir an die unstrukturierten Informationen (hier ein Textdokument) anhängen möchten. In unserem Beispiel möchten wir Erwähnungen von Entitäten identifizieren, daher definieren wir einen Typ my.Entity mit einem Feature category, das verwendet werden kann, um die Kategorie zu speichern, zu der die Entität gehört.
Um zu veranschaulichen, welche Informationen UIMA intern über das Annotationsschema verwaltet, schreiben wir das generierte Schema als XML auf den Bildschirm.
String TYPE_NAME_ENTITY = "my.Entity";
String TYPE_NAME_TOKEN = "my.Token";
String FEAT_NAME_CATEGORY = "category";
var tsd = UIMAFramework.getResourceSpecifierFactory().createTypeSystemDescription();
tsd.addType(TYPE_NAME_TOKEN, "", CAS.TYPE_NAME_ANNOTATION);
var entityTypeDesc = tsd.addType(TYPE_NAME_ENTITY, "", CAS.TYPE_NAME_ANNOTATION);
entityTypeDesc.addFeature(FEAT_NAME_CATEGORY, "", CAS.TYPE_NAME_STRING);
tsd.toXML(System.out);
Jetzt erstellen wir ein Common Analysis Structure (CAS)-Objekt, in dem wir den Text speichern, den wir analysieren möchten.
Auch hier schreiben wir, um die Informationen zu veranschaulichen, die UIMA intern im CAS-Objekt speichert, eine XML-Repräsentation des Objekts auf den Bildschirm.
var cas = CasFactory.createCas(tsd);
cas.setDocumentText("Welcome to Apache UIMA.");
cas.setDocumentLanguage("en");
CasIOUtils.save(cas, System.out, SerialFormat.XMI_PRETTY);
Jetzt erstellen wir eine Annotation vom Typ my.Entity, um die Erwähnung von Apache UIMA im Beispieltext zu identifizieren.
Schließlich iterieren wir über alle Annotationen im CAS und geben sie auf dem Bildschirm aus. Dies umfasst die standardmäßige DocumentAnnotation, die von UIMA immer erstellt wird, sowie die my.Entity-Annotation, die wir selbst erstellt haben.
var entityType = cas.getTypeSystem().getType(TYPE_NAME_ENTITY);
var entity = cas.createAnnotation(entityType, 11, 22);
cas.addFsToIndexes(entity);
for (var anno : cas.<Annotation>select(entityType)) {
System.out.printf("%s: [%s]%n", anno.getType().getName(), anno.getCoveredText());
}
Um verschiedene Analysetypen in Schritten zu organisieren, verpacken wir sie normalerweise in einzelne Analyse-Engines. Wir veranschaulichen nun, wie solche Komponenten erstellt und als Analyse-Pipeline ausgeführt werden können.
class TokenAnnotator extends CasAnnotator_ImplBase {
public void process(CAS cas) throws AnalysisEngineProcessException {
var tokenType = cas.getTypeSystem().getType(TYPE_NAME_TOKEN);
var bi = BreakIterator.getWordInstance();
bi.setText(cas.getDocumentText());
int begin = bi.first();
int end;
for (end = bi.next(); end != BreakIterator.DONE; end = bi.next()) {
var token = cas.createAnnotation(tokenType, begin, end);
cas.addFsToIndexes(token);
begin = end;
}
}
}
class EntityAnnotator extends CasAnnotator_ImplBase {
public void process(CAS cas) throws AnalysisEngineProcessException {
var tokenType = cas.getTypeSystem().getType(TYPE_NAME_TOKEN);
var entityType = cas.getTypeSystem().getType(TYPE_NAME_ENTITY);
for (var token : cas.<Annotation>select(tokenType)) {
if (Character.isUpperCase(token.getCoveredText().charAt(0))) {
var entity = cas.createAnnotation(entityType, token.getBegin(), token.getEnd());
cas.addFsToIndexes(entity);
}
}
}
}
cas = CasFactory.createCas(tsd);
cas.setDocumentText("John likes Apache UIMA.");
cas.setDocumentLanguage("en");
var pipeline = AnalysisEngineFactory.createEngineDescription(
AnalysisEngineFactory.createEngineDescription(TokenAnnotator.class),
AnalysisEngineFactory.createEngineDescription(EntityAnnotator.class));
SimplePipeline.runPipeline(cas, pipeline);
for (var anno : cas.<Annotation>select(entityType)) {
System.out.printf("%s: [%s]%n", anno.getType().getName(), anno.getCoveredText());
}