Créer et gérer des points de terminaison d'inférence en temps réel sans serveur

Article
03/22/2024

Important

Cette documentation a été mise hors service et peut ne pas être mise à jour. Les produits, services ou technologies mentionnés dans ce contenu ne sont plus pris en charge.
Les conseils contenus dans cet article concernent la version préliminaire de la fonctionnalité Model Serving, anciennement Serverless Real-Time Inference. Databricks vous recommande de migrer vos workflows de diffusion de modèles vers la fonctionnalité généralement disponible. Consultez Mise en service de modèles avec Azure Databricks.

Important

Cette fonctionnalité est disponible en préversion publique.

Cet article décrit comment créer et gérer des points de terminaison qui utilisent l’inférence en temps réel sans serveur Azure Databricks.

Important

Les définitions d’API et les workflows sont susceptibles de changer durant la préversion publique.
Si vous comptez sur Anaconda, consultez l'avis sur les conditions de service pour plus d'informations.

Spécifications

L’inférence serverless en temps réel est uniquement disponible pour les modèles MLflow basés sur Python inscrits dans le registre des modèles MLflow. Vous devez déclarer toutes les dépendances de modèle dans l’environnement Conda ou le fichier de spécifications.
- Si vous n’avez pas de modèle inscrit, consultez les exemples de notebooks pour les modèles pré-empaquetés que vous pouvez utiliser pour être opérationnel avec des points de terminaison serverless d’inférence en temps réel.
Votre espace de travail doit être activé pour l’inférence serverless en temps réel. Pour activer la diffusion de modèles avec l'inférence en temps réel sans serveur, vous devez disposer de l'autorisation de création de cluster.
Si vous utilisez des bibliothèques personnalisées ou des bibliothèques d'un serveur miroir privé avec votre modèle, consultez Utiliser des bibliothèques Python personnalisées avec Model Serving avant de créer le point de terminaison du modèle.

Créer un point de terminaison de diffusion de modèle

Vous pouvez créer des points de terminaison d’inférence serverless en temps réel pour le modèle servant avec l’API Databricks Machine Learning ou l’interface utilisateur Databricks Machine Learning. Un point de terminaison peut servir n’importe quel modèle Python MLflow inscrit dans le registre de modèles.

Utilisation de l’API

Vous pouvez utiliser l’API Activer la mise en service pour créer un point de terminaison pour le service de modèle. Dans l’exemple suivant, ElasticNet correspond au nom du modèle inscrit.

POST https://<databricks-instance>/api/2.0/preview/mlflow/endpoints-v2/enable

{
   "registered_model_name": "ElasticNet"
}

Utiliser l'interface utilisateur

Vous activez un modèle pour servir à partir de sa page de modèle inscrit dans l’interface utilisateur Databricks Machine Learning.

Cliquez sur l’onglet Mise en service. Si le modèle n’est pas déjà activé à des fins de mise en service, le bouton Activer l’inférence serverless en temps réel s’affiche.
Cliquez sur Activer l’inférence serverless en temps réel. L’onglet Mise en service s’affiche avec l’état En attente. Après quelques minutes, l’état affiche Prêt.

Modifier la configuration de calcul d’un point de terminaison

Après avoir activé un point de terminaison de modèle, vous pouvez définir la configuration de calcul à votre guise à l’aide de l’API ou de l’interface utilisateur. Cette configuration se révèle particulièrement utile si vous avez besoin de ressources supplémentaires pour votre modèle. La taille de la charge de travail et la configuration du calcul jouent un rôle clé dans les ressources allouées pour servir votre modèle. En savoir plus sur les objets WorkloadConfigSpec.

Utilisation de l’API

L’état de la mise à jour de configuration peut être suivi dans le champ config_update_status de l’état de la version du point de terminaison.

PUT /preview/model-serving-api/endpoints-v2/update-compute-config

Dans ce qui suit, renseignez desired_workload_config_spec avec les propriétés WorkloadConfigSpec.

{
  "registered_model_name": "ElasticNet",
  "stage": "Staging|Production",
  "desired_workload_config_spec": {"WorkloadConfigSpec"}
}

Utiliser l’interface utilisateur

Après avoir activé un point de terminaison de modèle, vous pouvez définir la configuration de calcul souhaitée sous l’onglet Paramètres de calcul. Vous avez la possibilité de définir des configurations distinctes pour les versions de modèle de préproduction et de production.

Vous pouvez choisir parmi quelques tailles de charge de travail. La mise à l’échelle automatique est automatiquement configurée selon la taille de la charge de travail. Si vous souhaitez que votre point de terminaison effectue un scale-down à zéro, vous pouvez cocher la case intitulée « Mettre à l’échelle à zéro ».

Notation d'un point de terminaison de modèle

Pour évaluer un modèle déployé, vous pouvez envoyer une requête d’API REST à l’URL du modèle ou utiliser l’interface utilisateur.

Vous devez appeler un modèle en appelant l’API correspondant à sa phase. Par exemple, si la version 1 se trouve dans la phase Production, elle peut également faire l’objet d’un scoring avec l’URI suivant :

https://<databricks-instance>/model-endpoint/iris-classifier/Production/invocations

La liste des URI de modèle disponibles apparaît en haut de l’onglet Versions de modèle sous l’onglet Mise en service.

Format de requête

Les demandes doivent être envoyées en créant un JSON avec l’une des clés ci-dessous et un objet JSON correspondant au format d’entrée.

Il existe quatre formats pour le JSON d’entrée en fonction de votre cas d’usage :

dataframe_split est un dataframe Pandas sérialisé au format JSON dans l’orientation split .

{
  "dataframe_split": {
    "index": [0, 1],
    "columns": ["sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"],
    "data": [[5.1, 3.5, 1.4, 0.2], [4.9, 3.0, 1.4, 0.2]]
  }
}

dataframe_records est un dataframe Pandas sérialisé au format JSON dans l’orientation records .

Remarque

Ce format ne garantit pas la conservation du classement des colonnes, et le split format est préféré au records format.

{
  "dataframe_records": [
  {
     "sepal length (cm)": 5.1,
     "sepal width (cm)": 3.5,
     "petal length (cm)": 1.4,
     "petal width (cm)": 0.2
  },
  {
     "sepal length (cm)": 4.9,
     "sepal width (cm)": 3,
     "petal length (cm)": 1.4,
     "petal width (cm)": 0.2
   },
   {
     "sepal length (cm)": 4.7,
     "sepal width (cm)": 3.2,
     "petal length (cm)": 1.3,
     "petal width (cm)": 0.2
   }
  ]
}

instances est un format basé sur des tenseurs qui accepte des tenseurs au format de ligne. Utilisez ce format si tous les tenseurs d’entrée ont la même dimension 0-th. Conceptuellement, chaque tenseur de la liste des instances peut être joint aux autres tenseurs du même nom dans le reste de la liste pour construire le tenseur d’entrée complet du modèle, ce qui n’est possible que si tous les tenseurs ont la même dimension 0-th.
```
  {"instances": [ "a", "b", "c" ]}
```
or

Dans l’exemple suivant, il existe trois dimensions et vous en disposez pour chaque capteur d’entrée.
```
{
"instances": [
  {
   "t1": "a",
   "t2": [1, 2, 3, 4, 5],
   "t3": [[1, 2], [3, 4], [5, 6]]
  },
  {
   "t1": "b",
   "t2": [6, 7, 8, 9, 10],
   "t3": [[7, 8], [9, 10], [11, 12]]
  }
]
}
```
inputs envoient des requêtes avec des tenseurs dans un format en colonnes. Cette requête est différente, car il existe en fait un nombre différent d’instances de tenseur de t2 (3) que t1 et t3, et il n’est donc pas possible de représenter cette entrée dans le format instances.
```
{
"inputs": {
  "t1": ["a", "b"],
  "t2": [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]],
  "t3": [[[1, 2], [3, 4], [5, 6]], [[7, 8], [9, 10], [11, 12]]]
}
}
```

Format de la réponse

La réponse du point de terminaison se présente au format suivant. La sortie de votre modèle est encapsulée dans une clé de « prédictions ».

{
  "predictions": "<JSON output from model>"
}

Utiliser l’interface utilisateur

L’envoi de requêtes à l’aide de l’interface utilisateur constitue le moyen le plus simple et le plus rapide de tester le modèle. Vous pouvez insérer les données d’entrée du modèle au format JSON, puis cliquer sur Envoyer la demande. Si le modèle a été journalisé avec un exemple d’entrée (comme indiqué dans le graphique ci-dessus), cliquez sur Afficher l’exemple pour charger l’exemple d’entrée.

Utilisation de l’API

Vous pouvez envoyer une demande de scoring par le biais de l’API REST en utilisant l’authentification Databricks standard. Les exemples suivant illustrent l’authentification avec un jeton d’accès personnel.

Remarque

En guise de bonne pratique de sécurité, quand vous vous authentifiez avec des outils, systèmes, scripts et applications automatisés, Databricks recommande d’utiliser des jetons d’accès personnels appartenant à des principaux de service et non des utilisateurs de l’espace de travail. Pour créer des jetons d’accès pour des principaux de service, consultez la section Gérer les jetons pour un principal de service.

Les exemples d’extraits de code suivants illustre l’évaluation d’un modèle servi, en supposant un MODEL_VERSION_URI comme https://<databricks-instance>/model/iris-classifier/Production/invocations (où <databricks-instance> est le nom de votre instance Databricks) et un jeton d’API REST Databricks appelé DATABRICKS_API_TOKEN.

Bash

Évaluez un modèle acceptant le format d’entrée des enregistrements de dataframe.

curl -X POST -u token:$DATABRICKS_API_TOKEN $MODEL_VERSION_URI \
  -H 'Content-Type: application/json' \
  -d '{"dataframe_records": [
    {
      "sepal_length": 5.1,
      "sepal_width": 3.5,
      "petal_length": 1.4,
      "petal_width": 0.2
    }
  ]}'

Évaluez un modèle acceptant les entrées de tenseur. Les entrées de tenseur doivent être mises en forme conformément à la documentation de l’API de TensorFlow Serving.

curl -X POST -u token:$DATABRICKS_API_TOKEN $MODEL_VERSION_URI \
   -H 'Content-Type: application/json' \
   -d '{"inputs": [[5.1, 3.5, 1.4, 0.2]]}'

Python

import numpy as np
import pandas as pd
import requests

def create_tf_serving_json(data):
  return {'inputs': {name: data[name].tolist() for name in data.keys()} if isinstance(data, dict) else data.tolist()}

def score_model(model_uri, databricks_token, data):
  headers = {
    "Authorization": f"Bearer {databricks_token}",
    "Content-Type": "application/json",
  }
  data_json = json.dumps({'dataframe_records': data.to_dict(orient='records')}) if isinstance(data, pd.DataFrame) else create_tf_serving_json(data)
  response = requests.request(method='POST', headers=headers, url=model_uri, json=data_json)
  if response.status_code != 200:
      raise Exception(f"Request failed with status {response.status_code}, {response.text}")
  return response.json()

# Scoring a model that accepts pandas DataFrames
data =  pd.DataFrame([{
  "sepal_length": 5.1,
  "sepal_width": 3.5,
  "petal_length": 1.4,
  "petal_width": 0.2
}])
score_model(MODEL_VERSION_URI, DATABRICKS_API_TOKEN, data)

# Scoring a model that accepts tensors
data = np.asarray([[5.1, 3.5, 1.4, 0.2]])
score_model(MODEL_VERSION_URI, DATABRICKS_API_TOKEN, data)

Powerbi

Vous pouvez évaluer un jeu de données dans Power BI Desktop en procédant comme suit :

Ouvrez le jeu de données à évaluer.
Accédez à Transformer les données.
Cliquez avec le bouton droit dans le volet gauche et sélectionnez Créer une requête.
Accédez à Afficher > Éditeur avancé.

Remplacez le corps de la requête par l’extrait de code ci-dessous, après avoir fourni un DATABRICKS_API_TOKEN approprié et un MODEL_VERSION_URI.

(dataset as table ) as table =>
let
  call_predict = (dataset as table ) as list =>
  let
    apiToken = DATABRICKS_API_TOKEN,
    modelUri = MODEL_VERSION_URI,
    responseList = Json.Document(Web.Contents(modelUri,
      [
        Headers = [
          #"Content-Type" = "application/json",
          #"Authorization" = Text.Format("Bearer #{0}", {apiToken})
        ],
        Content = {"dataframe_records": Json.FromValue(dataset)}
      ]
    ))
  in
    responseList,
  predictionList = List.Combine(List.Transform(Table.Split(dataset, 256), (x) => call_predict(x))),
  predictionsTable = Table.FromList(predictionList, (x) => {x}, {"Prediction"}),
  datasetWithPrediction = Table.Join(
    Table.AddIndexColumn(predictionsTable, "index"), "index",
    Table.AddIndexColumn(dataset, "index"), "index")
in
  datasetWithPrediction

Nommez la requête avec le nom de modèle de votre choix.
Ouvrez l’éditeur de requête avancé pour votre jeu de données et appliquez la fonction de modèle.

Consultez le notebook suivant pour obtenir un exemple de test de votre point de terminaison serverless d’inférence en temps réel avec un modèle Python :

Tester le notebook du point de terminaison serverless d’inférence en temps réel

Obtenir le notebook

Mettre à jour la version du modèle servie par un point de terminaison de modèle

Une version de modèle doit être en préproduction ou en production dans le registre de modèles pour être servie au point de terminaison.

Utilisation de l’API

Pour passer d’une nouvelle version de modèle à la mise en service, vous pouvez utiliser le registre de modèles pour passer la version de modèle que vous souhaitez servir dans la phase appropriée.

L’exemple de code suivant passe la version 2 du modèle ElasticNet en préproduction. Si vous définissez la valeur archive_existing_versions sur true, toutes les versions de modèle existantes sont archivées, ce qui fait que l'URL de préproduction pointe vers la nouvelle version du modèle une fois prête qu'elle est prête à être utilisée. Avant que la nouvelle version soit prête, le point de terminaison de préproduction sert l’ancienne version du modèle, de sorte que la transition s’effectue sans temps d’arrêt.


POST /mlflow/databricks/model-versions/transition-stage

{
   "name": "ElasticNet",
   "version": "2",
   "stage": "Staging",
   "archive_existing_versions": true,
   "comment": "Deploying version 1 to Staging endpoint!"
}

Conserver plusieurs versions dans une même phase

Vous pouvez également choisir de conserver la version précédente de préproduction en préproduction. Plusieurs versions d’un modèle peuvent se trouver dans la même phase. Dans ce scénario, les deux versions sont servies, mais l’URL de préproduction pointe uniquement vers la version la plus récente. L’ancienne version est toujours accessible par son URL de version.

Si vous souhaitez essayer une nouvelle version derrière votre point de terminaison de préproduction, vous pouvez effectuer la même opération que ci-dessus, mais en définissant archive_existing_versions sur false pour vous assurer que la version précédente de préproduction n’est pas archivée.

POST /mlflow/databricks/model-versions/transition-stage

{
...
   "archive_existing_versions": false,
...
}

Utiliser l’interface utilisateur

Pour passer des versions de modèle à la préproduction ou à la production à l’aide de l’interface utilisateur Databricks Machine Learning :

Sélectionnez Modèles dans la barre latérale.
Identifiez et sélectionnez le modèle inscrit que vous souhaitez mettre à jour.
Sélectionnez la version du modèle que vous souhaitez passer à la préproduction ou à la production. Le lien ouvre la page de détails de cette version de modèle.
Utilisez le menu déroulant Phase en haut à droite pour passer de la version du modèle en préproduction ou production.

Obtenir l’état du point de terminaison du modèle

Utilisation de l’API

Databricks fournit les informations suivantes pour vérifier l’état d’un point de terminaison. En savoir plus sur les objets EndpointStatus.

GET /preview/mlflow/endpoints-v2/get-status

{
  "registered_model_name": "ElasticNet"
}

Cette opération renvoie les propriétés de l’objet EndpointStatus :

{
  "endpoint_status": {"EndpointStatus"}
}

Utiliser l’interface utilisateur

Dans l’interface utilisateur, vous pouvez vérifier l’état d’un point de terminaison à partir de l’indicateur État en haut de l’onglet Mise en service .

Obtenir l’état des versions de point de terminaison de modèle

Vous pouvez obtenir l’état d’une version de point de terminaison particulière qui a été déployée. Cela vous permet :

Suivez les versions prises en charge.
Suivez l’état de ces versions.
Vérifiez si une version de modèle spécifique est prête à être utilisée.

Utilisation de l’API

Databricks fournit deux API pour vérifier l’état des versions de point de terminaison. Pour vérifier l’état de toutes les versions de point de terminaison d’un modèle inscrit particulier, vous pouvez utiliser ListVersions. En savoir plus sur les objets EndpointVersionStatus.

GET /preview/mlflow/endpoints-v2/list-versions

{
  "registered_model_name": "ElasticNet"
}

Cette opération renvoie les propriétés de l’objet EndpointVersionStatus :

{
  "endpoint_statuses": ["EndpointVersionStatus"]
}

Si vous connaissez déjà la version spécifique dont vous souhaitez connaître l’état, vous pouvez également utiliser GetVersions.

GET /preview/mlflow/endpoints-v2/get-version-status

{
  "registered_model_name": "ElasticNet",
  "endpoint_version_name": "1"
}

Cette opération renvoie les propriétés de l’objet EndpointVersionStatus :

{
  "endpoint_status": {"EndpointVersionStatus"}
}

Obtention de l’état d’une phase

Vous pouvez également obtenir l’état d’une phase particulière. Pour ce faire, vous devez d’abord déterminer la version du point de terminaison servant actuellement la phase. Pour récupérer ces informations, vous pouvez utiliser ListVersionAliases.

GET /preview/mlflow/endpoints-v2/list-version-aliases

{
  "registered_model_name": "ElasticNet"
}

Cette demande renvoie :

{
  "aliases": [
   {
      "alias": "Staging",
      "endpoint_version_name": "2"
   },
   {
      "alias": "Production",
      "endpoint_version_name": "1"
   }
  ]
}

À partir de là, vous pouvez utiliser ce qui précède pour obtenir l’état de la version de point de terminaison particulière.

Utiliser l’interface utilisateur

Sous l’onglet Mise en service de l’interface utilisateur, vous pouvez voir chaque version avec son propre onglet à gauche. Lorsque vous sélectionnez chaque onglet, des informations détaillées sur une version particulière s’affichent. La version qui sert actuellement une phase est visible à partir de l’étiquette Préproduction ou Production sur la version du point de terminaison.

Désactiver la mise en service du modèle

Utilisation de l’API

Vous pouvez utiliser l’API pour désactiver la mise en service d’un modèle de service pour n’importe quel modèle inscrit présent dans le registre de modèles.

Pour désactiver la mise en service d’un modèle, utilisez l’API Désactiver la mise en service :

POST /preview/mlflow/endpoints-v2/disable

{
   "registered_model_name": "ElasticNet"
}

Utiliser l’interface utilisateur

Vous pouvez désactiver un modèle à des fins de mise en service à partir de sa page de modèle inscrit.

Cliquez sur l’onglet Mise en service. Si le modèle n’est pas déjà activé à des fins de mise en service, le bouton Activer l’inférence serverless en temps réel s’affiche.
Cliquez sur Désactiver la mise en service.

Déboguer votre point de terminaison de modèle

Remarque

Seule l’interface utilisateur vous permet de déboguer votre point de terminaison de modèle.

Vous pouvez déboguer et résoudre les problèmes de votre point de terminaison en affichant les journaux de modèle sous l’onglet de la version du point de terminaison dans l’interface utilisateur Databricks Machine Learning. Les journaux de tous les réplicas du modèle sont fusionnés dans l’onglet Tous les réplicas.

Outre les journaux du modèle, vous pouvez afficher des événements de mise en service relatifs au modèle sous l’onglet Événements du modèle.

Objets API principaux

Cette section contient des modèles de conception ainsi que la syntaxe des objets API principaux de l’inférence Serverless en temps réel.

Important

Les définitions d’API sont susceptibles de changer durant la préversion publique.

Configuration de la charge de travail

WorkloadConfigSpec décrit la configuration utilisée pour mettre à l’échelle le calcul pour une phase particulière.

  "WorkloadConfigSpec":
  {
   "workload_size_id": "Small|Medium|Large",
   "scale_to_zero_enabled": false
  }

ComputeConfig représente la configuration utilisée pour mettre à l’échelle le calcul pour une phase particulière, ainsi que les métadonnées associées.

Dans ce qui suit, renseignez workload_spec en remplaçant "WorkloadConfigSpec" par les propriétés définies précédemment de votre objet WorkloadConfigSpec.

  "ComputeConfig":
  {
   "stage":  "Staging|Production",
   "creation_timestamp": 12345678,
   "user_id": "first.last@databricks.com",
   "workload_spec": {"WorkloadConfigSpec"}
  }

État du point de terminaison

L’intégrité d’un point de terminaison indique si l’une des phases peut être évaluée ou si des ressources sont générées pour des versions particulières du modèle.

Dans l’objet EndpointStatus suivant, renseignez compute_config en réutilisant les propriétés définies précédemment de votre objet ComputeConfig et toutes les autres propriétés sous forme de tableau.

  "EndpointStatus":
  {
   "registered_model_name": "ElasticNet",
   "state": "PENDING|READY|FAILED",
   "state_message": "State message",
   "compute_config": ["ComputeConfig and additional properties as an array"]
  }

État de la version d’un point de terminaison

Une version de point de terminaison dispose d’un URI particulier qui peut être interrogé. L’URI représente une version de modèle unique qui est prise en charge et dont le calcul est configuré par les configurations de calcul définies pour sa phase.

Dans l’objet EndpointVersionStatus suivant, renseignez les champs config, service_status et config_update_status, en remplaçant "ComputeConfig" par les propriétés définies précédemment de votre objet ComputeConfig.

  "EndpointVersionStatus":
  {
   "registered_model_name": "ElasticNet",
   "endpoint_version_name": "1",
   "service_status": {
      "state": "SERVICE_STATE_UNKNOWN|SERVICE_STATE_PENDING|SERVICE_STATE_READY|SERVICE_STATE_UNKNOWN",
      "message": "Ready",
      "config": {"ComputeConfig"}
   },
   "config_update_status": {
      "state": "SERVICE_STATE_UNKNOWN|SERVICE_STATE_PENDING|SERVICE_STATE_READY|SERVICE_STATE_UNKNOWN",
      "message": "Pending",
      "config": {"ComputeConfig"}
    }
  }

Exemples de Notebook

Les blocs-notes suivants incluent différents modèles que vous pouvez utiliser pour être opérationnel avec des points de terminaison serverless d’inférence en temps réel. Les exemples de modèles peuvent être importés dans l’espace de travail sur la base des instructions figurant dans Importer un notebook. Après avoir choisi et créé un modèle à partir de l’un des exemples, inscrivez-le dans le Registre de modèles MLflow, puis suivez les étapes du workflow de l’interface utilisateur pour le service de modèle.

Entraîner et inscrire un modèle scikit-learn pour le notebook de service de modèle

Obtenir le notebook

Entraîner et inscrire un modèle Pytorch pour le notebook de service de modèle

Obtenir le notebook

Entraîner et inscrire un modèle HuggingFace pour le notebook de service de modèle

Obtenir le notebook

Héberger plusieurs modèles dans un notebook de point de terminaison

Obtenir le notebook

Mise à jour des licences Anaconda

L’avis suivant concerne les clients qui s’appuient sur Anaconda.

Important

Anaconda Inc. a mis à jour ses conditions d’utilisation du service pour les canaux anaconda.org. Les nouvelles conditions d’utilisation du service peuvent vous imposer d’avoir une licence commerciale pour utiliser une distribution et des packages Anaconda. Pour plus d’informations, consultez le Forum aux questions sur l’édition commerciale d’Anaconda. Votre utilisation des canaux Anaconda est régie par leurs conditions d’utilisation du service.

Les modèles MLflow enregistrés avant la version 1.18 (Databricks Runtime 8.3 ML ou version antérieure) étaient enregistrés par défaut avec le canal conda defaults (https://repo.anaconda.com/pkgs/) en tant que dépendance. En raison de cette modification de licence, Databricks a arrêté l’utilisation du canal defaults pour les modèles enregistrés à l’aide de MLflow v1.18 et versions ultérieures. Le canal par défaut journalisé est maintenant conda-forge, qui pointe vers https://conda-forge.org/, géré par la communauté.

Si vous avez enregistré un modèle avant MLflow v1.18 sans exclure le canal defaults de l’environnement conda pour le modèle, ce modèle peut avoir une dépendance sur le canal defaults que vous n’avez peut-être pas prévue. Pour vérifier manuellement si un modèle a cette dépendance, vous pouvez examiner la valeur channel dans le fichier conda.yaml empaqueté avec le modèle journalisé. Par exemple, les modèles conda.yaml avec une dépendance de canal defaults peuvent ressembler à ceci :

channels:
- defaults
dependencies:
- python=3.8.8
- pip
- pip:
    - mlflow
    - scikit-learn==0.23.2
    - cloudpickle==1.6.0
      name: mlflow-env

Étant donné que Databricks ne peut pas déterminer si votre utilisation du référentiel Anaconda pour interagir avec vos modèles est autorisée dans votre relation avec Anaconda, Databricks n’oblige pas ses clients à apporter des modifications. Si votre utilisation du référentiel Anaconda.com par le biais de l’utilisation de Databricks est autorisée selon les conditions d’Anaconda, vous n’avez pas besoin d’effectuer d’action.

Si vous souhaitez modifier le canal utilisé dans l’environnement d’un modèle, vous pouvez réinscrire le modèle dans le registre de modèles avec un nouveau conda.yaml. Pour ce faire, spécifiez le canal dans le paramètre conda_env de log_model().

Pour plus d’informations sur l’API log_model(), consultez la documentation MLflow pour la version de modèle que vous utilisez, par exemple, log_model pour scikit-learn.

Pour plus d’informations sur les fichiers conda.yaml, consultez la documentation MLflow.

Créer et gérer des points de terminaison d'inférence en temps réel sans serveur

Spécifications

Créer un point de terminaison de diffusion de modèle

Utilisation de l’API

Utiliser l'interface utilisateur

Modifier la configuration de calcul d’un point de terminaison

Utilisation de l’API

Utiliser l’interface utilisateur

Notation d'un point de terminaison de modèle

Format de requête

Format de la réponse

Utiliser l’interface utilisateur

Utilisation de l’API

Bash

Python

Powerbi

Tester le notebook du point de terminaison serverless d’inférence en temps réel

Mettre à jour la version du modèle servie par un point de terminaison de modèle

Utilisation de l’API

Conserver plusieurs versions dans une même phase

Utiliser l’interface utilisateur

Obtenir l’état du point de terminaison du modèle

Utilisation de l’API

Utiliser l’interface utilisateur

Obtenir l’état des versions de point de terminaison de modèle

Utilisation de l’API

Obtention de l’état d’une phase

Utiliser l’interface utilisateur

Désactiver la mise en service du modèle

Utilisation de l’API

Utiliser l’interface utilisateur

Déboguer votre point de terminaison de modèle

Objets API principaux

Configuration de la charge de travail

État du point de terminaison

État de la version d’un point de terminaison

Exemples de Notebook

Entraîner et inscrire un modèle scikit-learn pour le notebook de service de modèle

Entraîner et inscrire un modèle Pytorch pour le notebook de service de modèle

Entraîner et inscrire un modèle HuggingFace pour le notebook de service de modèle

Héberger plusieurs modèles dans un notebook de point de terminaison

Mise à jour des licences Anaconda

Commentaires

Commentaires

Ressources supplémentaires