Dimensione os nós de inferência através da escala automática

Quando implementa um modelo para inferência online como um DeployedModel, pode configurar os nós de inferência para serem dimensionados automaticamente. Para tal, defina dedicatedResources.maxReplicaCount para um valor superior a dedicatedResources.minReplicaCount.

Quando configura um DeployedModel, tem de definir dedicatedResources.minReplicaCount como, pelo menos, 1. Por outras palavras, não pode configurar o DeployedModel para ser dimensionado para 0 nós de inferência quando não está a ser usado.

Em alternativa, se aceitar usar a funcionalidade Scale To Zero (Pré-visualização), o campo dedicatedResources.minReplicaCount pode ser definido como 0 e a carga de trabalho é dimensionada para zero réplicas quando não existe tráfego no ponto final. Para mais detalhes, consulte o artigo Reduza a zero.

Por predefinição, a operação de implementação só é considerada bem-sucedida se o número de nós de inferência atingir dedicatedResources.minReplicaCount antes do valor de tempo limite do pedido de implementação. Caso contrário, a implementação é marcada como falhada e os recursos subjacentes são libertados.

Implementação e mutação parcialmente bem-sucedidas

Pode modificar o comportamento de implementação predefinido definindo dedicatedResources.requiredReplicaCount para um valor inferior a dedicatedResources.minReplicaCount. Neste caso, quando o número de nós de inferência atinge dedicatedResources.requiredReplicaCount, a operação de implementação é marcada como bem-sucedida, embora ainda não esteja concluída. A implementação continua até atingir dedicatedResources.minReplicaCount. Se não for atingido o valor dedicatedResources.minReplicaCount antes da hora do pedido de implementação, a operação continua a ser bem-sucedida, mas é devolvida uma mensagem de erro para as réplicas com falhas em DeployedModel.status.message.

A quota para a publicação de modelos personalizados é calculada com base na utilização em tempo real do modelo implementado de recursos de computação. Se a soma de maxReplicaCount para todas as implementações no seu projeto for superior à quota do projeto, algumas implementações podem não ser dimensionadas automaticamente devido ao esgotamento da quota.

Os pontos finais são dimensionados para cima e para baixo por máquina, mas a quota é calculada por CPU ou GPU. Por exemplo, se o seu modelo for implementado no tipo de máquina, cada réplica ativa conta como 24 CPUs e 2 GPUs em relação à quota do seu projeto.a2-highgpu-2g Para mais informações, consulte o artigo Quota e limites.

Os nós de inferência para inferência em lote não são dimensionados automaticamente. O Vertex AI usa BatchDedicatedResources.startingReplicaCount e ignora BatchDedicatedResources.maxReplicaCount.

Utilização e configuração do alvo

Por predefinição, se implementar um modelo sem recursos de GPU dedicados, o Vertex AI dimensiona automaticamente o número de réplicas para cima ou para baixo, de modo que a utilização da CPU corresponda ao valor alvo predefinido de 60%.

Por predefinição, se implementar um modelo com recursos de GPU dedicados (se machineSpec.accelerator_count for superior a 0), o Vertex AI dimensiona automaticamente o número de réplicas para cima ou para baixo, de modo que a utilização da CPU ou da GPU, consoante o que for mais elevado, corresponda ao valor alvo predefinido de 60%. Por conseguinte, se o débito de inferência estiver a causar uma utilização elevada da GPU, mas não uma utilização elevada da CPU, o Vertex AI é dimensionado verticalmente e a utilização da CPU é muito baixa, o que é visível na monitorização. Por outro lado, se o seu contentor personalizado estiver a usar a GPU de forma insuficiente, mas tiver um processo não relacionado que aumente a utilização da CPU para mais de 60%, o Vertex AI é dimensionado, mesmo que isso não seja necessário para atingir os objetivos de QPS e latência.

Pode substituir a métrica e o objetivo do limite predefinidos especificando autoscalingMetricSpecs. Tenha em atenção que, se a sua implementação estiver configurada para ser dimensionada apenas com base na utilização da CPU, não vai ser dimensionada, mesmo que a utilização da GPU seja elevada.

As seguintes métricas de dimensionamento automático são suportadas:

• Utilização da CPU (aiplatform.googleapis.com/prediction/online/cpu/utilization): dimensiona-se com base na utilização da CPU. A respetiva unidade é a utilização da CPU por réplica. O valor de destino é uma percentagem (0-100). O valor de destino predefinido é 60%.
• Utilização da GPU (aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle): dimensiona-se com base na utilização da GPU. A respetiva unidade é a utilização da GPU por réplica. O valor de destino é uma percentagem (0-100). O valor de destino predefinido é 60%.
• Contagem de pedidos (aiplatform.googleapis.com/prediction/online/request_count): dimensiona-se com base no número de pedidos. A respetiva unidade é pedidos por minuto por réplica. O valor de destino é um número inteiro. Esta métrica está desativada por predefinição.
• Tamanho da fila do Pub/Sub (pré-visualização, sem suporte da CLI do Google Cloud) (pubsub.googleapis.com/subscription/num_undelivered_messages): dimensiona com base no número de mensagens não entregues de uma subscrição do Pub/Sub. A respetiva unidade é o número de mensagens não entregues por réplica. O valor de destino é um número inteiro. Esta métrica está desativada por predefinição.

Quando configurar o dimensionamento automático, use METRIC_NAME para o identificador da métrica e TARGET_THRESHOLD para o valor de destino.

Configure o dimensionamento automático durante a implementação

Para configurar o dimensionamento automático ao implementar um modelo, use uma das seguintes interfaces:

gcloud ai endpoints deploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION \
    --model=MODEL_ID \
    --display-name=DEPLOYED_MODEL_DISPLAY_NAME \
    --machine-type=MACHINE_TYPE \
    --accelerator-type=ACCELERATOR_TYPE \
    --accelerator-count=ACCELERATOR_COUNT \
    --min-replica-count=MIN_REPLICA_COUNT \
    --max-replica-count=MAX_REPLICA_COUNT \
    --autoscaling-metric-specs=METRIC_NAME_GCLOUD=TARGET_THRESHOLD

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:deployModel

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_DISPLAY_NAME",
    "dedicatedResources": {
      "machineSpec": {
        "machineType": "MACHINE_TYPE",
        "acceleratorType": "ACCELERATOR_TYPE",
        "acceleratorCount": ACCELERATOR_COUNT
      },
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD
        }
      ]
    }
  }
}

      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

from google.cloud import aiplatform

# Initialize Vertex AI
aiplatform.init(project="PROJECT_ID", location="LOCATION")

# Get the model from Model Registry
model = aiplatform.Model("MODEL_ID")

# Get the endpoint
endpoint = aiplatform.Endpoint("ENDPOINT_ID")

# Deploy the model to the endpoint
model.deploy(
  endpoint=endpoint,
  machine_type="MACHINE_TYPE",
  accelerator_type="ACCELERATOR_TYPE",
  accelerator_count=ACCELERATOR_COUNT,
  min_replica_count=MIN_REPLICA_COUNT,
  max_replica_count=MAX_REPLICA_COUNT,
  autoscaling_target_request_count_per_minute=TARGET_THRESHOLD,
)

from google.cloud import aiplatform_v1beta1 as aiplatform

# Initialize Vertex AI
aiplatform.init(project="PROJECT_ID", location="LOCATION")

# Get the model from Model Registry
model = aiplatform.Model("MODEL_ID")

# Get the endpoint
endpoint = aiplatform.Endpoint("ENDPOINT_ID")

# Deploy the model to the endpoint
model.deploy(
  endpoint=endpoint,
  machine_type="MACHINE_TYPE",
  accelerator_type="ACCELERATOR_TYPE",
  accelerator_count=ACCELERATOR_COUNT,
  min_replica_count=MIN_REPLICA_COUNT,
  max_replica_count=MAX_REPLICA_COUNT,
  autoscaling_target_pubsub_num_undelivered_messages=TARGET_THRESHOLD,
  autoscaling_pubsub_subscription_labels={
      "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
      "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
  },
)

Atualize a configuração do redimensionamento automático

Para atualizar uma configuração de ajuste automático existente, use uma das seguintes interfaces:

PATCH https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:mutateDeployedModel

{
  "deployedModel": {
    "id": "DEPLOYED_MODEL_ID",
    "dedicatedResources": {
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD
        }
      ]
    }
  },
  "updateMask": {
    "paths": [
      "dedicated_resources.min_replica_count",
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs"
    ]
  }
}

      "autoscalingMetricSpecs": [
        {
          "metricName": "METRIC_NAME",
          "target": TARGET_THRESHOLD,
          "monitoredResourceLabels": {
            "project_id": "PUBSUB_SUBSCRIPTION_PROJECT_ID",
            "subscription_id": "PUBSUB_SUBSCRIPTION_ID"
          },
        }
      ]

Escalabilidade para zero (pré-visualização)

A funcionalidade de redução a zero permite-lhe dimensionar automaticamente as implementações do servidor do modelo para zero réplicas quando não existe tráfego, o que resulta na não faturação durante este período.

Quando o tráfego atinge o ponto final reduzido de destino, é recebida uma resposta 429 - Model is not yet ready for inference. Wait and then try your request again, o pedido é ignorado e é enviado um sinal de aumento ao servidor do modelo de destino.

Isto faz com que o servidor do modelo seja dimensionado de zero para o valor que estiver especificado no campo DedicatedResources.initial_replica_count. O valor predefinido é 1.

Esta funcionalidade foi concebida para os seguintes exemplos de utilização:

• Implementações com longos períodos sem tráfego de forma regular.
• Pontos finais que recebem normalmente tráfego durante o horário de funcionamento e ficam inativos noutras alturas.

Ativação e utilização

Não é possível ativar a funcionalidade de redução a zero em pontos finais públicos partilhados. Todos os outros tipos de pontos finais são compatíveis.

Para ativar a opção Scale To Zero, especifique min_replica_count=0 na secção DedicatedResources do seu pedido deploy-model (segmentando a versão v1beta1 da API Vertex Prediction).

Parâmetros opcionais

Em DedicatedResources, pode especificar um valor initial_replica_count entre 1 e max_replica_count (inclusive).

Também foi adicionada uma nova secção ScaleToZeroSpec a DedicatedResources que permite a configuração de dois parâmetros relacionados com a redução a zero:

• min_scaleup_period: duração (em segundos) antes de um servidor de modelos ser inscrito na avaliação de redução a zero. A implementação não tenta reduzir novamente para zero réplicas até que esta duração termine, mesmo que não haja tráfego. Isto permite um valor de buffer durante a implementação inicial e os eventos de expansão subsequentes antes de o tráfego ser verificado em relação ao ponto final de destino (o que pode resultar na redução da implementação).
  • Valor predefinido: 1 hora (3600 s)
  • Valor mínimo: 5 minutos (300 s)
  • Valor máximo: 8 horas (28 800 s).
• idle_scaledown_period: duração (em segundos) sem tráfego antes de reduzir o número de réplicas do servidor do modelo alvo para zero.
  • Valor predefinido: 1 hora (3600 s)
  • Valor mínimo: 5 minutos (300 s)
  • Valor máximo: 8 horas (28 800 s).

Comportamentos esperados

Um pedido enviado a um modelo reduzido devolve uma resposta 429 com Model is not yet ready for inference. Please wait and then try your request again.

Aguarde e, em seguida, tente novamente o seu pedido. Tenha em atenção que todos os pedidos enviados nesta fase serão ignorados.

Limitações

• A funcionalidade Scale To Zero só é compatível com implementações de modelo único e um modelo por ponto final.
• Não é possível ativar a opção Reduzir a zero em pontos finais públicos partilhados. Todos os outros tipos de pontos finais são compatíveis.
• Sem reservas, é possível ter ruturas de stock quando aumenta o número de máquinas a partir de um estado reduzido (consoante o tipo de máquina).

• Os DeployedModels que são dimensionados para zero durante mais de 30 dias (por não receberem tráfego) estão sujeitos à anulação da implementação automática.

gcloud beta ai endpoints deploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION \
    --model=MODEL_ID \
    --display-name=DEPLOYED_MODEL_DISPLAY_NAME \
    --machine-type=MACHINE_TYPE \
    --accelerator-type=ACCELERATOR_TYPE \
    --accelerator-count=ACCELERATOR_COUNT \
    --min-replica-count=MIN_REPLICA_COUNT \
    --max-replica-count=MAX_REPLICA_COUNT \
    --min-scaleup-period=300s \
    --idle-scaledown-period=300s

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:deployModel

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_DISPLAY_NAME",
    "dedicatedResources": {
      "machineSpec": {
        "machineType": "MACHINE_TYPE",
        "acceleratorType": "ACCELERATOR_TYPE",
        "acceleratorCount": ACCELERATOR_COUNT
      },
      "minReplicaCount": MIN_REPLICA_COUNT,
      "maxReplicaCount": MAX_REPLICA_COUNT,
      "scale_to_zero_spec": {
          "min_scaleup_period": "300s",
          "idle_scaledown_period": "300s",
      },
    }
  }
}

from google.cloud import aiplatform

# Initialize Vertex AI
aiplatform.init(project="PROJECT_ID", location="LOCATION")

# Get the model from Model Registry
model = aiplatform.Model("MODEL_ID")

# Get the endpoint
endpoint = aiplatform.Endpoint("ENDPOINT_ID")

# Deploy the model to the endpoint
model.deploy(
  endpoint=endpoint,
  machine_type="MACHINE_TYPE",
  accelerator_type="ACCELERATOR_TYPE",
  accelerator_count=ACCELERATOR_COUNT
  min_replica_count=MIN_REPLICA_COUNT,
  max_replica_count=MAX_REPLICA_COUNT,
  autoscaling_target_request_count_per_minute=TARGET_THRESHOLD,
)

import google.auth.transport.requests
import urllib3

# pip install google-cloud-aiplatform for this dependency
from google.cloud import aiplatform
from google.cloud.aiplatform_v1beta1.services import endpoint_service # For EndpointServiceClient
from google.cloud.aiplatform_v1beta1 import types as aiplatform_v1beta1_types # For message types

PROJECT_NUMBER = "PROJECT_ID"
LOCATION = "LOCATION"
ENDPOINT_DISPLAY_NAME = "stz-sdk-test"
MODEL_ID="MODEL_ID"

# Full resource name of your existing model in Vertex AI Model Registry
# e.g., "projects/your-gcp-project-id/locations/us-central1/models/your-model-id"
MODEL_RESOURCE_NAME = f"projects/{PROJECT_NUMBER}/locations/{LOCATION}/models/{MODEL_ID}"

# Deployment settings
MACHINE_TYPE = "MACHINE_TYPE"
ACCELERATOR_TYPE ="ACCELERATOR_TYPE",
ACCELERATOR_COUNT =ACCELERATOR_COUNT

# Disable InsecureRequestWarning for the requests part as in your snippet
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# The AI Platform services require regional API endpoints.
client_options = {"api_endpoint": f"{LOCATION}-aiplatform.googleapis.com"}
endpoint_service_client = endpoint_service.EndpointServiceClient(client_options=client_options)

def main():
    aiplatform.init(project=PROJECT_NUMBER, location=LOCATION)
    model_to_deploy = aiplatform.Model(model_name=MODEL_RESOURCE_NAME) # Initialize model object

    try:
        # # --- 1. Create an Endpoint ---
        print(f"\nCreating endpoint '{ENDPOINT_DISPLAY_NAME}'...")
        endpoint = aiplatform.Endpoint.create(
            display_name=ENDPOINT_DISPLAY_NAME,
            project=PROJECT_NUMBER,
            location=LOCATION,
            sync=True, # Wait for creation to complete
            dedicated_endpoint_enabled=True,
        )
        print(f"Endpoint created: {endpoint.resource_name}")
        endpoint_numeric_id = endpoint.name # This is the numeric ID
        print(f"Numeric Endpoint ID for URL: {endpoint_numeric_id}")

        print(f"\nFetching model details for: {MODEL_RESOURCE_NAME}")
        model_to_deploy = aiplatform.Model(model_name=MODEL_RESOURCE_NAME)

        # --- 2. Deploy the Model ---
        print(f"\nDeploying model '{model_to_deploy.resource_name}' to endpoint '{endpoint.display_name}'...")
        deployed_model_config = aiplatform_v1beta1_types.DeployedModel(
            model=model_to_deploy.resource_name,
            dedicated_resources=aiplatform_v1beta1_types.DedicatedResources(
                machine_spec=aiplatform_v1beta1_types.MachineSpec(
                    machine_type=MACHINE_TYPE,
                    accelerator_type=ACCELERATOR_TYPE,
                    accelerator_count=ACCELERATOR_COUNT,
                ),
                initial_replica_count=1,
                min_replica_count=0,
                max_replica_count=1,
                scale_to_zero_spec=aiplatform_v1beta1_types.DedicatedResources.ScaleToZeroSpec(
                    min_scaleup_period=300,
                    idle_scaledown_period=300,
                )
            ),
        )

        deploy_model_request = aiplatform_v1beta1_types.DeployModelRequest(
            endpoint=endpoint.resource_name,
            deployed_model=deployed_model_config,
        )

        # Alternatively, if you've got an existing endpoint, use:
        # endpoint_path = endpoint_service_client.endpoint_path(
        #     project=PROJECT_NUMBER, location=LOCATION, endpoint={ENDPOINT_ID}
        # )

        # deploy_model_request = aiplatform_v1beta1_types.DeployModelRequest(
        #     endpoint=endpoint_path,
        #     deployed_model=deployed_model_config,
        # )

        print("\nSending v1beta1 DeployModelRequest...")
        operation = endpoint_service_client.deploy_model(request=deploy_model_request)

        print("Waiting for v1beta1 update deploy model operation to complete (this can take several minutes)...")
        operation.result()
        print("Model deployed successfully.")

    except Exception as e:
        print(f"\nAn error occurred: {e}")

if __name__ == "__main__":
    main()

Faça a gestão da utilização de recursos

Pode monitorizar o seu ponto final para acompanhar métricas como a utilização da CPU e do acelerador, o número de pedidos, a latência e o número atual e de destino de réplicas. Estas informações podem ajudar a compreender a utilização de recursos e o comportamento de escalabilidade do seu ponto final.

Tenha em atenção que cada réplica executa apenas um único contentor. Isto significa que, se um contentor de inferência não conseguir usar totalmente o recurso de computação selecionado, como código de thread único para uma máquina com vários núcleos ou um modelo personalizado que chama outro serviço como parte da inferência, os seus nós podem não ser dimensionados.

Por exemplo, se estiver a usar o FastAPI ou qualquer servidor de modelos que tenha um número configurável de trabalhadores ou threads, existem muitos casos em que ter mais do que um trabalhador pode aumentar a utilização de recursos, o que melhora a capacidade de o serviço dimensionar automaticamente o número de réplicas.

Geralmente, recomendamos que comece com um trabalhador ou um segmento por núcleo. Se notar que a utilização da CPU é baixa, especialmente sob carga elevada, ou que o seu modelo não está a ser dimensionado porque a utilização da CPU é baixa, aumente o número de trabalhadores. Por outro lado, se notar que a utilização é demasiado elevada e as latências aumentam mais do que o esperado sob carga, experimente usar menos trabalhadores. Se já estiver a usar apenas um único trabalhador, experimente usar um tipo de máquina mais pequeno.

Comportamento de dimensionamento e atraso

A Vertex AI ajusta o número de réplicas a cada 15 segundos com base nos dados da janela de 5 minutos anterior. Para cada ciclo de 15 segundos, o sistema mede a utilização do servidor e gera um número de réplicas de destino com base na seguinte fórmula:

target # of replicas = Ceil(current # of replicas * (current utilization / target utilization))

Por exemplo, se tiver 2 réplicas a serem usadas a 100%, o alvo é 4:

4 = Ceil(3.33) = Ceil(2 * (100% / 60%))

Outro exemplo: se tiver 10 réplicas e a utilização descer para 1%, o alvo é 1:

1 = Ceil(.167) = Ceil(10 * (1% / 60%))

No final de cada ciclo de 15 segundos, o sistema ajusta o número de réplicas para corresponder ao valor alvo mais elevado da janela de 5 minutos anterior. Tenha em atenção que, como é escolhido o valor alvo mais elevado, o seu ponto final não é reduzido se houver um aumento súbito na utilização durante esse período de 5 minutos, mesmo que a utilização geral seja muito baixa. Por outro lado, se o sistema precisar de ser expandido, fá-lo no prazo de 15 segundos, porque é escolhido o valor alvo mais elevado em vez da média.

Tenha em atenção que, mesmo depois de o Vertex AI ajustar o número de réplicas, demora algum tempo a iniciar ou desativar as réplicas. Assim, existe um atraso adicional antes de o ponto final se poder ajustar ao tráfego. Os principais fatores que contribuem para este tempo incluem o seguinte:

• O tempo para aprovisionar e iniciar as VMs do Compute Engine
• O tempo para transferir o contentor do registo
• O tempo para carregar o modelo a partir do armazenamento

A melhor forma de compreender o comportamento de escalabilidade do seu modelo no mundo real é executar um teste de carga e otimizar as caraterísticas importantes para o seu modelo e o seu exemplo de utilização. Se o dimensionamento automático não estiver a aumentar a escala com rapidez suficiente para a sua aplicação, aprovisione min_replicas suficientes para processar o tráfego de base esperado.

Atualize a configuração do escalonamento

Se especificou DedicatedResources ou AutomaticResources quando implementou o modelo, pode atualizar a configuração do dimensionamento sem reimplementar o modelo chamando mutateDeployedModel.

Por exemplo, o seguinte pedido atualiza max_replica, autoscaling_metric_specs e desativa o registo do contentor.

{
  "deployedModel": {
    "id": "2464520679043629056",
    "dedicatedResources": {
      "maxReplicaCount": 9,
      "autoscalingMetricSpecs": [
        {
          "metricName": "aiplatform.googleapis.com/prediction/online/cpu/utilization",
          "target": 50
        }
      ]
    },
    "disableContainerLogging": true
  },
  "update_mask": {
    "paths": [
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs",
      "disable_container_logging"
    ]
  }
}

Notas de utilização:

• Não pode alterar o tipo de máquina nem mudar de DedicatedResources para AutomaticResources ou vice-versa. Os únicos campos de configuração de escalonamento que pode alterar são: min_replica, max_replica, required_replica e AutoscalingMetricSpec (apenas DedicatedResources).
• Tem de indicar todos os campos que precisa de atualizar em updateMask. Os campos não indicados são ignorados.
• O DeployedModel tem de estar no estado DEPLOYED. Pode haver, no máximo, uma operação mutate ativa por modelo implementado.
• mutateDeployedModel também lhe permite ativar ou desativar o registo do contentor. Para mais informações, consulte o artigo Registo de inferências online.