shoucheng3/apache__uima-uimaj_cve-2022-32287_3-3-0SDK Java pour construire des pipelines d'analyse qui traitent et enrichissent des données textuelles non structurées avec des annotations, des systèmes de types et des moteurs d'analyse modulaires.
Apache UIMA vous aide à gérer les données non structurées (comme les textes) qui sont enrichies d'informations utiles. Par exemple, si vous souhaitez identifier une mention d'une entité dans un texte ou éventuellement lier cette entité à un jeu de données de référence, Apache UIMA fournit :
Notez que le SDK Java Apache UIMA fournit uniquement un cadre pour la construction d'analytiques, mais ne fournit aucune analytique en soi. Cependant, divers tiers s'appuient sur Apache UIMA et proposent des collections de composants d'analyse ou des solutions prêtes à l'emploi.
Apache UIMA v3.6.0 et versions ultérieures nécessite Java 17 ou version ultérieure.
L'exécution du plugin Eclipse pour UIMA nécessite de démarrer Eclipse 4.25 (2022-09) ou ultérieur avec Java 17 ou version ultérieure.
L'exécution de l'outil de migration sur les fichiers de classe nécessite l'utilisation d'un JDK Java, pas d'un JRE Java.
Les plateformes prises en charge sont : Windows, Linux et macOS. D'autres implémentations de la plateforme Java devraient fonctionner mais n'ont pas été testées de manière significative.
La plupart des scripts du répertoire invoquent Java. Ils utilisent la valeur de la variable d'environnement pour localiser le Java à utiliser ; si elle n'est pas définie, ils invoquent en s'attendant à trouver un Java approprié dans votre variable .
/binJAVA_HOMEjavaPATHVous pouvez facilement ajouter le SDK Java Apache UIMA à votre projet dans la plupart des outils de construction en l'important depuis Maven Central. Par exemple, si vous utilisez Maven, vous pouvez ajouter la dépendance suivante à votre projet :
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimaj-core</artifactId>
<version>3.6.0</version>
</dependency>
Ensuite, nous donnons quelques brefs exemples d'utilisation du SDK Java Apache UIMA et de la bibliothèque Apache uimaFIT. Apache uimaFIT est une dépendance distincte que vous pouvez ajouter :
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimafit-core</artifactId>
<version>3.6.0</version>
</dependency>
Le système de types définit le type d'informations que nous souhaitons attacher aux informations non structurées (ici un document texte). Dans notre exemple, nous voulons identifier les mentions d'entités, nous définissons donc un type my.Entity avec une caractéristique category qui peut être utilisée pour stocker la catégorie à laquelle appartient l'entité.
Pour illustrer les informations qu'UIMA maintient en interne sur le schéma d'annotation, nous écrivons le schéma généré au format XML à l'écran.
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);
Maintenant, nous créons un objet Common Analysis Structure (CAS) dans lequel nous stockons le texte que nous souhaitons analyser.
Encore une fois, pour illustrer les informations qu'UIMA stocke en interne dans l'objet CAS, nous écrivons une représentation XML de l'objet à l'écran.
var cas = CasFactory.createCas(tsd);
cas.setDocumentText("Welcome to Apache UIMA.");
cas.setDocumentLanguage("en");
CasIOUtils.save(cas, System.out, SerialFormat.XMI_PRETTY);
Maintenant, nous créons une annotation de type my.Entity pour identifier la mention de Apache UIMA dans le texte d'exemple.
Enfin, nous parcourons toutes les annotations dans la CAS et les affichons à l'écran. Cela inclut la DocumentAnnotation par défaut qui est toujours créée par UIMA ainsi que l'annotation my.Entity que nous avons créée nous-mêmes.
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());
}
Afin d'organiser différents types d'analyse en étapes, nous les regroupons généralement dans des moteurs d'analyse individuels. Nous illustrons maintenant comment de tels composants peuvent être construits et comment ils peuvent être exécutés en tant que pipeline d'analyse.
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 configuration des composants UIMA se fait généralement en créant des fichiers descripteurs XML qui indiquent au framework au moment de l'exécution comment les composants doivent être instanciés et déployés. Ces fichiers descripteurs XML sont très étroitement liés à l'implémentation Java des composants qu'ils décrivent. Nous avons constaté qu'il est très difficile de maintenir les deux cohérents, surtout lorsque le remaniement du code est très fréquent. uimaFIT fournit des annotations Java pour décrire les composants UIMA, qui peuvent être utilisées pour décrire directement les composants UIMA dans le code. Cela simplifie grandement le remaniement d'une définition de composant (par exemple, changer le nom d'un paramètre de configuration). Cela permet également de générer des fichiers descripteurs XML dans le cadre du cycle de construction plutôt que de les effectuer manuellement en parallèle avec la création du code. uimaFIT facilite également l'instanciation de composants UIMA sans utiliser de fichiers descripteurs XML en fournissant un certain nombre de méthodes d'usine pratiques qui permettent l'instanciation programmatique/dynamique des composants UIMA. Cela fait d'uimaFIT une bibliothèque idéale pour tester les composants UIMA car le composant peut être facilement instancié et invoqué sans qu'il soit nécessaire de créer d'abord un fichier descripteur. uimaFIT est également utile dans les environnements de recherche où l'instanciation programmatique/dynamique d'un pipeline peut simplifier les expérimentations. Par exemple, lors de la réalisation d'une validation croisée à 10 plis sur un certain nombre de conditions expérimentales, il peut être très laborieux de créer un ensemble différent de fichiers descripteurs pour chaque exécution ou même un script qui génère ces fichiers descripteurs. uimaFIT est indépendant du système de types et ne dépend pas (ni ne fournit) d'un système de types spécifique.
uimaFIT est une bibliothèque qui fournit des usines, l'injection et des utilitaires de test pour UIMA. La liste suivante met en évidence certaines des fonctionnalités qu'uimaFIT propose :
Usines : simplifient l'instanciation programmatique des composants UIMA sans fichiers descripteurs. Par exemple, pour instancier un AnalysisEngine, on pourrait faire un appel comme celui-ci :
AnalysisEngineFactory.createEngine(MyAEImpl.class, myTypeSystem,
paramName1, paramValue2,
paramName2, paramValue2,
...)
Injection : gère la liaison des valeurs des paramètres de configuration aux variables membres correspondantes dans les moteurs d'analyse et gère la liaison des ressources externes. Par exemple, pour lier un paramètre de configuration, il suffit d'annoter une variable membre avec @ConfigurationParameter. Les ressources externes peuvent également être injectées via l'annotation @ExternalResource. Ajoutez ensuite une ligne de code à votre méthode d'initialisation :
ConfigurationParameterInitializer.initialize(this, uimaContext).
Ceci est géré automatiquement si vous étendez la classe uimaFIT JCasAnnotator_ImplBase.
Test : uimaFIT simplifie les tests de plusieurs manières décrites dans la documentation. En rendant facile l'instanciation de vos composants sans fichiers descripteurs, une grande quantité de XML difficile à maintenir et inutile peut être éliminée de votre code de test. Cela rend les tests plus faciles à écrire et à maintenir. De plus, l'exécution de composants en tant que pipeline peut être réalisée avec un appel de méthode comme celui-ci :
SimplePipeline.runPipeline(reader, ae1, ..., aeN, consumer1, ... consumerN)
uimaFIT fait partie du projet Apache UIMA(TM). uimaFIT ne peut être utilisé qu'avec une version compatible de la version Java du SDK Apache UIMA. Pour votre commodité, le package de distribution binaire d'uimaFIT inclut toutes les bibliothèques nécessaires à l'utilisation d'uimaFIT. En particulier pour les utilisateurs novices, il est fortement conseillé d'obtenir une copie du SDK UIMA complet séparément.
uimaFIT est disponible via Maven Central. Si vous utilisez Maven pour votre environnement de construction, vous pouvez ajouter uimaFIT comme dépendance à votre fichier pom.xml avec ce qui suit :
<dependencies>
<dependency>
<groupId>org.apache.uima</groupId>
<artifactId>uimafit-core</artifactId>
<version>3.6.0</version>
</dependency>
</dependencies>
Modules
Pour construire Apache UIMA, vous avez besoin d'au moins un JDK Java 17 et d'une version récente de Maven 3.
Après avoir extrait la distribution source ZIP ou cloné le dépôt, placez-vous dans le répertoire créé et exécutez la commande suivante :
mvn clean install
Pour plus de détails, veuillez consulter http://uima.apache.org/building-uima.html
Vous pouvez télécharger les distributions source et binaire depuis le site Web Apache UIMA.
Après avoir décompressé la distribution Apache UIMA à partir du package de votre choix (par exemple .zip ou .gz), suivez les étapes ci-dessous pour configurer UIMA afin qu'il fonctionne correctement.
Définissez JAVA_HOME sur le répertoire de votre installation JRE que vous souhaitez utiliser pour UIMA.
Définissez UIMA_HOME sur le répertoire apache-uima de votre distribution Apache UIMA décompressée.
Ajoutez UIMA_HOME/bin à votre PATH.
Veuillez exécuter le script UIMA_HOME/bin/adjustExamplePaths.bat (ou .sh) pour mettre à jour les chemins dans les exemples en fonction du chemin réel du répertoire UIMA_HOME. Ce script exécute un programme Java ; vous devez avoir java dans votre PATH ou définir la variable d'environnement JAVA_HOME sur un JRE approprié.
Remarque : Les procédures du système d'exploitation Mac OS X pour configurer les variables d'environnement globales sont décrites ici : voir http://developer.apple.com/qa/qa2001/qa1067.html.
Pour tester l'installation, exécutez le fichier documentAnalyzer.bat (ou .sh) situé dans le sous-répertoire bin. Cela devrait faire apparaître une fenêtre Document Analyzer. Définissez les valeurs affichées dans cette interface graphique comme suit :
UIMA_HOME/examples/dataUIMA_HOME/examples/data/processedUIMA_HOME/examples/descriptors/analysis_engine/PersonTitleAnnotator.xmlRemplacez UIMA_HOME ci-dessus par le chemin de votre installation Apache UIMA.
Ensuite, cliquez sur le bouton Run, ce qui devrait, après une brève pause, faire apparaître une fenêtre Analyzed Results. Double-cliquez sur l'un des documents pour afficher les résultats d'analyse pour ce document.
Voici une liste de plusieurs projets bien connus qui fournissent leurs outils d'analyse en tant que composants UIMA ou qui encapsulent des outils d'analyse tiers en tant que composants UIMA :
Cette liste n'est pas exhaustive. Si vous pensez qu'un projet particulier devrait figurer ici, veuillez nous en informer. Vous pouvez en trouver d'autres par exemple en :
Le SDK Java Apache UIMA peut être utilisé avec tout langage de programmation basé sur la machine virtuelle Java, y compris Java, Groovy, Scala, et bien d'autres langages.
L'interopérabilité avec Python peut par exemple être réalisée via la bibliothèque tierce DKPro Cassis qui peut être utilisée pour lire, manipuler et écrire des données CAS au format XMI.
Le SDK Java Apache UIMA est une implémentation Java de la spécification UIMA.
Veuillez adresser vos questions à [email protected].
Si vous utilisez uimaFIT pour soutenir la recherche académique, veuillez envisager de citer l'article suivant comme approprié :
@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}
}
Début des années 2000 : UIMA a été initialement développé par IBM dans le cadre de recherches sur l'analyse d'informations non structurées (comme le texte, l'audio et la vidéo). Il a été conçu pour traiter de grands volumes de données non structurées de manière évolutive, ciblant les applications de traitement du langage naturel (NLP).
2004 : UIMA a été rendu open source, permettant une utilisation plus large et des contributions extérieures à IBM.
2006 : Le projet UIMA a été accepté dans l'Apache Incubator, marquant le début du processus formel pour devenir un projet Apache.
2008 : UIMA a obtenu son diplôme de l'Apache Incubator et est devenu un projet Apache de premier niveau, signifiant sa maturité et son développement actif.
2009 : Apache UIMA-AS (Asynchronous Scaleout) a été introduit, permettant le traitement distribué et asynchrone des pipelines UIMA.
2012 : uimaFIT a été contribué au projet Apache UIMA. Apache uimaFIT était auparavant connu sous le nom d'uimaFIT, qui lui-même était auparavant connu sous le nom d'UUTUC. Avant sa contribution, il s'agissait d'un effort collaboratif entre le Center for Computational Pharmacology de l'Université du Colorado à Denver, le Center for Computational Language and Education Research de l'Université du Colorado à Boulder, et le laboratoire Ubiquitous Knowledge Processing (UKP) à la Technische Universität Darmstadt.
2013 : UIMA DUCC (Distributed UIMA Cluster Computing) a été introduit en tant que sous-projet d'Apache UIMA.
2016 : Apache UIMA Ruta (Rule-based Text Annotation) a été introduit en tant qu'extension, fournissant un langage de script pour le traitement de texte basé sur des règles.
2023 : UIMA DUCC et UIMA-AS ont été retirés.
2024 : uimaFIT a été fusionné dans le SDK Java UIMA