shoucheng3/apache__uima-uimaj_cve-2022-32287_3-3-0SDK Java per la costruzione di pipeline di analisi che elaborano e arricchiscono dati testuali non strutturati con annotazioni, sistemi di tipi e motori di analisi modulari.
Apache UIMA ti aiuta a gestire dati non strutturati (come i testi) arricchiti con informazioni utili. Ad esempio, se vuoi identificare una menzione di un'entità in un testo o possibilmente collegare tale entità a un dataset di riferimento, Apache UIMA fornisce:
Nota: Apache UIMA Java SDK fornisce solo un framework per costruire sistemi di analisi, ma non fornisce alcun sistema di analisi stesso. Tuttavia, esistono vari terze parti che si basano su Apache UIMA e che forniscono collezioni di componenti di analisi o soluzioni pronte.
Apache UIMA v3.6.0 e successive richiede Java versione 17 o successiva.
L'esecuzione del plugin Eclipse per UIMA richiede di avviare Eclipse 4.25 (2022-09) o successivo con Java 17 o successivo.
L'esecuzione dello strumento di migrazione su file class richiede l'esecuzione con un Java JDK, non un Java JRE.
Le piattaforme supportate sono: Windows, Linux e macOS. Altre implementazioni della piattaforma Java dovrebbero funzionare ma non sono state testate in modo significativo.
Molti degli script nella directory /bin invocano Java. Utilizzano il valore della variabile d'ambiente per individuare il Java da usare; se non è impostata, invocano aspettandosi di trovare un Java appropriato nella variabile .
JAVA_HOMEjavaPATHPuoi aggiungere Apache UIMA Java SDK al tuo progetto facilmente nella maggior parte degli strumenti di build importandolo da Maven Central. Ad esempio, se usi Maven, puoi aggiungere la seguente dipendenza al tuo progetto:
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimaj-core</artifactId>
<version>3.6.0</version>
</dependency>
Successivamente, forniamo alcuni brevi esempi su come utilizzare Apache UIMA Java SDK e la libreria Apache uimaFIT. Apache uimaFIT è una dipendenza separata che puoi aggiungere:
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimafit-core</artifactId>
<version>3.6.0</version>
</dependency>
Il sistema di tipi definisce il tipo di informazione che vogliamo allegare all'informazione non strutturata (qui un documento di testo). Nel nostro esempio, vogliamo identificare menzioni di entità, quindi definiamo un tipo my.Entity con una caratteristica category che può essere usata per memorizzare la categoria a cui appartiene l'entità.
Per illustrare le informazioni che UIMA mantiene internamente sullo schema di annotazione, scriviamo lo schema generato come XML a schermo.
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);
Ora creiamo un oggetto Common Analysis Structure (CAS) in cui memorizziamo il testo che vogliamo analizzare.
Ancora una volta, per illustrare le informazioni che UIMA memorizza internamente nell'oggetto CAS, scriviamo una rappresentazione XML dell'oggetto a schermo.
var cas = CasFactory.createCas(tsd);
cas.setDocumentText("Welcome to Apache UIMA.");
cas.setDocumentLanguage("en");
CasIOUtils.save(cas, System.out, SerialFormat.XMI_PRETTY);
Ora, creiamo un'annotazione del tipo my.Entity per identificare la menzione di Apache UIMA nel testo di esempio.
Infine, iteriamo su tutte le annotazioni nella CAS e le stampiamo a schermo. Questo include l'DocumentAnnotation predefinita che viene sempre creata da UIMA, così come l'annotazione my.Entity che abbiamo creato noi stessi.
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());
}
Per organizzare diversi tipi di analisi in passaggi, di solito li raggruppiamo in singoli motori di analisi. Illustriamo ora come tali componenti possono essere costruiti e come possono essere eseguiti come pipeline di analisi.
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());
}
La configurazione dei componenti UIMA viene generalmente ottenuta creando file di descrizione XML che dicono al framework in fase di esecuzione come i componenti devono essere istanziati e distribuiti. Questi file di descrizione XML sono strettamente accoppiati con l'implementazione Java dei componenti che descrivono. Abbiamo scoperto che è molto difficile mantenere i due coerenti tra loro, specialmente quando il refactoring del codice è molto frequente. uimaFIT fornisce annotazioni Java per descrivere i componenti UIMA che possono essere utilizzate per descrivere direttamente i componenti UIMA nel codice. Questo semplifica enormemente il refactoring di una definizione di componente (ad esempio, cambiare il nome di un parametro di configurazione). Rende anche possibile generare file di descrizione XML come parte del ciclo di build piuttosto che essere eseguiti manualmente in parallelo con la creazione del codice. uimaFIT rende anche facile istanziare componenti UIMA senza utilizzare affatto file di descrizione XML fornendo una serie di metodi factory di comodo che consentono l'istanziazione programmatica/dinamica dei componenti UIMA. Questo rende uimaFIT una libreria ideale per testare i componenti UIMA perché il componente può essere facilmente istanziato e invocato senza richiedere la creazione preventiva di un file di descrizione. uimaFIT è anche utile in ambienti di ricerca in cui l'istanziazione programmatica/dinamica di una pipeline può semplificare la sperimentazione. Ad esempio, quando si esegue una convalida incrociata a 10 pieghe su una serie di condizioni sperimentali, può essere molto laborioso creare un diverso set di file di descrizione per ogni esecuzione o persino uno script che generi tali file di descrizione. uimaFIT è agnostico rispetto al sistema di tipi e non dipende (né fornisce) un sistema di tipi specifico.
uimaFIT è una libreria che fornisce factory, iniezione e utilità di test per UIMA. Il seguente elenco evidenzia alcune delle funzionalità che uimaFIT fornisce:
Factory: semplificano l'istanziazione programmatica dei componenti UIMA senza file di descrizione. Ad esempio, per istanziare un AnalysisEngine si potrebbe fare una chiamata come questa:
AnalysisEngineFactory.createEngine(MyAEImpl.class, myTypeSystem,
paramName1, paramValue2,
paramName2, paramValue2,
...)
Iniezione: gestisce il binding dei valori dei parametri di configurazione alle variabili membro corrispondenti nei motori di analisi e gestisce il binding delle risorse esterne. Ad esempio, per legare un parametro di configurazione è sufficiente annotare una variabile membro con @ConfigurationParameter. Le risorse esterne possono essere iniettate allo stesso modo tramite l'annotazione @ExternalResource. Quindi aggiungi una riga di codice al tuo metodo di inizializzazione:
ConfigurationParameterInitializer.initialize(this, uimaContext).
Questo viene gestito automaticamente se estendi la classe JCasAnnotator_ImplBase di uimaFIT.
Test: uimaFIT semplifica il testing in diversi modi descritti nella documentazione. Rendendo facile istanziare i tuoi componenti senza file di descrizione, una grande quantità di XML difficile da mantenere e non necessario può essere eliminata dal codice di test. Questo rende i test più facili da scrivere e mantenere. Inoltre, eseguire i componenti come pipeline può essere realizzato con una chiamata al metodo come questa:
SimplePipeline.runPipeline(reader, ae1, ..., aeN, consumer1, ... consumerN)
uimaFIT fa parte del progetto Apache UIMA(TM). uimaFIT può essere utilizzato solo insieme a una versione compatibile della versione Java di Apache UIMA SDK. Per vostra comodità, il pacchetto di distribuzione binaria di uimaFIT include tutte le librerie necessarie per utilizzare uimaFIT. In particolare per gli utenti alle prime armi, si consiglia vivamente di ottenere una copia del SDK UIMA completo separatamente.
uimaFIT è disponibile tramite Maven Central. Se usi Maven per il tuo ambiente di build, puoi aggiungere uimaFIT come dipendenza al tuo file pom.xml con quanto segue:
<dependencies>
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimafit-core</artifactId>
<version>3.6.0</version>
</dependency>
</dependencies>
Moduli
Per costruire Apache UIMA, hai bisogno almeno di un Java 17 JDK e di una versione recente di Maven 3.
Dopo aver estratto l'archivio della distribuzione dei sorgenti o clonato il repository, entra nella directory creata ed esegui il seguente comando:
mvn clean install
Per maggiori dettagli, consulta http://uima.apache.org/building-uima.html
Puoi scaricare le distribuzioni sorgente e binaria dal sito web di Apache UIMA.
Dopo aver decompresso la distribuzione di Apache UIMA dal pacchetto scelto (ad esempio .zip o .gz), esegui i passaggi seguenti per configurare UIMA in modo che funzioni correttamente.
Imposta JAVA_HOME sulla directory della tua installazione JRE che desideri utilizzare per UIMA.
Imposta UIMA_HOME sulla directory apache-uima della tua distribuzione Apache UIMA decompressa
Aggiungi UIMA_HOME/bin al tuo PATH
Esegui lo script UIMA_HOME/bin/adjustExamplePaths.bat (o .sh), per aggiornare
i percorsi negli esempi in base al percorso effettivo della directory UIMA_HOME.
Questo script esegue un programma Java; devi avere java nel tuo PATH o impostare la variabile
d'ambiente JAVA_HOME su un JRE adatto.
Nota: Le procedure del sistema operativo Mac OS X per la configurazione delle variabili d'ambiente globali sono descritte qui: vedi http://developer.apple.com/qa/qa2001/qa1067.html.
Per testare l'installazione, esegui il file documentAnalyzer.bat (o .sh) situato nella sottodirectory bin.
Dovrebbe apparire una finestra Document Analyzer. Imposta i valori visualizzati in questa GUI come segue:
UIMA_HOME/examples/dataUIMA_HOME/examples/data/processedUIMA_HOME/examples/descriptors/analysis_engine/PersonTitleAnnotator.xmlSostituisci UIMA_HOME sopra con il percorso della tua installazione di Apache UIMA.
Successivamente, fai clic sul pulsante Run, che dopo una breve pausa dovrebbe far apparire una finestra Analyzed Results. Fai doppio clic su uno dei documenti per visualizzare i risultati dell'analisi per quel documento.
Ecco un elenco di diversi progetti noti che forniscono i loro strumenti di analisi come componenti UIMA o che incapsulano strumenti di analisi di terze parti come componenti UIMA:
Questo non è un elenco esaustivo. Se ritieni che un progetto particolare dovrebbe essere elencato qui, ti preghiamo di farcelo sapere. Puoi trovare altri ad esempio:
Apache UIMA Java SDK può essere utilizzato con qualsiasi linguaggio di programmazione basato sulla Java Virtual Machine, inclusi Java, Groovy, Scala e molti altri linguaggi.
L'interoperabilità con Python può essere ottenuta, ad esempio, tramite la libreria di terze parti DKPro Cassis che può essere utilizzata per leggere, manipolare e scrivere dati CAS nel formato XMI.
Apache UIMA Java SDK è un'implementazione basata su Java della specifica UIMA.
Indirizza le domande a [email protected].
Se utilizzi uimaFIT per supportare la ricerca accademica, ti preghiamo di considerare di citare il seguente articolo come appropriato:
@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}
}
Inizi anni 2000: UIMA è stato originariamente sviluppato da IBM come parte della ricerca sull'analisi di informazioni non strutturate (come testo, audio e video). È stato progettato per elaborare grandi volumi di dati non strutturati in modo scalabile, mirando ad applicazioni di elaborazione del linguaggio naturale (NLP).
2004: UIMA è stato reso open-source, consentendo un uso più ampio e contributi dall'esterno di IBM.
2006: Il progetto UIMA è stato accettato nell'Apache Incubator, avviando il processo formale per diventare un progetto Apache.
2008: UIMA è uscito dall'Apache Incubator ed è diventato un progetto Apache di primo livello, a significare la sua maturità e lo sviluppo attivo.
2009: È stato introdotto Apache UIMA-AS (Asynchronous Scaleout), consentendo l'elaborazione distribuita e asincrona delle pipeline UIMA.
2012: uimaFIT è stato contribuito al progetto Apache UIMA. Apache uimaFIT era precedentemente noto come uimaFIT, che a sua volta era precedentemente noto come UUTUC. Prima del suo contributo, era uno sforzo collaborativo tra il Center for Computational Pharmacology dell'Università del Colorado Denver, il Center for Computational Language and Education Research dell'Università del Colorado a Boulder e il laboratorio Ubiquitous Knowledge Processing (UKP) della Technische Universität Darmstadt.
2013: UIMA DUCC (Distributed UIMA Cluster Computing) è stato introdotto come sottoprogetto di Apache UIMA.
2016: Apache UIMA Ruta (Rule-based Text Annotation) è stato introdotto come estensione, fornendo un linguaggio di scripting per l'elaborazione testuale basata su regole.
2023: UIMA DUCC e UIMA-AS sono stati ritirati.
2024: uimaFIT è stato integrato nel UIMA Java SDK