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][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 JAVA_HOME per individuare il Java da usare; se non è impostata, invocano java aspettandosi di trovare un Java appropriato nella variabile PATH.
Puoi aggiungere Apache UIMA Java SDK al tuo progetto facilmente nella maggior parte degli strumenti di build importandolo da [Maven Central][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());
}