Partilhar via

Criar pontos de extremidade de serviço de modelo personalizado

  • Artigo

Este artigo descreve como criar pontos de extremidade de serviço de modelo que servem modelos personalizados usando o Databricks Model Serving.

O Model Serving fornece as seguintes opções para servir a criação de pontos finais:

  • A interface do usuário de serviço
  • API REST
  • SDK de implantações MLflow

Para criar endpoints que servem modelos de base de IA generativa, consulte Criar modelo de IA generativa servindo endpoints.

Requerimentos

  • Seu espaço de trabalho deve estar em uma região suportada.
  • Se você usar bibliotecas personalizadas ou bibliotecas de um servidor espelho privado com seu modelo, consulte Usar bibliotecas Python personalizadas com o Model Serving antes de criar o ponto de extremidade do modelo.
  • Para criar pontos de extremidade usando o SDK de Implantações MLflow, você deve instalar o cliente MLflow Deployment. Para instalá-lo, execute:
import mlflow.deployments

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

Controlo de acesso

Para entender as opções de controle de acesso para pontos de extremidade de serviço de modelo para gerenciamento de ponto de extremidade, consulte Gerenciar permissões em seu ponto de extremidade de serviço de modelo.

Você também pode adicionar variáveis de ambiente para armazenar credenciais para servir o modelo. Consulte Configurar o acesso a recursos a partir de pontos de extremidade de serviço de modelo

Criar um ponto de extremidade

Servindo a interface do usuário

Você pode criar um ponto de extremidade para o modelo de serviço com a interface do usuário de serviço .

  1. Clique em Servindo na barra lateral para exibir a interface do usuário de serviço.

  2. Clique em Criar ponto de extremidade de serviço.

    Painel de serviço de modelo na interface do usuário do Databricks

Para modelos registrados no registro de modelo de espaço de trabalho ou modelos no Catálogo Unity:

  1. No campo Nome, forneça um nome para o seu ponto de extremidade.

  2. Na secção Entidades servidas

    1. Clique no campo Entidade para abrir o formulário Selecionar entidade atendida.
    2. Selecione o tipo de modelo que deseja servir. O formulário é atualizado dinamicamente com base na sua seleção.
    3. Selecione qual modelo e versão do modelo você deseja servir.
    4. Selecione a percentagem de tráfego a encaminhar para o seu modelo servido.
    5. Selecione o tamanho de computação a ser usado. Você pode usar cálculos de CPU ou GPU para suas cargas de trabalho. Consulte Tipos de carga de trabalho de GPU para obter mais informações sobre cálculos de GPU disponíveis.
    6. Em Expansão de computação, selecione o tamanho da escala de computação que corresponde ao número de solicitações que esse modelo atendido pode processar ao mesmo tempo. Este número deve ser aproximadamente igual ao tempo de execução do modelo QPS x.
      1. Os tamanhos disponíveis são Pequeno para 0-4 pedidos, Médio 8-16 pedidos e Grande para 16-64 pedidos.
    7. Especifique se o ponto de extremidade deve ser dimensionado para zero quando não estiver em uso.

  3. Clique em Criar. A página Pontos de extremidade de serviço é exibida com o estado do ponto de extremidade de serviço mostrado como Não pronto.

    Criar um ponto de extremidade de serviço de modelo

API REST

Você pode criar pontos de extremidade usando a API REST. Consulte POST /api/2.0/serving-endpoints para obter os parâmetros de configuração do ponto final.

O exemplo a seguir cria um ponto de extremidade que serve a primeira versão do ads1 modelo registrado no registro do modelo. Para especificar um modelo do Unity Catalog, forneça o nome completo do modelo, incluindo o catálogo pai e o esquema, catalog.schema.example-modelcomo .


POST /api/2.0/serving-endpoints

{
  "name": "workspace-model-endpoint",
  "config":{
    "served_entities": [
      {
        "name": "ads-entity"
        "entity_name": "my-ads-model",
        "entity_version": "3",
        "workload_size": "Small",
        "scale_to_zero_enabled": true
      },
      {
        "entity_name": "my-ads-model",
        "entity_version": "4",
        "workload_size": "Small",
        "scale_to_zero_enabled": true
      }
    ],
    "traffic_config":{
      "routes": [
        {
          "served_model_name": "my-ads-model-3",
          "traffic_percentage": 100
        },
        {
          "served_model_name": "my-ads-model-4",
          "traffic_percentage": 20
        }
      ]
    }
  },
  "tags": [
    {
      "key": "team",
      "value": "data science"
    }
  ]
}

Segue-se um exemplo de resposta. O estado do ponto de config_update extremidade é NOT_UPDATING e o modelo servido está em um READY estado.

{
  "name": "workspace-model-endpoint",
  "creator": "user@email.com",
  "creation_timestamp": 1700089637000,
  "last_updated_timestamp": 1700089760000,
  "state": {
    "ready": "READY",
    "config_update": "NOT_UPDATING"
  },
  "config": {
    "served_entities": [
      {
        "name": "ads-entity",
        "entity_name": "my-ads-model-3",
        "entity_version": "3",
        "workload_size": "Small",
        "scale_to_zero_enabled": true,
        "workload_type": "CPU",
      "state": {
        "deployment": "DEPLOYMENT_READY",
        "deployment_state_message": ""
      },
      "creator": "user@email.com",
      "creation_timestamp": 1700089760000
      }
    ],
    "traffic_config": {
      "routes": [
        {
          "served_model_name": "my-ads-model-3",
          "traffic_percentage": 100
        }
      ]
    },
    "config_version": 1
  },
  "tags": [
    {
      "key": "team",
      "value": "data science"
    }
  ],
  "id": "e3bd3e471d6045d6b75f384279e4b6ab",
  "permission_level": "CAN_MANAGE",
  "route_optimized": false
}

SDK de implantações MLflow

MLflow Deployments fornece uma API para tarefas de criação, atualização e exclusão. As APIs para essas tarefas aceitam os mesmos parâmetros que a API REST para servir pontos de extremidade. Consulte POST /api/2.0/serving-endpoints para obter os parâmetros de configuração do ponto final.


from mlflow.deployments import get_deploy_client

client = get_deploy_client("databricks")
endpoint = client.create_endpoint(
    name="workspace-model-endpoint",
    config={
        "served_entities": [
            {
                "name": "ads-entity"
                "entity_name": "my-ads-model",
                "entity_version": "3",
                "workload_size": "Small",
                "scale_to_zero_enabled": true
            }
        ],
        "traffic_config": {
            "routes": [
                {
                    "served_model_name": "my-ads-model-3",
                    "traffic_percentage": 100
                }
            ]
        }
    }
)

Também pode:

Tipos de carga de trabalho GPU

A implantação da GPU é compatível com as seguintes versões de pacote:

  • Pytorch 1.13.0 - 2.0.1
  • TensorFlow 2.5.0 - 2.13.0
  • MLflow 2.4.0 e superior

Para implantar seus modelos usando GPUs, inclua o campo na configuração do endpoint durante a criação do workload_type endpoint ou como uma atualização de configuração do endpoint usando a API. Para configurar seu ponto de extremidade para cargas de trabalho de GPU com a interface do usuário de serviço , selecione o tipo de GPU desejado na lista suspensa Tipo de computação.

{
  "served_entities": [{
    "name": "ads1",
    "entity_version": "2",
    "workload_type": "GPU_LARGE",
    "workload_size": "Small",
    "scale_to_zero_enabled": false,
  }]
}

A tabela a seguir resume os tipos de carga de trabalho de GPU disponíveis suportados.

Tipo de carga de trabalho GPU Instância da GPU Memória GPU
GPU_SMALL 1xT4 16 GB
GPU_LARGE 1xA100 80 GB
GPU_LARGE_2 2xA100 160 GB

Modificar um ponto de extremidade de modelo personalizado

Depois de habilitar um ponto de extremidade de modelo personalizado, você pode atualizar a configuração de computação conforme desejado. Essa configuração é particularmente útil se você precisar de recursos adicionais para seu modelo. O tamanho da carga de trabalho e a configuração de computação desempenham um papel fundamental nos recursos alocados para atender ao seu modelo.

Até que a nova configuração esteja pronta, a configuração antiga continua servindo o tráfego de previsão. Embora haja uma atualização em andamento, outra atualização não pode ser feita. No entanto, você pode cancelar uma atualização em andamento na interface do usuário de serviço.

Servindo a interface do usuário

Depois de habilitar um ponto de extremidade de modelo, selecione Editar ponto de extremidade para modificar a configuração de computação do seu ponto de extremidade.

Pode fazer o seguinte:

  • Escolha entre alguns tamanhos de carga de trabalho e o dimensionamento automático é configurado automaticamente dentro do tamanho da carga de trabalho.
  • Especifique se o ponto de extremidade deve ser reduzido para zero quando não estiver em uso.
  • Modifique a porcentagem de tráfego para rotear para o modelo servido.

Você pode cancelar uma atualização de configuração em andamento selecionando Cancelar atualização no canto superior direito da página de detalhes do ponto de extremidade. Essa funcionalidade só está disponível na interface do usuário de serviço.

API REST

A seguir está um exemplo de atualização de configuração de ponto de extremidade usando a API REST. Consulte PUT /api/2.0/serving-endpoints/{name}/config.


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

{
  "name": "workspace-model-endpoint",
  "config":{
    "served_entities": [
      {
        "name": "ads-entity"
        "entity_name": "my-ads-model",
        "entity_version": "5",
        "workload_size": "Small",
        "scale_to_zero_enabled": true
      }
    ],
    "traffic_config":{
      "routes": [
        {
          "served_model_name": "my-ads-model-5",
          "traffic_percentage": 100
        }
      ]
    }
  }
}

SDK de implantações MLflow

O SDK de implantações MLflow usa os mesmos parâmetros que a API REST, consulte PUT /api/2.0/serving-endpoints/{name}/config para obter detalhes do esquema de solicitação e resposta.

O exemplo de código a seguir usa um modelo do registro de modelo do Unity Catalog:

import mlflow
from mlflow.deployments import get_deploy_client

mlflow.set_registry_uri("databricks-uc")
client = get_deploy_client("databricks")

endpoint = client.create_endpoint(
  name=f"{endpointname}",
  config={
    "served_entities": [
        {
            "entity_name": f"{catalog}.{schema}.{model_name}",
            "entity_version": "1",
            "workload_size": "Small",
            "scale_to_zero_enabled": True
        }
    ],
    "traffic_config": {
        "routes": [
            {
                "served_model_name": f"{model_name}-1",
                "traffic_percentage": 100
            }
        ]
    }
  }
)

Pontuando um ponto de extremidade do modelo

Para pontuar seu modelo, envie solicitações para o ponto de extremidade de serviço do modelo.

Recursos adicionais

Exemplos de blocos de notas

Os blocos de anotações a seguir incluem diferentes modelos registrados no Databricks que você pode usar para começar a trabalhar com pontos de extremidade de serviço de modelo.

Os exemplos de modelo podem ser importados para o espaço de trabalho seguindo as instruções em Importar um bloco de anotações. Depois de escolher e criar um modelo a partir de um dos exemplos, registre-o no Registro do Modelo MLflow e siga as etapas do fluxo de trabalho da interface do usuário para servir o modelo.

Treine e registre um modelo scikit-learn para modelo de notebook

Obter o bloco de notas

Treine e registre um modelo HuggingFace para notebook de serviço de modelo

Obter o bloco de notas