Modèles d’apprentissage automatique traditionnels (à caractère expérimental)

Apprenez à utiliser Xinference pour inférer des modèles d’apprentissage automatique traditionnels. Dans Xinference, ces modèles flexibles et extensibles sont appelés modèles flexibles.

Ajouté dans la version v1.7.1: Cette fonctionnalité est publique depuis la version v1.7.1, mais l’API actuelle n’est pas encore stable et peut changer dans les itérations ultérieures.

Introduction

Les modèles d’apprentissage automatique traditionnels peuvent encore jouer un rôle important dans un écosystème centré sur les grands modèles.

Xinference offre des capacités d’extension flexibles pour l’inférence de modèles d’apprentissage automatique traditionnels. Il prend en charge nativement le chargement et l’exécution des types de modèles suivants :

• Utilisez le pipeline HuggingFace du modèle hébergé par HuggingFace, adapté aux tâches de classification, etc.

• Utilisez le pipeline ModelScope d’un modèle sur ModelScope pour des tâches comme la classification.

• YOLO est utilisé pour la détection d’images et les tâches connexes de vision par ordinateur.

Xinference prend en charge plusieurs modèles d’apprentissage automatique traditionnels. Pour chaque catégorie mentionnée ci-dessus, nous allons démontrer étape par étape comment effectuer des inférences sur la plateforme Xinference à l’aide d’un exemple représentatif.

Cas de support des modèles intégrés

Pipeline HuggingFace

Tout d’abord, prenons l’exemple de FacebookAI/roberta-large-mnli. Ce modèle est un modèle de classification zéro-shot. Pour les autres types de modèles, il suffit de spécifier la tâche correspondante (qui est aussi un paramètre de Pipeline) lors de l’enregistrement.

Téléchargez le modèle dans le chemin suivant :

/path/to/roberta-large-mnli

Ensuite, nous montrons comment enregistrer ce modèle flexible dans l’interface utilisateur Web de Xinference. Dans les exemples suivants, sauf si nécessaire, nous passerons les opérations d’interface et nous concentrerons sur la logique centrale.

Le fichier JSON du modèle personnalisé correspondant est le suivant :

{
    "model_name": "roberta-large-mnli",
    "model_id": null,
    "model_revision": null,
    "model_hub": "huggingface",
    "model_description": "roberta-large-mnli is the RoBERTa large model fine-tuned on the Multi-Genre Natural Language Inference (MNLI) corpus. The model is a pretrained model on English language text using a masked language modeling (MLM) objective.",
    "model_uri": "/path/to/roberta-large-mnli",
    "launcher": "xinference.model.flexible.launchers.transformers",
    "launcher_args": "{\"task\": \"zero-shot-classification\"}",
    "virtualenv": {
        "packages": [],
        "inherit_pip_config": true,
        "index_url": null,
        "extra_index_url": null,
        "find_links": null,
        "trusted_host": null,
        "no_build_isolation": null
    },
    "is_builtin": false
}

Voir le chapitre register_custom_model pour savoir comment enregistrer un modèle via le code ou la ligne de commande.

Ensuite, dans l’interface Web, sélectionnez Démarrer le modèle / Modèle personnalisé / Modèle flexible pour charger le modèle. Le processus de chargement est le même que pour les autres types de modèles.

Lorsque vous utilisez la ligne de commande, n’oubliez pas de spécifier le paramètre --model-type flexible.

Une fois le modèle chargé avec succès, nous pouvons procéder à l’inférence de la manière suivante.

cURLXinference Python Clientoutput

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/flexible/infers' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "roberta-large-mnli",
    "args": [
      "one day I will see the world",
      ["travel", "cooking", "dancing"]
    ]
  }'

Modèle Pipeline ModelScope

Les modèles Pipeline de ModelScope sont très similaires aux modèles Huggingface, la seule différence réside dans le lanceur utilisé.

Prenons l’exemple d’un modèle de classification zéro-shot sur ModelScope. Le modèle est iic/nlp_structbert_zero-shot-classification_chinese-base.

Nous utilisons ici la fonctionnalité d’environnement virtuel de modèle de Xinference. Comme le modèle utilisé dans cet exemple nécessite transformers==4.50.3 pour fonctionner correctement, afin d’isoler l’environnement d’exécution, nous avons utilisé l’environnement virtuel lors de l’enregistrement du modèle.

La syntaxe pour spécifier un package personnalisé lors de l’enregistrement d’un modèle est la même que pour un package ordinaire, mais il existe quelques cas particuliers. Étant donné que l’environnement virtuel est toujours basé sur les site-packages de l’interpréteur Python exécuté par Xinference, nous devons explicitement inclure #system_numpy#. Le nom du package est entouré de #system_xx# pour garantir que l’environnement virtuel créé soit cohérent avec l’environnement de base, sinon cela peut facilement entraîner des erreurs d’exécution.

Méthode d’inscription (interface utilisateur web) :

Fichier JSON correspondant :

{
    "model_name": "nlp_structbert_zero-shot-classification_chinese-base",
    "model_id": null,
    "model_revision": null,
    "model_hub": "huggingface",
    "model_description": "This is a model description.",
    "model_uri": "/Users/xuyeqin/Downloads/models/nlp_structbert_zero-shot-classification_chinese-base",
    "launcher": "xinference.model.flexible.launchers.modelscope",
    "launcher_args": "{\"task\": \"zero-shot-classification\"}",
    "virtualenv": {
        "packages": [
            "transformers==4.50.3",
            "#system_numpy#"
        ],
        "inherit_pip_config": true,
        "index_url": "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple",
        "extra_index_url": null,
        "find_links": null,
        "trusted_host": null,
        "no_build_isolation": null
    },
    "is_builtin": false
}

Inférence de modèle

cURLXinference Python Clientoutput

curl -X 'POST' \
  'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/flexible/infers' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "nlp_structbert_zero-shot-classification_chinese-base",
    "args": [
      "世界那么大，我想去看看"
    ],
    "candidate_labels": ["家居", "旅游", "科技", "军事", "游戏", "故事"]
  }'

YOLO

YOLO est un modèle de détection d’objets en temps réel populaire, largement utilisé dans les scénarios de détection d’images et d’analyse vidéo.

Tout d’abord, téléchargez les poids YOLO. Ici, nous prenons comme exemple le fichier yolov11s.pt.

Fichier JSON de définition du modèle :

{
    "model_name": "yolo11s",
    "model_id": null,
    "model_revision": null,
    "model_hub": "huggingface",
    "model_description": "YOLO is a popular real-time object detection model, widely used in image detection and video analysis scenarios.",
    "model_uri": "/Users/xuyeqin/Downloads/models/yolo11s.pt",
    "launcher": "xinference.model.flexible.launchers.yolo",
    "launcher_args": "{}",
    "virtualenv": {
        "packages": [
            "ultralytics",
            "#system_numpy#"
        ],
        "inherit_pip_config": true,
        "index_url": "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple",
        "extra_index_url": null,
        "find_links": null,
        "trusted_host": null,
        "no_build_isolation": null
    },
    "is_builtin": false
}

Inférence de modèle

Xinference Python Clientoutput

import requests
from PIL import Image
import io
import base64
from xinference.client import Client

client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("yolo11s")

url = "https://ultralytics.com/images/bus.jpg"

response = requests.get(url)
response.raise_for_status()

img = Image.open(io.BytesIO(response.content))

buffered = io.BytesIO()
img.save(buffered, format="JPEG")
img_bytes = buffered.getvalue()
img_base64 = base64.b64encode(img_bytes).decode('utf-8')

model.infer(source=img_base64)

Écrire un modèle flexible personnalisé

Tout d’abord, nous avons implémenté un simple lanceur personnalisé pour la notation des sentiments. Dans cet exemple, nous n’utilisons aucun poids de modèle réel, donc la fonction load n’effectue aucune opération de chargement de modèle.

# my_flexible_model.py

from xinference.model.flexible import FlexibleModel


class RuleBasedSentimentModel(FlexibleModel):
    def load(self):
        self.pos_words = self.config.get("pos", ["good", "happy", "great"])
        self.neg_words = self.config.get("neg", ["bad", "sad", "terrible"])

    def infer(self, text: str):
        score = 0
        words = text.lower().split()
        for w in words:
            if w in self.pos_words:
                score += 1
            elif w in self.neg_words:
                score -= 1
        return {"score": score}


def launcher(model_uid: str, model_spec: FlexibleModel, **kwargs) -> FlexibleModel:
    # get model path,
    # in this example, we do not use it, so it's empty
    model_path = model_spec.model_uri
    return RuleBasedSentimentModel(model_uid=model_uid, model_path=model_path, config=kwargs)

La définition du modèle JSON est la suivante :

{
    "model_name": "my-flexible-model",
    "model_id": null,
    "model_revision": null,
    "model_hub": "huggingface",
    "model_description": "This is a model description.",
    "model_uri": "/path/to/model",
    "launcher": "my_flexible_model.launcher",
    "launcher_args": "{\"pos\": [\"good\", \"happy\", \"great\", \"nice\"]}",
    "virtualenv": {
        "packages": [],
        "inherit_pip_config": true,
        "index_url": null,
        "extra_index_url": null,
        "find_links": null,
        "trusted_host": null,
        "no_build_isolation": null
    },
    "is_builtin": false
}

Nous avons étendu le modèle en passant une valeur personnalisée de pos.

Enfin, vérifions le résultat :

Xinference Python Clientoutput

from xinference.client import Client

client = Client("http://127.0.0.1:9997")

model = client.get_model("my-flexible-model")

model.infer("I feel nice and am happy today")

Conclusion

Le lanceur de modèle flexible intégré à Xinference se trouve sur Github. N’hésitez pas à contribuer pour ajouter le support de davantage de modèles d’apprentissage automatique traditionnels !