Modèles externes dans le service de modèles Mosaic AI

Article
11/18/2024

Important

Les exemples de code de cet article démontrent l’utilisation de l’API CRUD des déploiements de MLflow de la préversion publique.

Cet article décrit les modèles externes dans le service de modèles Mosaic AI, y compris les fournisseurs de modèles pris en charge et les limitations.

Quels sont les modèles externes ?

Important

Vous pouvez désormais configurer Mosaic AI Gateway sur des points de terminaison de service de modèles qui servent des modèles externes. AI Gateway assure la gouvernance, la surveillance et la préparation à la mise en production à ces points de terminaison de service de modèles. Consultez Mosaic AI Gateway.

Les modèles externes sont des modèles tiers hébergés à l’extérieur de Databricks. Pris en charge par le Service de modèle, les modèles externes vous permettent de rationaliser l’utilisation et la gestion de divers fournisseurs de grands modèles de langage (LLM), tels qu’OpenAI et Anthropic, au sein d’une organisation. Vous pouvez également utiliser le service de modèles Mosaic AI en tant que fournisseur pour servir des modèles personnalisés, ce qui offre des limites de débit pour ces points finaux. Dans le cadre de ce soutien, le Service de modèle offre une interface de haut niveau qui simplifie l’interaction avec ces services en fournissant un point de terminaison unifié pour traiter les demandes spécifiques liées au LLM.

En outre, la prise en charge des modèles externes par Azure Databricks permet une gestion centralisée des informations d’identification. En stockant les clés d’API dans un seul endroit sécurisé, les entreprises peuvent améliorer leur sécurité en minimisant l’exposition des clés d’API sensibles dans l’ensemble du système. Il permet également d’éviter d’exposer ces clés dans le code ou d’exiger des utilisateurs finaux qu’ils gèrent les clés en toute sécurité.

Consultez Tutoriel : créer des points de terminaison de modèle externe pour interroger des modèles OpenAI pour obtenir des conseils étape par étape sur la création de points de terminaison de modèle externe et l’interrogation des modèles pris en charge servis par ces points de terminaison à l’aide du kit de développement logiciel (SDK) des déploiements MLflow. Consultez les guides suivants pour obtenir des instructions sur l’utilisation de l’interface utilisateur de mise en service et de l’API REST :

Exigences

Champs de clé API ou d’authentification pour le fournisseur de modèles.
Espace de travail Databricks dans les régions prises en charge des modèles externes.

Fournisseurs de modèle

Les modèles externes dans Model Serving sont conçus pour prendre en charge une variété de fournisseurs de modèles. Un fournisseur représente la source des modèles Machine Learning, comme OpenAI, Anthropic, etc. Chaque fournisseur a ses caractéristiques et configurations spécifiques qui sont encapsulées dans le external_model champ du modèle externe de configuration du point de terminaison.

Les fournisseurs suivants sont pris en charge :

openai : pour les modèles proposés par openAI et les intégrations Azure pour Azure OpenAI et Azure OpenAI avec AAD.
anthropic : pour les modèles proposés par Anthropic.
cohere : pour les modèles proposés par Cohere.
amazon-bedrock : pour les modèles proposés par Amazon Bedrock.
google-cloud-vertex-ai : pour les modèles proposés par Google Cloud Vertex AI.
databricks-model-service : pour les points de terminaison du service de modèles Mosaic AI avec des schémas compatibles. Afficher Configuration du point de terminaison.

Pour demander le support d’un fournisseur non répertorié ici, contactez votre équipe de compte Databricks.

Modèles pris en charge

Le modèle que vous choisissez affecte directement les résultats des réponses que vous obtenez à partir des appels d’API. Par conséquent, choisissez un modèle qui répond à vos besoins en cas d’utilisation. Par exemple, pour générer des réponses conversationnelles, vous pouvez choisir un modèle de conversation. À l’inverse, pour générer des incorporations de texte, vous pouvez choisir un modèle d’incorporation.

Le tableau ci-dessous présente une liste non exhaustive des modèles pris en charge et des types de points de terminaison correspondants. Les associations de modèles énumérées ci-dessous peuvent servir de guide utile lors de la configuration d’un point de terminaison pour tout nouveau type de modèle disponible auprès d’un fournisseur donné. Les clients sont tenus de d’assurer de leur conformité vis-à-vis des licences de modèle applicables.

Remarque

Avec le développement rapide des machines virtuelles locales, il n’existe aucune garantie que cette liste soit à jour à tout moment.

Fournisseur de modèles	llm/v1/completions	llm/v1/chat	llm/v1/embeddings
OpenAI**	- gpt-3.5-turbo-instruct - babbage-002 - davinci-002	- o1-preview - o1-preview-2024-09-12 - o1-mini - o1-mini-2024-09-12 - gpt-3.5-turbo - gpt-4 - gpt-4o - gpt-4o-2024-05-13 - gpt-4o-mini - gpt-3.5-turbo-0125 - gpt-3.5-turbo-1106 - gpt-4-0125-preview - gpt-4-turbo-preview - gpt-4-1106-preview	- text-embedding-ada-002 - text-embedding-3-large - text-embedding-3-small
Azure OpenAI**	- text-davinci-003 - gpt-35-turbo-instruct	- gpt-35-turbo - gpt-35-turbo-16k - gpt-4 - gpt-4-32k - gpt-4o - gpt-4o-mini	- text-embedding-ada-002 - text-embedding-3-large - text-embedding-3-small
Anthropic	- claude-1 - claude-1.3-100k - claude-2 - claude-2.1 - claude-2.0 - claude-instant-1.2	- claude-3-5-sonnet-20240620 - claude-3-haiku-20240307 - claude-3-opus-20240229 - claude-3-sonnet-20240229 - claude-2.1 - claude-2.0 - claude-instant-1.2
Cohere**	- command - command-light	- command-r-plus - command-r - command - command-light-nightly - command-light - command-nightly	- embed-english-v2.0 - embed-multilingual-v2.0 - embed-english-light-v2.0 - embed-english-v3.0 - embed-english-light-v3.0 - embed-multilingual-v3.0 - embed-multilingual-light-v3.0
Service de modèles Mosaic AI	Point de terminaison de service Databricks	Point de terminaison de service Databricks	Point de terminaison de service Databricks
Amazon Bedrock	Anthropic : - claude-instant-v1 - claude-v2 Cohere : - command-text-v14 - command-light-text-v14 AI21 Labs : - j2-grande-instruct - j2-jumbo-instruct - j2-mid - j2-mid-v1 - j2-ultra - j2-ultra-v1	Anthropic : - claude-v2 - claude-v2:1 - claude-3-sonnet-20240229-v1:0 - claude-3-5-sonnet-20240620-v1:0 Cohere : - command-r-plus-v1:0 - command-r-v1:0	Amazon : - titan-embed-text-v1 - titan-embed-g1-text-02 Cohere : - embed-english-v3 - embed-multilingual-v3
AI21 Labs†	- j2-mid - j2-light - j2-ultra
Google Cloud Vertex AI	text-bison	- chat-bison - gemini-pro - gemini-1.0-pro - gemini-1.5-pro - gemini-1.5-flash	textembedding-gecko

** Le fournisseur de modèles prend en charge les modèles de saisie semi-automatique et de conversation ajustés. Pour interroger un modèle ajusté, renseignez le champ name de la configuration external model avec le nom de votre modèle ajusté.

† Le fournisseur de modèles prend en charge les modèles de saisie semi-automatique personnalisés.

Utiliser des modèles servis sur des points de terminaison de service de modèles Mosaic AI

Les points de terminaison du service de modèles Mosaic AI en tant que fournisseur sont pris en charge pour les types de points de terminaison llm/v1/completions, llm/v1/chat et llm/v1/embeddings. Ces points de terminaison doivent accepter les paramètres de requête standard marqués comme nécessaires, tandis que d’autres paramètres peuvent être ignorés selon que le point de terminaison du service de modèles Mosaic AI les prend en charge ou non.

Consultez POST /serving-endpoints/{name}/invocations dans la référence de l’API pour les paramètres de requête standard.

Ces points de terminaison doivent produire des réponses au format OpenAI suivant.

Pour les tâches d’achèvement :

{
"id": "123", # Not Required
"model": "test_databricks_model",
"choices": [
  {
    "text": "Hello World!",
    "index": 0,
    "logprobs": null, # Not Required
    "finish_reason": "length" # Not Required
  }
],
"usage": {
  "prompt_tokens": 8,
  "total_tokens": 8
  }
}

Pour les tâches de conversation :

{
  "id": "123", # Not Required
  "model": "test_chat_model",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "\n\nHello there, how may I assist you today?",
    },
    "finish_reason": "stop"
  },
  {
    "index": 1,
    "message": {
      "role": "human",
      "content": "\n\nWhat is the weather in San Francisco?",
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 8,
    "total_tokens": 8
  }
}

Pour les tâches d’incorporation :

{
  "data": [
    {
      "embedding": [
        0.0023064255,
        -0.009327292,
        .... # (1536 floats total for ada-002)
        -0.0028842222,
      ],
      "index": 0
    },
    {
      "embedding": [
        0.0023064255,
        -0.009327292,
        .... #(1536 floats total for ada-002)
        -0.0028842222,
      ],
      "index": 0
    }
  ],
  "model": "test_embedding_model",
  "usage": {
    "prompt_tokens": 8,
    "total_tokens": 8
  }
}

Configuration du point de terminaison

Pour traiter et interroger des modèles externes, vous devez configurer un service de point de terminaison. Consultez Créer un point de terminaison de mise en service de modèles externes

Pour un point de terminaison de service de modèle externe, vous devez inclure le champ external_model et ses paramètres dans la section served_entities de la configuration du point de terminaison. Si vous configurez plusieurs modèles externes dans un point de terminaison de service, vous devez fournir un traffic_config pour définir le pourcentage de routage du trafic pour chaque modèle externe.

Le champ external_model définit le modèle auquel ce point de terminaison transfère les requêtes. Lorsque vous spécifiez un modèle, il est essentiel que le fournisseur prenne en charge le modèle que vous demandez. Par exemple, openai en tant que fournisseur prend en charge des modèles comme text-embedding-ada-002, mais d’autres fournisseurs peuvent ne pas le faire. Si le modèle n’est pas pris en charge par le fournisseur, Databricks retourne une erreur HTTP 4xx lors de la tentative d’acheminer les requêtes vers ce modèle.

Le tableau ci-dessous récapitule les paramètres du champ external_model. Consultez POST /api/2.0/serving-endpoints pour connaître les paramètres de configuration de point de terminaison.

Paramètre	Descriptions
`name`	Nom du modèle à utiliser. Par exemple, `gpt-3.5-turbo` pour le modèle `GPT-3.5-Turbo` OpenAI.
`provider`	Spécifie le nom du fournisseur pour ce modèle. Cette valeur de chaîne doit correspondre à un fournisseur de modèle externe pris en charge. Par exemple, `openai` pour les modèles `GPT-3.5` OpenAI.
`task`	La tâche correspond au type d’interaction du modèle de langage souhaité. Les tâches prises en charge sont « llm/v1/completions », « llm/v1/chat », « llm/v1/embeddings ».
`<provider>_config`	Contient tous les détails de configuration supplémentaires nécessaires pour le modèle. Cela inclut la spécification de l’URL de base de l’API et de la clé API. Consultez Configurer le fournisseur pour un point de terminaison.

Voici un exemple de création d’un point de terminaison de modèle externe à l’aide de l’API create_endpoint(). Dans cet exemple, une requête envoyée au point de terminaison d’achèvement est transférée au modèle claude-2 fourni par anthropic.

import mlflow.deployments

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

client.create_endpoint(
    name="anthropic-completions-endpoint",
    config={
        "served_entities": [
            {
                "name": "test",
                "external_model": {
                    "name": "claude-2",
                    "provider": "anthropic",
                    "task": "llm/v1/completions",
                    "anthropic_config": {
                        "anthropic_api_key": "{{secrets/my_anthropic_secret_scope/anthropic_api_key}}"
                    }
                }
            }
        ]
    }
)

Configurer le fournisseur pour un point de terminaison

Lorsque vous créez un point de terminaison, vous devez fournir les configurations requises pour le fournisseur de modèles spécifié. Les sections suivantes résument les paramètres de configuration de point de terminaison disponibles pour chaque fournisseur de modèles.

Remarque

Databricks chiffre et stocke en lieu sûr les informations d’identification fournies pour chaque fournisseur de modèles. Ces informations d’identification sont automatiquement supprimées lorsque leurs points de terminaison associés sont supprimés.

OpenAI

Paramètre de configuration	Description	Obligatoire	Par défaut
`openai_api_key`	Référence de clé secrète Azure Databricks pour une clé API OpenAI utilisant le service OpenAI. Si vous préférez coller directement votre clé API, consultez `openai_api_key_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `openai_api_key` ou `openai_api_key_plaintext`.
`openai_api_key_plaintext`	Clé API OpenAI utilisant le service OpenAI, fournie sous forme de chaîne de texte en clair. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `openai_api_key`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `openai_api_key` ou `openai_api_key_plaintext`.
`openai_api_type`	Un champ facultatif pour spécifier le type d’API OpenAI à utiliser.	Non	`openai`
`openai_api_base`	L’URL de base de l’API OpenAI.	Non	`https://api.openai.com/v1`
`openai_api_version`	Un champ facultatif pour spécifier la version d’API OpenAI.	Non
`openai_organization`	Un champ facultatif pour spécifier l’organisation dans OpenAI.	Non

Cohere

Paramètre de configuration	Description	Obligatoire
`cohere_api_key`	Référence de clé secrète Azure Databricks pour une clé API Cohere. Si vous préférez coller directement votre clé API, consultez `cohere_api_key_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `cohere_api_key` ou `cohere_api_key_plaintext`.
`cohere_api_key_plaintext`	Clé API Cohere fournie sous forme de chaîne de texte en clair. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `cohere_api_key`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `cohere_api_key` ou `cohere_api_key_plaintext`.
`cohere_api_base`	URL de base pour le service Cohere.	Non

Anthropic

Paramètre de configuration	Description	Obligatoire	Par défaut
`anthropic_api_key`	Référence de clé secrète Azure Databricks pour une clé API Anthropic. Si vous préférez coller directement votre clé API, consultez `anthropic_api_key_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `anthropic_api_key` ou `anthropic_api_key_plaintext`.
`anthropic_api_key_plaintext`	Clé API Anthropic fournie sous forme de chaîne de texte en clair. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `anthropic_api_key`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `anthropic_api_key` ou `anthropic_api_key_plaintext`.

Azure OpenAI

Azure OpenAI a des fonctionnalités distinctes par rapport au service OpenAI direct. Pour obtenir une vue d’ensemble, consultez la documentation de comparaison.

Paramètre de configuration	Description	Obligatoire
`openai_api_key`	Référence de clé secrète Azure Databricks pour une clé API OpenAI utilisant le service Azure. Si vous préférez coller directement votre clé API, consultez `openai_api_key_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `openai_api_key` ou `openai_api_key_plaintext`.
`openai_api_key_plaintext`	Clé API OpenAI utilisant le service Azure, fournie sous forme de chaîne de texte en clair. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `openai_api_key`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `openai_api_key` ou `openai_api_key_plaintext`.
`openai_api_type`	Utilisez `azure` pour la validation du jeton d’accès.	Oui
`openai_api_base`	L’URL de base du service d’API Azure OpenAI fourni par Azure.	Oui
`openai_api_version`	La version du service Azure OpenAI à utiliser, spécifiée par une date.	Oui
`openai_deployment_name`	Le nom de la ressource de déploiement pour le service Azure OpenAI.	Oui
`openai_organization`	Un champ facultatif pour spécifier l’organisation dans OpenAI.	Non

Si vous utilisez Azure OpenAI avec Microsoft Entra ID, utilisez les paramètres suivants dans la configuration de votre point de terminaison.

Paramètre de configuration	Description	Obligatoire
`microsoft_entra_tenant_id`	L’ID de locataire pour l’authentification Microsoft Entra ID.	Oui
`microsoft_entra_client_id`	L’ID client pour l’authentification Microsoft Entra ID.	Oui
`microsoft_entra_client_secret`	Référence de clé secrète Azure Databricks pour une clé secrète client utilisée pour l’authentification Microsoft Entra ID. Si vous préférez coller directement votre clé secrète client, consultez `microsoft_entra_client_secret_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `microsoft_entra_client_secret` ou `microsoft_entra_client_secret_plaintext`.
`microsoft_entra_client_secret_plaintext`	Clé secrète client utilisée pour l’authentification Microsoft Entra ID, fournie sous forme de chaîne de texte en clair. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `microsoft_entra_client_secret`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `microsoft_entra_client_secret` ou `microsoft_entra_client_secret_plaintext`.
`openai_api_type`	Utilisez `azuread` pour l’authentification à l’aide de Microsoft Entra ID.	Oui
`openai_api_base`	L’URL de base du service d’API Azure OpenAI fourni par Azure.	Oui
`openai_api_version`	La version du service Azure OpenAI à utiliser, spécifiée par une date.	Oui
`openai_deployment_name`	Le nom de la ressource de déploiement pour le service Azure OpenAI.	Oui
`openai_organization`	Un champ facultatif pour spécifier l’organisation dans OpenAI.	Non

L’exemple suivant montre comment créer un point de terminaison avec Azure OpenAI :

client.create_endpoint(
    name="openai-chat-endpoint",
    config={
        "served_entities": [{
            "external_model": {
                "name": "gpt-3.5-turbo",
                "provider": "openai",
                "task": "llm/v1/chat",
                "openai_config": {
                    "openai_api_type": "azure",
                    "openai_api_key": "{{secrets/my_openai_secret_scope/openai_api_key}}",
                    "openai_api_base": "https://my-azure-openai-endpoint.openai.azure.com",
                    "openai_deployment_name": "my-gpt-35-turbo-deployment",
                    "openai_api_version": "2023-05-15"
                }
            }
        }]
    }
)

Google Cloud Vertex AI

Paramètre de configuration	Description	Obligatoire
`private_key`	Référence de clé secrète Azure Databricks pour une clé privée associée au compte de service qui a accès au service Google Cloud Vertex AI. Consultez Bonnes pratiques pour gérer les clés de compte de service. Si vous préférez coller directement votre clé API, consultez `private_key_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `private_key` ou `private_key_plaintext`.
`private_key_plaintext`	Clé privée du compte de service ayant accès au service Google Cloud Vertex AI, fournie sous forme de secret en texte en clair. Consultez Bonnes pratiques pour gérer les clés de compte de service. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `private_key`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `private_key` ou `private_key_plaintext`.
`region`	Il s’agit de la région du service Google Cloud Vertex AI. Pour plus d’informations, consultez Régions prises en charge. Certains modèles ne sont disponibles que dans des régions spécifiques.	Oui
`project_id`	Il s’agit de l’ID de projet Google Cloud auquel le compte de service est associé.	Oui

Amazon Bedrock

Pour utiliser Amazon Bedrock comme un fournisseur de modèle externe, les clients doivent s’assurer de l’activation de Bedrock dans la région AWS spécifiée, mais également que la paire de clés AWS spécifiée dispose des autorisations appropriées pour interagir avec les services Bedrock. Pour plus d’informations, consultez Gestion des identités et des accès AWS.

Paramètre de configuration	Description	Obligatoire
`aws_region`	La région AWS à utiliser. Bedrock doit être activé là-bas.	Oui
`aws_access_key_id`	Référence de clé secrète Azure Databricks pour un ID de clé d’accès AWS, avec des autorisations pour interagir avec les services Bedrock. Si vous préférez coller directement votre clé API, consultez `aws_access_key_id_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `aws_access_key_id` ou `aws_access_key_id_plaintext`.
`aws_access_key_id_plaintext`	ID de clé d’accès AWS avec des autorisations pour interagir avec les services Bedrock, fournie sous forme de chaîne de texte en clair. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `aws_access_key_id`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `aws_access_key_id` ou `aws_access_key_id_plaintext`.
`aws_secret_access_key`	Référence de clé secrète Azure Databricks pour une clé d’accès secrète AWS associée à l’ID de clé d’accès, avec des autorisations pour interagir avec les services Bedrock. Si vous préférez coller directement votre clé API, consultez `aws_secret_access_key_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `aws_secret_access_key` ou `aws_secret_access_key_plaintext`.
`aws_secret_access_key_plaintext`	Clé d’accès secrète AWS associée à l’ID de clé d’accès avec des autorisations pour interagir avec les services Bedrock, fournie sous forme de chaîne de texte en clair. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `aws_secret_access_key`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `aws_secret_access_key` ou `aws_secret_access_key_plaintext`.
`bedrock_provider`	Le fournisseur sous-jacent dans Amazon Bedrock. Les valeurs prises en charge (sans respect de la casse) sont les suivantes : Anthropic, Cohere, AI21Labs, Amazon	Oui

L’exemple suivant montre comment créer un point de terminaison avec Amazon Bedrock en utilisant des clés d’accès.

client.create_endpoint(
    name="bedrock-anthropic-completions-endpoint",
    config={
        "served_entities": [
            {
                "external_model": {
                    "name": "claude-v2",
                    "provider": "amazon-bedrock",
                    "task": "llm/v1/completions",
                    "amazon_bedrock_config": {
                        "aws_region": "<YOUR_AWS_REGION>",
                        "aws_access_key_id": "{{secrets/my_amazon_bedrock_secret_scope/aws_access_key_id}}",
                        "aws_secret_access_key": "{{secrets/my_amazon_bedrock_secret_scope/aws_secret_access_key}}",
                        "bedrock_provider": "anthropic",
                    },
                }
            }
        ]
    },
)

S’il existe des problèmes d’autorisation AWS, Databricks vous recommande de vérifier les informations d’identification directement avec l’API Amazon Bedrock.

Laboratoires AI21

Paramètre de configuration	Description	Obligatoire	Par défaut
`ai21labs_api_key`	Référence de clé secrète Azure Databricks pour une clé API AI21 Labs. Si vous préférez coller directement votre clé API, consultez `ai21labs_api_key_plaintext`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `ai21labs_api_key` ou `ai21labs_api_key_plaintext`.
`ai21labs_api_key_plaintext`	Clé API AI21 Labs fournie sous forme de chaîne de texte en clair. Si vous préférez référencer votre clé à l’aide de secrets Azure Databricks, consultez `ai21labs_api_key`.	Vous devez fournir une clé API en utilisant l’un des champs suivants : `ai21labs_api_key` ou `ai21labs_api_key_plaintext`.

Configurer AI Gateway sur un point de terminaison

Vous pouvez également configurer votre point de terminaison pour activer les fonctionnalités de Mosaic AI Gateway, telles que la limitation de débit, le suivi de l’utilisation et les garde-fous.

Consultez Configurer AI Gateway sur les points de terminaison de service de modèles.

Interroger un point de terminaison de modèle externe

Une fois que vous avez créé un point de terminaison de modèle externe, celui-ci est prêt à recevoir le trafic des utilisateurs.

Vous pouvez envoyer des demandes de scoring au point de terminaison en utilisant le client OpenAI l’API REST ou le SDK des déploiements MLflow.

Consultez les paramètres de requête standard pour une requête de scoring dans POST /serving-endpoints/{name}/invocations.
Interroger des modèles IA génératifs

L’exemple suivant interroge le modèle de complétions claude-2 hébergé par Anthropic en utilisant le client OpenAI. Pour utiliser le client OpenAI, renseignez le champ model avec le nom du point de terminaison de service du modèle qui héberge le modèle que vous voulez interroger.

Cet exemple utilise un point de terminaison créé précédemment, anthropic-completions-endpoint, configuré pour accéder aux modèles externes à partir du fournisseur de modèles Anthropic. Découvrez comment créer des points de terminaison de modèle externe.

Consultez les Modèles pris en charge pour obtenir des modèles supplémentaires que vous pouvez interroger, et leurs fournisseurs.

import os
import openai
from openai import OpenAI

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

completion = client.completions.create(
  model="anthropic-completions-endpoint",
  prompt="what is databricks",
  temperature=1.0
)
print(completion)

Format de réponse de sortie attendu :

{
"id": "123", # Not Required
"model": "anthropic-completions-endpoint",
"choices": [
  {
    "text": "Hello World!",
    "index": 0,
    "logprobs": null, # Not Required
    "finish_reason": "length" # Not Required
  }
],
"usage": {
  "prompt_tokens": 8,
  "total_tokens": 8
  }
}

Paramètres de requête supplémentaires

Vous pouvez transmettre tous les paramètres supplémentaires pris en charge par le fournisseur du point de terminaison dans le cadre de votre requête.

Par exemple :

logit_bias (pris en charge par OpenAI, Cohere).
top_k (pris en charge par Anthropic, Cohere).
frequency_penalty (pris en charge par OpenAI, Cohere).
presence_penalty (pris en charge par OpenAI, Cohere).
stream (pris en charge par OpenAI, Anthropic, Cohere, Amazon Bedrock pour Anthropic). Disponible uniquement pour les requêtes de conversation et de complétions.

Prise en charge des configurations de connectivité réseau pour les modèles externes

La prise en charge des configurations de connectivité réseau (NCC) pour les modèles externes, notamment Azure Private Link, est actuellement en préversion privée. Contactez l’équipe de votre compte Databricks pour participer à la préversion.

Limites

Selon le modèle externe que vous choisissez, votre configuration peut entraîner le traitement de vos données en dehors de la région d’où elles proviennent. Consultez Limites et régions de la mise en service de modèles.

Partager via