Utiliser des modèles de langage tiers avec ArcGIS—ArcGIS Pro

Le jeu d’outils Analyse de texte de la boîte à outils GeoAI fournit un ensemble d’outils destinés aux tâches de traitement de texte, telles que la classification de texte, l’extraction d’entités et la traduction de texte. Les modèles de traitement du langage naturel (NLP) qui sont créés avec ces outils reposent sur des modèles de langage tels que BERT, RoBERTa et T5 et sur de grands modèles de langage (LLM), tels que Mistral pour assurer l’analyse de texte haute performance.

Même si ces modèles préconçus sont fiables, vous pouvez avoir besoin d’un processus NLP personnalisé, par exemple si vous utilisez un LLM pour standardiser des adresses, réaliser une analyse des sentiments ou extraire des entités ou relations personnalisées qui ne sont actuellement pas prises en charge par le jeu d’outils Analyse de texte. Pour répondre à ces besoins, vous pouvez intégrer des modèles de langage tiers externes à ArcGIS. Il s’agit de LLM Open Source comme de LLM commerciaux hébergés sur le Cloud qui sont accessibles à l’aide d’une API Web. N’oubliez pas que si vous utilisez un grand modèle de langage (LLM) hébergé sur le Web, les données que vous traitez sont envoyées au fournisseur du LLM pour être traitées. Les développeurs Python peuvent créer une fonction NLP personnalisée à intégrer à des modèles externes et empaqueter leur modèle en tant que paquetage de Deep Learning Esri (fichier .dlpk) pour l’utiliser avec les outils suivants :

Fonction NLP Python personnalisée

Vous pouvez créer une fonction NLP dans Python afin d’intégrer des modèles de langage tiers dans un pipeline de traitement de texte. Les fonctions NLP gèrent les données de texte et différentes tâches de traitement de texte.

Les méthodes de ces fonctions sont répertoriées dans la table suivante et sont décrites de façon plus complète dans les sous-sections ci-dessous.


Méthode	Description
__init__	Initialiser les variables d’instance, telles que name, description et d’autres attributs essentiels à la fonction NLP.
initialize	Charger le modèle NLP et configurer les configurations initiales. Utilisez cette méthode au début de la fonction NLP Python.
getParameterInfo	Définir les paramètres que la fonction NLP accepte. Cela inclut les paramètres de configuration requis pour charger ou se connecter au modèle, ainsi que les paramètres nécessaires au traitement de texte.
getConfiguration	Décrire la façon dont l’outil exécute le traitement des entrées et génère des sorties. Cela inclut les détails des étapes de prétraitement ou de post-traitement nécessaires à la fonction.
predict	Fonction chargée de convertir le texte en entrée en sortie souhaitée. Elle utilise des paramètres définis et une logique de traitement pour produire le résultat final.

Méthodes des fonctions

Les méthodes des fonctions NLP sont décrites ci-dessous.

init

La méthode __init__ est le constructeur de la fonction NLP personnalisée et initialise les variables d’instance, telles que le nom, la description et d’autres attributs essentiels. Cette méthode définit les propriétés qui définissent le comportement et les caractéristiques de la fonction NLP.

Le constructeur crée une instance d’une classe NLP personnalisée avec tous les attributs requis pour le traitement et l’analyse. Lors de la création d’une instance d’une classe NLP, cette méthode s’assure qu’elle dispose des paramètres et valeurs par défaut nécessaires. Par exemple, si la fonction NLP a besoin de paramètres spécifiques tels que des chemins d’accès aux modèles, ou de jetons spéciaux, ils peuvent être configurés dans cette méthode.

class MyTextClassifier:
    def __init__(self, **kwargs):
        """
        It sets up the initial state of an object by defining its attributes,
        such as name, description, and other properties.

        """
        self.name = "Text classifier"
        self.description = '''The `MyTextClassifier` class is designed to perform text classification tasks
                            such as categorizing text data into predefined categories.'''
        # Additional initialization code here
        ...

initialize

La méthode initialize est appelée au début de la fonction NLP Python personnalisée et l’argument kwargs['model'] est transmis à cette méthode. L’argument kwargs['model'] est le chemin d’accès au fichier de définition du modèle (.emd) Esri. La méthode doit être utilisée pour charger les pondérations du modèle et configurer le modèle NLP, ce qui garantit son référencement en cas d’opérations ultérieures.

def initialize(self, **kwargs):
    """
    Initialize model parameters, such as loading pretrained model weights.
    """
    json_file = kwargs['model']
    with open(json_file, 'r') as f:
        self.json_info = json.load(f)
    
    # access the model path in the model definition file
    model_path = json_info['ModelFile']
    # load your model and keep an instance for the model
    self.model = load_your_model(model_path)
    
    # Additional initialization code here
    ...

getParameterInfo

La méthode getParameterInfo est appelée par les outils Analyse de texte après la méthode initialize. C’est à ce stade que les paramètres requis par le modèle sont définis. Cette méthode renvoie une liste des paramètres en entrée attendus par la fonction NLP personnalisée. Chaque paramètre est décrit à l’aide d’un dictionnaire contenant le nom, le type de données, le nom d’affichage et la description du paramètre, ainsi que d’un paramètre booléen indiquant si le paramètre est obligatoire, comme illustré ci-dessous.

def getParameterInfo(self):
    return [
        {
            "name": "class_names",
            "dataType": "string",
            "required": True,
            "displayName": "class_names",
            "description": "Comma-separated list of class names used for classification.",
            "value": "positive,negative"
        },
        {
            "name": "prompt",
            "dataType": "string",
            "required": False,
            "displayName": "prompt",
            "description": "The number of samples processed in one forward pass through the model.",
            "value": "Classify the following text into the defined classes."
        },
        # Additional code here
        ...
    ]

La méthode renvoie une liste de dictionnaires, chacun décrivant un paramètre. Voici les attributs clés du dictionnaire :

name : identifiant de chaîne du paramètre
dataType : type de données que le paramètre accepte (chaîne, booléen ou liste, par exemple)
value : valeur par défaut du paramètre
required : valeur booléenne indiquant si le paramètre est obligatoire
displayName : nom convivial du paramètre
domain : ensemble de valeurs autorisées, le cas échéant
description : description détaillée du paramètre

L’utilisateur peut voir la liste des paramètres par l’intermédiaire des arguments du modèle personnalisé dans les outils Analyse de texte. Les utilisateurs du modèle peuvent définir ces valeurs de façon interactive à l’aide de l’interface utilisateur de l’outil ou les transmettre par programmation à la méthode getConfiguration en tant qu’arguments de mots-clés.

getConfiguration

La méthode getConfiguration configure et gère les paramètres de la fonction NLP. Les arguments de mots-clés contenant les paramètres mis à jour lui sont transmis par les utilisateurs du modèle via l’outil ou par programmation. La méthode contrôle également la façon dont la fonction traite et génère les données en fonction des paramètres mis à jour. Cette méthode est invoquée après la méthode getParameterInfo mais avant la méthode predict. La valeur renvoyée de la fonction est un dictionnaire contenant la valeur de batch_size qui indique le nombre de chaînes que le modèle peut traiter à la fois. La valeur renvoyée de la méthode indique à l’outil comment les données en entrée doivent être fractionnées afin d’être traitées par le modèle, un lot à la fois.

def getConfiguration(self, **kwargs):
    """
    This method configures the supported NLP function parameters and
    controls further processing based on them.
    """
    # Set the class names from the provided arguments
    self.class_names = kwargs.get("class_names", "")
    self.prompt = kwargs.get("prompt", "")
    # Set the batch size, limiting it to a maximum of 4
    if kwargs.get("batch_size", 0) > 4:
        kwargs["batch_size"] = 4
       
    # Additional code here
    ...
    
    # Return the updated parameter values
    return kwargs

Dans l’exemple ci-dessus, la fonction NLP personnalisée est configurée en procédant comme suit :

Configuration du paramètre class_names à partir des arguments fournis.
Configuration du paramètre prompt à partir des arguments fournis.
Limitation du paramètre batch_size à un maximum de 4 si une valeur supérieure est fournie.
Renvoi des valeurs des paramètres mis à jour.

predict

La méthode predict effectue une inférence, c’est-à-dire qu’elle génère des prévisions avec le modèle NLP. Un FeatureSet contenant les entités en entrée (ou des lignes dans le cas d’une table) et des kwargs contenant le nom de champ qui comporte les chaînes en entrée sont transmis à cette méthode. Cette méthode renvoie les résultats sous la forme d’un objet FeatureSet. Voici un processus classique :

Extrayez le texte en entrée à traiter du paramètre FeatureSet fourni et prétraitez-le pour qu’il réponde aux exigences du modèle.
Appliquez le modèle NLP au texte prétraité pour générer des prévisions.
Affichez ou formatez les prévisions du modèle comme vous le souhaitez.
Empaquetez les prévisions traitées dans un objet FeatureSet et renvoyez-le.

def predict(self, feature_set: FeatureSet, **kwargs):
    """
    Predicts the classification of text data from the input FeatureSet and returns a new FeatureSet with the predictions.
    """
    # read the text from the input Featureset, when calling this function from ArcGIS Pro tools, be sure to use the name of the column that contains the text data instead of `input_str`.
    field = kwargs["input_field"]
    input_text = feature_set.df[field].to_list() 
    # Preprocessing input code here
    # 
    ... 
    
    # Make Predictions
    results = self.model.predict(input_text, self.class_names, self.prompt)
    
    # Additional code here
    ... 
    
    # Create featureset
    feature_dict = {
        "fields": [
            {"name": "input_str", "type": "esriFieldTypeString"},
            {"name": "class", "type": "esriFieldTypeString"}
        ],
        'geometryType': "",
        'features': [{'attributes': {'input_str': inputs, "class": result}}]
    }
    
    # Return the featureset
    return FeatureSet.from_dict(feature_dict)

Fichier .emd Esri

Après avoir créé une fonction NLP Python personnalisée, incluez une référence à la fonction dans le fichier .emd en la spécifiant dans le paramètre InferenceFunction. Cela permet de garantir que le fichier .emd fait correctement référence à la fonction, ce qui facilite son utilisation dans un pipeline de traitement NLP.

{
    "InferenceFunction": "MyTextClassifier.py",
    "ModelType": "TextClassifier",
    "OutputField": "ClassLabel",
    "Labels": [
        "positive",
        "negative"
    ],


    # additional keys here
    ...
}

Remarque :

Le fichier .emd doit inclure les clés suivantes :

InferenceFunction : spécifiez le nom du fichier contenant la fonction NLP personnalisée.
ModelType : indiquez le type de modèle en fonction de sa tâche. Les valeurs prises en charge sont TextClassifier, SequenceToSequence et EntityRecognizer.
OutputField : fournissez le nom du champ en sortie destiné à stocker les résultats des modèles TextClassifier ou SequenceToSequence.

Fichier .dlpk personnalisé

Pour terminer une configuration NLP personnalisée, créez un fichier de modèle .dlpk. Le fichier .dlpk vous permet d’utiliser un modèle avec les outils d’inférence dans le jeu d’outils Analyse de texte.

Organisez les fichiers comme suit :

Créez un dossier et intégrez le fichier de la fonction NLP personnalisée (par exemple, MyTextClassifier.py) et le fichier Esri .emd (par exemple, TextClassifier.emd). Le nom du dossier doit correspondre à celui du fichier .emd.
```
TextClassifier/
├── MyTextClassifier.py
└── TextClassifier.emd
```
Ajoutez les fichiers ou dossiers supplémentaires nécessaires à la fonction NLP.
Compressez le dossier en archive ZIP. Renommez le fichier .zip pour qu’il corresponde au nom du fichier .emd mais avec l’extension .dlpk. Ce fichier .dlpk est maintenant prêt à être utilisé avec les outils d’inférence dans le jeu d’outils Analyse de texte.

Vous avez un commentaire à formuler concernant cette rubrique ?