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 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 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());
}
Die Konfiguration von UIMA-Komponenten erfolgt in der Regel durch die Erstellung von XML-Deskriptordateien, die dem Framework zur Laufzeit mitteilen, wie Komponenten instanziiert und bereitgestellt werden sollen. Diese XML-Deskriptordateien sind sehr eng mit der Java-Implementierung der von ihnen beschriebenen Komponenten gekoppelt. Wir haben festgestellt, dass es sehr schwierig ist, die beiden konsistent zu halten, insbesondere wenn Code-Refactoring sehr häufig vorkommt. uimaFIT bietet Java-Annotationen zur Beschreibung von UIMA-Komponenten, die verwendet werden können, um die UIMA-Komponenten direkt im Code zu beschreiben. Dies vereinfacht das Refactoring einer Komponentendefinition erheblich (z. B. das Ändern eines Konfigurationsparameternamens). Es ermöglicht auch, XML-Deskriptordateien als Teil des Build-Zyklus zu generieren, anstatt sie manuell parallel zur Codeerstellung durchzuführen. uimaFIT macht es auch einfach, UIMA-Komponenten ohne XML-Deskriptordateien zu instanziieren, indem es eine Reihe praktischer Factory-Methoden bereitstellt, die eine programmatische/dynamische Instanziierung von UIMA-Komponenten ermöglichen. Dies macht uimaFIT zu einer idealen Bibliothek zum Testen von UIMA-Komponenten, da die Komponente einfach instanziiert und aufgerufen werden kann, ohne dass zuerst eine Deskriptordatei erstellt werden muss. uimaFIT ist auch in Forschungsumgebungen hilfreich, in denen die programmatische/dynamische Instanziierung einer Pipeline das Experimentieren vereinfachen kann. Beispielsweise kann es bei der Durchführung einer 10-fachen Kreuzvalidierung über eine Reihe von experimentellen Bedingungen ziemlich mühsam sein, für jeden Durchlauf einen anderen Satz von Deskriptordateien oder sogar ein Skript zu erstellen, das solche Deskriptordateien generiert. uimaFIT ist typsystemunabhängig und hängt nicht von einem bestimmten Typsystem ab (und bietet auch keines).
uimaFIT ist eine Bibliothek, die Fabriken, Injection und Testdienstprogramme für UIMA bereitstellt. Die folgende Liste hebt einige der Funktionen hervor, die uimaFIT bietet:
Factories: Vereinfachen die programmatische Instanziierung von UIMA-Komponenten ohne Deskriptordateien. Beispielsweise könnte ein Aufruf wie folgt aussehen, um eine AnalysisEngine zu instanziieren:
AnalysisEngineFactory.createEngine(MyAEImpl.class, myTypeSystem,
paramName1, paramValue2,
paramName2, paramValue2,
...)
Injection: Behandelt die Bindung von Konfigurationsparameterwerten an die entsprechenden Membervariablen in den Analyse-Engines und die Bindung externer Ressourcen. Beispielsweise können Sie eine Membervariable mit @ConfigurationParameter annotieren, um einen Konfigurationsparameter zu binden. Externe Ressourcen können ebenfalls über die @ExternalResource-Annotation injiziert werden.
Fügen Sie dann eine Codezeile zu Ihrer Initialisierungsmethode hinzu:
ConfigurationParameterInitializer.initialize(this, uimaContext).
Dies wird automatisch behandelt, wenn Sie die uimaFIT-Klasse JCasAnnotator_ImplBase erweitern.
Testing: uimaFIT vereinfacht das Testen auf verschiedene Weise, die in der Dokumentation beschrieben werden. Indem es einfach wird, Ihre Komponenten ohne Deskriptordateien zu instanziieren, kann eine große Menge schwer zu wartender und unnötiger XML aus Ihrem Testcode entfernt werden. Dies macht Tests einfacher zu schreiben und zu warten. Auch das Ausführen von Komponenten als Pipeline kann mit einem Methodenaufruf wie diesem erfolgen:
SimplePipeline.runPipeline(reader, ae1, ..., aeN, consumer1, ... consumerN)
uimaFIT ist ein Teil des Apache UIMA(TM)-Projekts. uimaFIT kann nur in Verbindung mit einer kompatiblen Version der Java-Version des Apache UIMA SDK verwendet werden. Der Einfachheit halber enthält das Binärdistributionspaket von uimaFIT alle Bibliotheken, die zur Verwendung von uimaFIT erforderlich sind. Insbesondere für Anfänger wird dringend empfohlen, eine separate Kopie des vollständigen UIMA SDK zu besorgen.
uimaFIT ist über Maven Central verfügbar. Wenn Sie Maven für Ihre Build-Umgebung verwenden, können Sie uimaFIT als Abhängigkeit zu Ihrer pom.xml-Datei wie folgt hinzufügen:
<dependencies>
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimafit-core</artifactId>
<version>3.6.0</version>
</dependency>
</dependencies>
Module
Um Apache UIMA zu erstellen, benötigen Sie mindestens ein Java 17 JDK und eine aktuelle Maven 3 Version.
Nach dem Extrahieren des Quellverteilungs-ZIPs oder Klonen des Repositorys wechseln Sie in das erstellte Verzeichnis und führen Sie den folgenden Befehl aus:
mvn clean install
Weitere Details finden Sie unter http://uima.apache.org/building-uima.html
Sie können die Quell- und Binärverteilungen von der Apache UIMA-Website herunterladen.
Nachdem Sie die Apache UIMA-Verteilung aus dem von Ihnen gewählten Paket (z.B. .zip oder .gz) entpackt haben, führen Sie die folgenden Schritte aus, um UIMA einzurichten, damit es ordnungsgemäß funktioniert.
Setzen Sie JAVA_HOME auf das Verzeichnis Ihrer JRE-Installation, die Sie für UIMA verwenden möchten.
Setzen Sie UIMA_HOME auf das apache-uima-Verzeichnis Ihrer entpackten Apache UIMA-Verteilung.
Fügen Sie UIMA_HOME/bin zu Ihrem PATH hinzu.
Führen Sie bitte das Skript UIMA_HOME/bin/adjustExamplePaths.bat (oder .sh) aus, um die Pfade in den Beispielen basierend auf dem tatsächlichen UIMA_HOME-Verzeichnispfad zu aktualisieren.
Dieses Skript führt ein Java-Programm aus; Sie müssen entweder java in Ihrem PATH haben oder die Umgebungsvariable JAVA_HOME auf eine geeignete JRE setzen.
Hinweis: Die Verfahren des Mac OS X-Betriebssystems zum Einrichten globaler Umgebungsvariablen werden hier beschrieben: siehe http://developer.apple.com/qa/qa2001/qa1067.html.
Um die Installation zu testen, führen Sie die Datei documentAnalyzer.bat (oder .sh) im Unterverzeichnis bin aus. Es sollte ein Fenster Document Analyzer erscheinen. Stellen Sie die in dieser GUI angezeigten Werte wie folgt ein:
UIMA_HOME/examples/dataUIMA_HOME/examples/data/processedUIMA_HOME/examples/descriptors/analysis_engine/PersonTitleAnnotator.xmlErsetzen Sie UIMA_HOME oben durch den Pfad Ihrer Apache UIMA-Installation.
Klicken Sie dann auf die Schaltfläche Run, nach einer kurzen Pause sollte ein Fenster Analyzed Results erscheinen. Doppelklicken Sie auf eines der Dokumente, um die Analyseergebnisse für dieses Dokument anzuzeigen.
Hier ist eine Liste mehrerer bekannter Projekte, die ihre Analysetools als UIMA-Komponenten bereitstellen oder die Analysetools von Drittanbietern als UIMA-Komponenten kapseln:
Dies ist keine vollständige Liste. Wenn Sie der Meinung sind, dass ein bestimmtes Projekt hier aufgeführt werden sollte, lassen Sie es uns bitte wissen. Weitere Projekte finden Sie z.B. durch:
Das Apache UIMA Java SDK kann mit jeder Programmiersprache verwendet werden, die auf der Java Virtual Machine basiert, einschließlich Java, Groovy, Scala und vielen anderen Sprachen.
Die Interoperabilität mit Python kann beispielsweise über die Drittanbieter-Bibliothek DKPro Cassis erreicht werden, die zum Lesen, Bearbeiten und Schreiben von CAS-Daten im XMI-Format verwendet werden kann.
Das Apache UIMA Java SDK ist eine Java-basierte Implementierung der UIMA-Spezifikation.
Bitte richten Sie Fragen an [email protected].
Wenn Sie uimaFIT zur Unterstützung akademischer Forschung verwenden, ziehen Sie bitte in Betracht, das folgende Paper entsprechend zu zitieren:
@InProceedings{ogren-bethard:2009:SETQA-NLP,
author = {Ogren, Philip and Bethard, Steven},
title = {Building Test Suites for {UIMA} Components},
booktitle = {Proceedings of the Workshop on Software Engineering, Testing, and Quality Assurance for Natural Language Processing (SETQA-NLP 2009)},
month = {June},
year = {2009},
address = {Boulder, Colorado},
publisher = {Association for Computational Linguistics},
pages = {1--4},
url = {http://www.aclweb.org/anthology/W/W09/W09-1501}
}
Frühe 2000er: UIMA wurde ursprünglich von IBM im Rahmen der Forschung zur Analyse unstrukturierter Informationen (wie Text, Audio und Video) entwickelt. Es wurde entwickelt, um große Mengen unstrukturierter Daten skalierbar zu verarbeiten, mit Fokus auf Anwendungen der natürlichen Sprachverarbeitung (NLP).
2004: UIMA wurde als Open Source veröffentlicht, was eine breitere Nutzung und Beiträge von außerhalb IBM ermöglichte.
2006: Das UIMA-Projekt wurde in den Apache Incubator aufgenommen und begann den formalen Prozess, ein Apache-Projekt zu werden.
2008: UIMA graduierte aus dem Apache Incubator und wurde ein Top-Level-Apache-Projekt, was seine Reife und aktive Entwicklung zeigt.
2009: Apache UIMA-AS (Asynchronous Scaleout) wurde eingeführt, was verteilte und asynchrone Verarbeitung von UIMA-Pipelines ermöglicht.
2012: uimaFIT wurde zum Apache UIMA-Projekt beigetragen. Apache uimaFIT war früher als uimaFIT bekannt, das wiederum früher als UUTUC bekannt war. Vor seinem Beitrag war es eine gemeinsame Anstrengung des Center for Computational Pharmacology an der University of Colorado Denver, des Center for Computational Language and Education Research an der University of Colorado Boulder und des Ubiquitous Knowledge Processing (UKP) Lab an der Technischen Universität Darmstadt.
2013: UIMA DUCC (Distributed UIMA Cluster Computing) wurde als Unterprojekt von Apache UIMA eingeführt.
2016: Apache UIMA Ruta (Rule-based Text Annotation) wurde als Erweiterung eingeführt und bietet eine Skriptsprache für regelbasierte Textverarbeitung.
2023: UIMA DUCC und UIMA-AS wurden eingestellt.
2024: uimaFIT wurde in das UIMA Java SDK integriert.