Share via

Criar pontos de extremidade de serviço de modelo personalizados

  • Artigo

Este artigo descreve como criar pontos de extremidade de serviço de modelo que atendam modelos personalizados usando o Serviço de Modelo do Databricks.

O Serviço de Modelo do Databricks fornece as seguintes opções para a criação de pontos de extremidade de serviço:

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

Para criar pontos de extremidade que servem modelos de fundação de IA generativos, consulte Criar pontos de extremidade de serviço de modelo de fundação.

Requisitos

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

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

Controle 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.

Você também pode adicionar variáveis de ambiente para armazenar credenciais para o serviço de modelo. Confira Configurar o acesso aos recursos dos pontos de extremidade do serviço de modelo

Criar um ponto de extremidade

Servindo interface do usuário

Você pode criar um ponto de extremidade para o serviço de modelo 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 workspace ou modelos no Catálogo do Unity:

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

  2. Na seção Entidades atendidas

    1. Clique no campo Entidade para abrir o formulário Selecionar entidade atendida.
    2. Selecione o tipo de modelo que você deseja atender. O formulário é atualizado dinamicamente com base em sua seleção.
    3. Selecione qual modelo e versão de modelo você deseja atender.
    4. Selecione o percentual de tráfego a ser roteado para o modelo atendido.
    5. Selecione qual tamanho a computação usar. Você pode usar cálculos de CPU ou GPU nas suas cargas de trabalho. Consulte Tipos de carga de trabalho de GPU para obter mais informações sobre as computações de GPU disponíveis.
    6. Em Expansão de computação, selecione o tamanho da escala horizontal de computação que corresponde ao número de solicitações que esse modelo servido pode processar ao mesmo tempo. Esse número deve ser aproximadamente igual ao tempo de execução do QPS x modelo.
      1. Os tamanhos disponíveis são Pequeno para 0-4 solicitações, Médio para 8 a 16 solicitações e Grande para 16 a 64 solicitações.
    7. Especifique se o ponto de extremidade deve reduzir 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 De serviço do ponto de extremidade 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 dos pontos de extremidade.

O exemplo a seguir cria um ponto de extremidade que atende à primeira versão do modelo ads1 registrada no registro de modelo. Para especificar um modelo do Catálogo do Unity, forneça o nome completo do modelo, incluindo o catálogo pai e o esquema, como catalog.schema.example-model.


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"
    }
  ]
}

A seguir, um exemplo de resposta. O estado do ponto de extremidade config_update é NOT_UPDATING e o modelo servido está em um estado READY.

{
  "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 do Mlflow

implantações de MLflow fornecem 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 pontos de extremidade de serviço. Consulte POST /api/2.0/serving-endpoints para obter os parâmetros de configuração dos pontos de extremidade.


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 é possível:

Tipos de cargas de trabalho GPU

A implantação de 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 workload_type na configuração do ponto de extremidade durante a criação do ponto de extremidade ou como uma atualização de configuração de ponto de extremidade usando a API. Para configurar o 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 e com suporte.

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

Modificar um ponto de extremidade de modelo personalizado

Após 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 uma função fundamenta em quais os recursos são alocados para servir seu modelo.

Até que a nova configuração esteja pronta, a configuração antiga continuará atendendo ao 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 de usuário de serviço.

Servindo 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 ponto de extremidade.

É possível fazer o seguinte:

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

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, um exemplo de atualização da configuração de um 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 do Mlflow

O SDK de Implantações do 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 seguinte exemplo de código usa um modelo do registro de modelo do Catálogo do Unity:

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 de modelo

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

Recursos adicionais

Exemplos de notebook

Os notebooks a seguir incluem diferentes modelos registrados do Databricks que você pode usar para começar a executar os pontos de extremidade do serviço de modelo.

Importe os exemplos de modelos para o workspace seguindo as instruções em Importar um notebook. Depois de escolher e criar um modelo com base em um dos exemplos, registre-o no Registro de Modelo do MLFlow e siga as etapas descritas em Fluxo de trabalho da interface do usuário para fornecimento do modelo.

Treinar e registrar um modelo do Scikit-learn para o notebook de serviço de modelo

Obter notebook

Treinar e registrar um modelo do HuggingFace para o notebook de fornecimento de modelo

Obter notebook