Servir plusieurs modèles vers un point de terminaison de service de modèle

Article
11/02/2024

Cet article explique comment configurer par programmation un point de terminaison de service de modèle pour servir plusieurs modèles et le trafic partagé entre eux.

Le service de plusieurs modèles à partir d’un seul point de terminaison vous permet de fractionner le trafic entre différents modèles pour comparer leurs performances et faciliter les tests A/B. Vous pouvez également servir différentes versions d’un modèle en même temps, ce qui facilite l’expérimentation de nouvelles versions, tout en conservant la version actuelle en production.

Vous pouvez traiter l’un des types de modèles suivants sur un point de terminaison mosaïque AI Model Serving. Vous ne pouvez pas servir différents types de modèles dans un point de terminaison unique. Par exemple, vous ne pouvez pas servir un modèle personnalisé et un modèle externe dans le même point de terminaison.

Modèles personnalisés
Modèles IA génératifs mis à disposition via le débit provisionné des API Foundation Model
Modèles externes

Spécifications

Consultez la configuration requise pour la création de points de terminaison de service de modèle.

Pour comprendre les options de contrôle d’accès pour les points de terminaison de service de modèle et les conseils sur les meilleures pratiques pour la gestion des points de terminaison, consultez Mise en service des listes de contrôle d’accès des point de terminaison.

Créer un point de terminaison et définir le fractionnement initial du trafic

Lorsque vous créez des points de terminaison de service de modèle à l’aide de l’API de service Databricks Mosaïque ou de l’interface utilisateur de service d’IA Databricks Mosaïque, vous pouvez également définir le trafic initial fractionné pour les modèles que vous souhaitez servir sur ce point de terminaison. Les sections suivantes fournissent des exemples de définition du fractionnement du trafic pour plusieurs modèles personnalisés ou modèles IA génératifs servis sur un point de terminaison.

Servir plusieurs modèles personnalisés à un point de terminaison

L’exemple d’API REST suivant crée un point de terminaison unique avec deux modèles personnalisés dans le catalogue Unity et définit le trafic de point de terminaison divisé entre ces modèles. L’entité servie, currentles hôtes version 1 et model-A obtient 90 % du trafic de point de terminaison, tandis que l’autre entité servie, les challengerhôtes version 1 de model-B et obtient 10 % du trafic de point de terminaison.

POST /api/2.0/serving-endpoints

{
   "name":"multi-model"
   "config":
   {
      "served_entities":
      [
         {
            "name":"current",
            "entity_name":"catalog.schema.model-A",
            "entity_version":"1",
            "workload_size":"Small",
            "scale_to_zero_enabled":true
         },
         {
            "name":"challenger",
            "entity_name":"catalog.schema.model-B",
            "entity_version":"1",
            "workload_size":"Small",
            "scale_to_zero_enabled":true
         }
      ],
      "traffic_config":
      {
         "routes":
         [
            {
               "served_model_name":"current",
               "traffic_percentage":"90"
            },
            {
               "served_model_name":"challenger",
               "traffic_percentage":"10"
            }
         ]
      }
   }
}

Servir plusieurs modèles à un point de terminaison de débit provisionné

L’exemple d’API REST suivant crée un point de terminaison de débit provisionné d’API Model Foundation unique avec deux modèles et définit le trafic de point de terminaison divisé entre ces modèles. Le point de terminaison nommé multi-pt-model, héberge la version 2 mistral_7b_instruct_v0_1-2 , dont 60 % du trafic de point de terminaison, et héberge également la version 3, mixtral_8x7b_instruct_v0_1-3 dont 40 % du trafic de point de terminaison.


POST /api/2.0/serving-endpoints
{
   "name":"multi-pt-model"
   "config":
   {
      "served_entities":
      [
         {
            "name":"mistral_7b_instruct_v0_1-2",
            "entity_name":"system.ai.mistral_7b_instruct_v0_1",
            "entity_version":"2",
            "min_provisioned_throughput":0,
            "max_provisioned_throughput":1940
         },
         {
            "name":"mixtral_8x7b_instruct_v0_1-3",
            "entity_name":"system.ai.mixtral_8x7b_instruct_v0_1",
            "entity_version":"3",
            "min_provisioned_throughput":0,
            "max_provisioned_throughput":1240
         }
      ],
      "traffic_config":
      {
         "routes":
         [
            {
               "served_model_name":"mistral_7b_instruct_v0_1-2",
               "traffic_percentage":"60"
            },
            {
               "served_model_name":"mixtral_8x7b_instruct_v0_1-3",
               "traffic_percentage":"40"
            }
         ]
      }
   }
}

Servir plusieurs modèles externes à un point de terminaison

Vous pouvez également configurer plusieurs modèles externes dans un point de terminaison de service tant qu’ils ont tous le même type de tâche et que chaque modèle a un modèle unique name. Vous ne pouvez pas avoir à la fois des modèles externes et des modèles non externes dans le même point de terminaison de service.

L’exemple suivant crée un point de terminaison de service qui route 50 % du trafic fourni gpt-4 par OpenAI et les 50 % restants à claude-3-opus-20240229 fournir par Anthropic.

import mlflow.deployments

client = mlflow.deployments.get_deploy_client("databricks")

client.create_endpoint(
    name="mix-chat-endpoint",
    config={
        "served_entities": [
            {
                "name": "served_model_name_1",
                "external_model": {
                    "name": "gpt-4",
                    "provider": "openai",
                    "task": "llm/v1/chat",
                    "openai_config": {
                        "openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}"
                    }
                }
            },
            {
                "name": "served_model_name_2",
                "external_model": {
                    "name": "claude-3-opus-20240229",
                    "provider": "anthropic",
                    "task": "llm/v1/chat",
                    "anthropic_config": {
                        "anthropic_api_key": "{{secrets/my_anthropic_secret_scope/anthropic_api_key}}"
                    }
                }
            }
        ],
        "traffic_config": {
            "routes": [
                {"served_model_name": "served_model_name_1", "traffic_percentage": 50},
                {"served_model_name": "served_model_name_2", "traffic_percentage": 50}
            ]
        },
    }
)

Mettre à jour le trafic fractionné entre les modèles servis

Vous pouvez également mettre à jour le trafic fractionné entre les modèles servis. L’exemple d’API REST suivant définit le modèle servi, currentpour obtenir 50 % du trafic de point de terminaison et l’autre modèle, challengerpour obtenir les 50 % restants du trafic.

Vous pouvez également effectuer cette mise à jour à partir de l’onglet Service dans l’interface utilisateur de Databricks Mosaic AI à l’aide du bouton Modifier la configuration.

PUT /api/2.0/serving-endpoints/{name}/config

{
   "served_entities":
   [
      {
         "name":"current",
         "entity_name":"catalog.schema.model-A",
         "entity_version":"1",
         "workload_size":"Small",
         "scale_to_zero_enabled":true
      },
      {
         "name":"challenger",
         "entity_name":"catalog.schema.model-B",
         "entity_version":"1",
         "workload_size":"Small",
         "scale_to_zero_enabled":true
      }
   ],
   "traffic_config":
   {
      "routes":
      [
         {
            "served_model_name":"current",
            "traffic_percentage":"50"
         },
         {
            "served_model_name":"challenger",
            "traffic_percentage":"50"
         }
      ]
   }
}

Interroger des modèles individuels derrière un point de terminaison

Dans certains scénarios, vous pouvez interroger des modèles individuels derrière le point de terminaison.

Pour cela, vous pouvez utiliser :

POST /serving-endpoints/{endpoint-name}/served-models/{served-model-name}/invocations

Ici, le modèle servi spécifique est interrogé. Le format de requête est identique à l’interrogation du point de terminaison. Lors de l’interrogation du modèle servi individuel, les paramètres de trafic sont ignorés.

Dans le contexte de l’exemple multi-model de point de terminaison, si toutes les requêtes sont envoyées à /serving-endpoints/multi-model/served-models/challenger/invocations, toutes les requêtes sont traitées par le modèle servi challenger.

Partager via