Esta página foi traduzida pela API Cloud Translation.

Implemente um modelo num ponto final

Tem de implementar um modelo num ponto final antes de poder usar esse modelo para publicar previsões online. A implementação de um modelo associa recursos físicos para publicar previsões online com baixa latência.

Esta página descreve os passos que tem de seguir para implementar um modelo num ponto final usando a previsão online.

Antes de começar

Antes de implementar o modelo num ponto final, exporte os artefactos do modelo para previsão e certifique-se de que cumpre todos os pré-requisitos dessa página.

Crie um conjunto de recursos

Um recurso personalizado ResourcePoolpermite-lhe ter um controlo detalhado sobre o comportamento do seu modelo. Pode definir definições como as seguintes:

Configurações de escalabilidade automática.
O tipo de máquina, que define os requisitos de CPU e memória.
Opções de acelerador, como recursos de GPU.

O tipo de máquina é essencial para o pedido de especificação do node pool que envia para criar o cluster de previsão.

Para o conjunto de recursos do modelo implementado, a quantidade e o tipo de acelerador determinam a utilização da GPU. O tipo de máquina apenas determina os recursos de CPU e memória pedidos. Por este motivo, quando inclui aceleradores de GPU na especificação ResourcePool, o campo machineType controla os requisitos de CPU e memória para o modelo, enquanto o campo acceleratorType controla a GPU. Além disso, o campo acceleratorCount controla o número de fatias da GPU.

ResourcePoolacceleratorType

Siga estes passos para criar um ResourcePoolrecurso personalizado:

Crie um ficheiro YAML que defina o ResourcePool recurso personalizado. Os exemplos seguintes contêm ficheiros YAML para conjuntos de recursos com aceleradores de GPU (modelos baseados em GPU) e sem aceleradores de GPU (modelos baseados em CPU):

Modelos baseados em GPU

  apiVersion: prediction.aiplatform.gdc.goog/v1
  kind: ResourcePool
  metadata:
    name: RESOURCE_POOL_NAME
    namespace: PROJECT_NAMESPACE
  spec:
    resourcePoolID: RESOURCE_POOL_NAME
    enableContainerLogging: false
    dedicatedResources:
      machineSpec:
        # The system adds computing overhead to the nodes for mandatory components.
        # Choose a machineType value that allocates fewer CPU and memory resources
        # than those used by the nodes in the prediction cluster.
        machineType: a2-highgpu-1g-gdc
        acceleratorType: nvidia-a100-80gb
        # The accelerator count is a slice of the requested virtualized GPUs.
        # The value corresponds to one-seventh of 80 GB of GPUs for each count.
        acceleratorCount: 2
      autoscaling:
        minReplica: 2
        maxReplica: 10

Modelos baseados na CPU

  apiVersion: prediction.aiplatform.gdc.goog/v1
  kind: ResourcePool
  metadata:
    name: RESOURCE_POOL_NAME
    namespace: PROJECT_NAMESPACE
  spec:
    resourcePoolID: RESOURCE_POOL_NAME
    enableContainerLogging: false
    dedicatedResources:
      machineSpec:
        # The system adds computing overhead to the nodes for mandatory components.
        # Choose a machineType value that allocates fewer CPU and memory resources
        # than those used by the nodes in the prediction cluster.
        machineType: n2-highcpu-8-gdc
      autoscaling:
        minReplica: 2
        maxReplica: 10

Substitua o seguinte:

RESOURCE_POOL_NAME: o nome que quer dar ao ficheiro de definição ResourcePool.
PROJECT_NAMESPACE: o nome do espaço de nomes do projeto associado ao cluster de previsão.

Modifique os valores nos campos dedicatedResources de acordo com as necessidades dos seus recursos e o que está disponível no cluster de previsão.

Aplique o ficheiro de definição ResourcePool ao cluster de previsão:
```
kubectl --kubeconfig PREDICTION_CLUSTER_KUBECONFIG apply -f RESOURCE_POOL_NAME.yaml
```
Substitua o seguinte:
- PREDICTION_CLUSTER_KUBECONFIG: o caminho para o ficheiro kubeconfig no cluster de previsão.
- RESOURCE_POOL_NAME: o nome do ficheiro de definição ResourcePool.

Quando cria o recurso personalizado ResourcePool, a API Kubernetes e o serviço de webhook validam o ficheiro YAML e comunicam o êxito ou a falha. O operador de previsão aprovisiona e reserva os seus recursos do conjunto de recursos quando implementa os seus modelos num ponto final.

Implemente o modelo num ponto final

Se tiver um conjunto de recursos, pode implementar mais do que um modelo num ponto final e pode implementar um modelo em mais do que um ponto final. Implemente um modelo de previsão segmentando contentores suportados. Consoante o ponto final já exista ou não, escolha um dos dois métodos seguintes:

Implemente um modelo num novo ponto final
Implemente um modelo num ponto final existente

Implemente um modelo num novo ponto final

Siga estes passos para implementar um modelo de previsão num novo ponto final:

Crie um ficheiro YAML que defina um DeployedModel recurso personalizado:

TensorFlow

O ficheiro YAML seguinte mostra uma configuração de exemplo para um modelo do TensorFlow:

apiVersion: prediction.aiplatform.gdc.goog/v1
kind: DeployedModel
metadata:
  name: DEPLOYED_MODEL_NAME
  namespace: PROJECT_NAMESPACE
spec:
  # The endpoint path structure is endpoints/<endpoint-id>
  endpointPath: endpoints/PREDICTION_ENDPOINT
  modelSpec:
    # The artifactLocation field must be the s3 path to the folder that
    # contains the various model versions.
    # For example, s3://my-prediction-bucket/tensorflow
    artifactLocation: s3://PATH_TO_MODEL
    # The value in the id field must be unique to each model.
    id: img-detection-model
    modelDisplayName: my_img_detection_model
    # The model resource name structure is models/<model-id>/<model-version-id>
    modelResourceName: models/img-detection-model/1
    # The model version ID must match the name of the first folder in
    # the artifactLocation bucket, inside the 'tensorflow' folder.
    # For example, if the bucket path is
    # s3://my-prediction-bucket/tensorflow/1/,
    # then the value for the model version ID is "1".
    modelVersionID: "1"
    modelContainerSpec:
      args:
      - --model_config_file=/models/models.config
      - --rest_api_port=8080
      - --port=8500
      - --file_system_poll_wait_seconds=30
      - --model_config_file_poll_wait_seconds=30
      command:
      - /bin/tensorflow_model_server
      # The image URI field must contain one of the following values:
      # For CPU-based models: gcr.io/aiml/prediction/containers/tf2-cpu.2-14:latest
      # For GPU-based models: gcr.io/aiml/prediction/containers/tf2-gpu.2-14:latest
      imageURI: gcr.io/aiml/prediction/containers/tf2-gpu.2-14:latest
      ports:
      - 8080
      grpcPorts:
      - 8500
  resourcePoolRef:
    kind: ResourcePool
    name: RESOURCE_POOL_NAME
    namespace: PROJECT_NAMESPACE

Substitua o seguinte:

DEPLOYED_MODEL_NAME: o nome que quer dar ao ficheiro de definição DeployedModel.
PROJECT_NAMESPACE: o nome do espaço de nomes do projeto associado ao cluster de previsão.
PREDICTION_ENDPOINT: o nome que quer dar ao novo ponto final, como my-img-prediction-endpoint.
PATH_TO_MODEL: o caminho para o seu modelo no contentor de armazenamento.
RESOURCE_POOL_NAME: o nome que atribuiu ao ficheiro de definição quando criou um conjunto de recursos para alojar o modelo.ResourcePool

Modifique os valores nos campos restantes de acordo com o seu modelo de previsão.

PyTorch

O ficheiro YAML seguinte mostra uma configuração de exemplo para um modelo do PyTorch:

apiVersion: prediction.aiplatform.gdc.goog/v1
kind: DeployedModel
metadata:
  name: DEPLOYED_MODEL_NAME
  namespace: PROJECT_NAMESPACE
spec:
  endpointPath: PREDICTION_ENDPOINT
  endpointInfo:
    id: PREDICTION_ENDPOINT
  modelSpec:
    # The artifactLocation field must be the s3 path to the folder that
    # contains the various model versions.
    # For example, s3://my-prediction-bucket/pytorch
    artifactLocation: s3://PATH_TO_MODEL
    # The value in the id field must be unique to each model.
    id: "pytorch"
    modelDisplayName: my-pytorch-model
    # The model resource name structure is models/<model-id>/<model-version-id>
    modelResourceName: models/pytorch/1
    modelVersionID: "1"
    modelContainerSpec:
      # The image URI field must contain one of the following values:
      # For CPU-based models: gcr.io/aiml/prediction/containers/pytorch-cpu.2-4:latest
      # For GPU-based models: gcr.io/aiml/prediction/containers/pytorch-gpu.2-4:latest
      imageURI: gcr.io/aiml/prediction/containers/pytorch-cpu.2-4:latest
      ports:
      - 8080
      grpcPorts:
      - 7070
  sharesResourcePool: false
  resourcePoolRef:
    kind: ResourcePool
    name: RESOURCE_POOL_NAME
    namespace: PROJECT_NAMESPACE

Substitua o seguinte:

DEPLOYED_MODEL_NAME: o nome que quer dar ao ficheiro de definição DeployedModel.
PROJECT_NAMESPACE: o nome do espaço de nomes do projeto associado ao cluster de previsão.
PREDICTION_ENDPOINT: o nome que quer dar ao novo ponto final, como my-img-prediction-endpoint.
PATH_TO_MODEL: o caminho para o seu modelo no contentor de armazenamento.
RESOURCE_POOL_NAME: o nome que atribuiu ao ficheiro de definição quando criou um conjunto de recursos para alojar o modelo.ResourcePool

Modifique os valores nos campos restantes de acordo com o seu modelo de previsão.

Aplique o ficheiro de definição DeployedModel ao cluster de previsão:
```
kubectl --kubeconfig PREDICTION_CLUSTER_KUBECONFIG apply -f DEPLOYED_MODEL_NAME.yaml
```
Substitua o seguinte:
- PREDICTION_CLUSTER_KUBECONFIG: o caminho para o ficheiro kubeconfig no cluster de previsão.
- DEPLOYED_MODEL_NAME: o nome do ficheiro de definição DeployedModel.
Quando cria o recurso personalizado DeployedModel, a API Kubernetes e o serviço de webhook validam o ficheiro YAML e comunicam o êxito ou a falha. O operador de previsão reconcilia o recurso personalizado DeployedModel e serve-o no cluster de previsão.

Sugestão: pode verificar o estado do recurso personalizado DeployedModel e garantir que está pronto para aceitar pedidos de previsão através do comando kubectl --kubeconfig PREDICTION_CLUSTER_KUBECONFIG get -f DEPLOYED_MODEL_NAME.yaml -o jsonpath='{.status.primaryCondition}'. O DeployedModel tem de estar num estado pronto.
Crie um ficheiro YAML que defina um Endpoint recurso personalizado.

O ficheiro YAML seguinte mostra uma configuração de exemplo:
```
apiVersion: aiplatform.gdc.goog/v1
kind: Endpoint
metadata:
  name: ENDPOINT_NAME
  namespace: PROJECT_NAMESPACE
spec:
  createDns: true
  id: PREDICTION_ENDPOINT
  destinations:
    - serviceRef:
        kind: DeployedModel
        name: DEPLOYED_MODEL_NAME
        namespace: PROJECT_NAMESPACE
      trafficPercentage: 50
      grpcPort: 8501
      httpPort: 8081
    - serviceRef:
        kind: DeployedModel
        name: DEPLOYED_MODEL_NAME_2
        namespace: PROJECT_NAMESPACE
      trafficPercentage: 50
      grpcPort: 8501
      httpPort: 8081
```
Substitua o seguinte:
- ENDPOINT_NAME: o nome que quer dar ao ficheiro de definição Endpoint.
- PROJECT_NAMESPACE: o nome do espaço de nomes do projeto associado ao cluster de previsão.
- PREDICTION_ENDPOINT: o nome do novo ponto final. Definiu este nome no ficheiro de definição DeployedModel.
- DEPLOYED_MODEL_NAME: o nome que atribuiu ao ficheiro de definição.DeployedModel
Pode ter um ou mais destinos serviceRef. Se tiver um segundo objeto serviceRef, adicione-o ao ficheiro YAML no campo destinations e substitua DEPLOYED_MODEL_NAME_2 pelo nome que deu ao segundo ficheiro de definição DeployedModel que criou. Continue a adicionar ou remover objetos serviceRef conforme necessário, consoante a quantidade de modelos que está a implementar.

Defina os campos trafficPercentage com base na forma como quer dividir o tráfego entre os modelos neste ponto final. Modifique os valores nos campos restantes de acordo com as configurações do seu ponto final.
Aplique o ficheiro de definição Endpoint ao cluster de previsão:
```
kubectl --kubeconfig PREDICTION_CLUSTER_KUBECONFIG apply -f ENDPOINT_NAME.yaml
```
Substitua ENDPOINT_NAME pelo nome do ficheiro de definição Endpoint.

Para obter o caminho do URL do ponto final do modelo de previsão, execute o seguinte comando:

kubectl --kubeconfig PREDICTION_CLUSTER_KUBECONFIG get endpoint PREDICTION_ENDPOINT -n PROJECT_NAMESPACE -o jsonpath='{.status.endpointFQDN}'

Substitua o seguinte:

PREDICTION_CLUSTER_KUBECONFIG: o caminho para o ficheiro kubeconfig no cluster de previsão.
PREDICTION_ENDPOINT: o nome do novo ponto final.
PROJECT_NAMESPACE: o nome do espaço de nomes do projeto de previsão.