Desenvolver um aplicativo

Nesta página, mostramos como criar um app e combinar componentes, como streams de entrada, modelos para análise e armazenamentos para armazenamento, para uso na plataforma de apps da Vertex AI Vision.

Para criar um app, é preciso considerar as fontes de dados, a análise que você quer fazer e como armazenar os resultados. Um app de ponta a ponta pode ter formas diferentes, dependendo do seu caso de uso. Portanto, a maneira de criar um app depende do seu objetivo.

Antes de começar, avalie seu caso de uso e objetivo do ponto de vista da IA responsável e considere o impacto que seus modelos e aplicativos podem ter nos usuários finais quando algo dá errado. Leia mais sobre os primeiros passos para avaliar seu caso de uso quanto à imparcialidade. Verifique também se o uso da Vertex AI Vision está em conformidade com os Termos de Serviço do Google Cloudou uma variante off-line, e com os Termos de URL incorporados, como a Política de uso aceitável do Google Cloud.

Ao criar seu aplicativo, lembre-se de que as tecnologias de visão de IA podem reforçar ou introduzir desigualdades e afetar direitos humanos fundamentais. O desenvolvimento do aplicativo precisa envolver reflexão ética com base nos valores da sua empresa e diligência prévia legal para seu caso de uso específico, incluindo casos de uso de alto risco. Como em todas as tecnologias, você precisa considerar todas as leis e regulamentações aplicáveis que regem seu uso de tecnologias de IA/ML na região em que está implementando a tecnologia. Os clientes são responsáveis pela diligência necessária para implementar casos de uso considerados de alto risco em uma região específica.

Crie um novo aplicativo

Antes de adicionar componentes como um fluxo ou modelos a um app, é necessário criar o app. Todos os apps precisam conter o seguinte para serem implantados:

• Um nó de entrada de stream (fonte de dados).
• Pelo menos outro nó de componente, como um modelo ou um data warehouse.

Criar um aplicativo personalizado

Criar um aplicativo com um modelo

Adicionar entrada de stream

Um aplicativo precisa conter um nó de stream de vídeo. Não é possível implantar o aplicativo sem adicionar um nó do Streams.

Se o aplicativo não estiver implantado, a atualização da entrada de stream será aplicada automaticamente. Se o app já estiver implantado, você precisa cancelar a implantação e atualizar para que as mudanças sejam aplicadas. Consulte a seção atualizar um app para mais detalhes.

POST https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput

{
  "applicationStreamInputs": [
     {
       "streamWithAnnotation": {
         "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID"
       }
     },
     {
       "streamWithAnnotation": {
         "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID"
       }
     }
   ]
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput" | Select-Object -Expand Content

Adicionar entrada de stream com anotações de nó

Ao criar um fluxo de entrada de aplicativo, é possível adicionar anotações a ele usando a API Vertex AI Vision. Também é possível adicionar anotações a um nó no console doGoogle Cloud .

POST https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput

{
  "applicationStreamInputs": [
    {
      "streamWithAnnotation": {
        "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID",
        "nodeAnnotations": [
          {
            "node": "NODE_NAME",
            "annotations": [
              {
                "id": "ANNOTATION_ID",
                "displayName": "ANNOTATION_DISPLAYNAME",
                "sourceStream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID",
                "type": ANNOTATION_TYPE,
                "activeZone": {
                  "normalizedVertices": {
                    "x": 0.07434944,
                    "y": 0.18061674
                  },
                  "normalizedVertices": {
                    "x": 0.64684016,
                    "y": 0.16079295
                  },
                  "normalizedVertices": {
                    "x": 0.6047088,
                    "y": 0.92070484
                  },
                  "normalizedVertices": {
                    "x": 0.1251549,
                    "y": 0.76651984
                  }
                }
              }
            ]
          }
        ]
      }
    }
  ]
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:addStreamInput" | Select-Object -Expand Content

Remover entrada de stream

POST https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:removeStreamInput

{
  "targetStreamInputs": [
     {
       "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID"
     },
     {
       "stream": "projects/PROJECT/locations/LOCATION_ID/clusters/application-cluster-0/streams/STREAM_ID"
     }
   ]
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:removeStreamInput"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://visionai.googleapis.com/v1/projects/PROJECT/locations/LOCATION_ID/applications/APPLICATION_ID:removeStreamInput" | Select-Object -Expand Content

Adicionar um modelo pré-treinado da Vertex AI Vision

Depois de criar um app, é possível adicionar um modelo e conectá-lo a fluxos, outros modelos ou um data warehouse de mídia.

Há dois tipos de modelos: pré-treinados ou treinados pelo usuário. Da mesma forma, os modelos treinados pelo usuário também podem ser de dois tipos: AutoML ou treinamento personalizado:

• Os modelos pré-treinados realizam um objetivo específico, são treinados com dados generalizados e estão prontos para uso.
• Modelos do AutoML treinados pelo usuário ou personalizados exigem que você identifique e forneça dados de amostra e treine modelos mais adequados ao seu caso de uso específico. Você treina esses modelos usando a Vertex AI, um produto que oferece duas opções de treinamento: modelos treinados pelo AutoML e modelos treinados personalizados. Consulte Escolher um método de treinamento para mais informações.

Use as instruções a seguir para adicionar um modelo pré-treinado da Vertex AI Vision ao gráfico do app.

Adicionar um modelo da Vertex AI treinado pelo usuário

Depois de criar um app, é possível adicionar um modelo e conectá-lo a fluxos, outros modelos ou um data warehouse de mídia.

Há dois tipos de modelos: pré-treinados ou treinados pelo usuário. Da mesma forma, os modelos treinados pelo usuário também podem ser de dois tipos: AutoML ou treinamento personalizado:

• Os modelos pré-treinados realizam um objetivo específico, são treinados com dados generalizados e estão prontos para uso.
• Modelos do AutoML treinados pelo usuário ou personalizados exigem que você identifique e forneça dados de amostra e treine modelos mais adequados ao seu caso de uso específico. Você treina esses modelos usando a Vertex AI, um produto que oferece duas opções de treinamento: modelos treinados pelo AutoML e modelos treinados personalizados. Consulte Escolher um método de treinamento para mais informações.

Adicionar um modelo de streaming de detecção de objetos do AutoML da Vertex AI

Siga estas instruções para adicionar um modelo de streaming de detecção de objetos do Vertex AI AutoML treinado ao gráfico do app.

Antes de treinar um modelo do AutoML da Vertex AI, você precisa preparar os dados de detecção de objetos e criar um conjunto de dados.

Treinar um modelo para usar na Vertex AI Vision

Depois de criar um conjunto de dados com uma coleção representativa de dados na Vertex AI, é possível treinar um modelo para usar na Vertex AI Vision.

Adicionar o modelo treinado ao app

Depois que o treinamento do modelo for concluído, você poderá adicioná-lo ao app da Vertex AI Vision.

Adicionar um modelo personalizado da Vertex AI

Também é possível importar modelos treinados personalizados da Vertex AI para a Vertex AI Vision e usar na análise de dados. Esses modelos treinados de forma personalizada precisam ter as seguintes propriedades:

• O modelo precisa ser sem estado, já que a entrada dele são as imagens que vêm de diferentes instâncias de aplicativos (fluxos) e podem estar fora de ordem. Se você precisar de processamento de streaming com estado, talvez seja necessário manter os estados no seu próprio contêiner.
• O tamanho da entrada do modelo é limitado a 1,5 MB. Consequentemente, a Vertex AI Vision precisa compactar a imagem RGB original em um formato com perda, como JPG.

Use as instruções a seguir para adicionar um modelo de vídeo treinado de forma personalizada da Vertex AI ao gráfico do app.

Para informações sobre como criar um modelo treinado personalizado da Vertex AI com um contêiner personalizado, consulte Usar um contêiner personalizado para previsão.

Especificar um arquivo YAML de instâncias

Ao adicionar um modelo treinado de forma personalizada da Vertex AI, é necessário especificar um arquivo YAML de instâncias (instances.yaml) armazenado no Cloud Storage. Esse arquivo especifica a entrada esperada para o contêiner do modelo.

A Vertex AI envia a solicitação de previsão em um formato:

{
  "instances": [
    <value>|<simple/nested list>|<object>,
    ...
  ]
}

Aqui, instances.yaml define o esquema do payload. Para mais informações, consulte Receber previsões on-line de modelos treinados de forma personalizada.

A Vertex AI Vision só é compatível com modelos treinados de maneira personalizada com exatamente uma entrada de previsão nomeada. Esse tipo de entrada precisa ser uma string JPEG codificada. O esquema da entrada de previsão precisa ser especificado com o arquivo YAML do esquema de instâncias. Esse arquivo YAML de esquema precisa estar no formato de um objeto de esquema OpenAPI.

Por exemplo, o esquema a seguir vai receber a solicitação com a imagem codificada em um campo chamado image_bytes:

properties:
  image_bytes:
    type: string

O modelo personalizado recebe entradas de previsão neste formato:

{
  "instances": [
    {
      "image_bytes" : {
        "b64": "BASE64_ENCODED_IMAGE_BYTES"
      }
    }
  ]
}

Antes de importar o modelo para a Vertex AI Vision, verifique se ele funciona corretamente com essa entrada.

Especificar um arquivo YAML de previsões

Ao adicionar um modelo treinado de forma personalizada da Vertex AI, é possível especificar um arquivo YAML de previsões (predictions.yaml) armazenado no Cloud Storage. Esse arquivo especifica a saída do contêiner do modelo.

Esse arquivo é opcional, mas recomendado para informar à Vertex AI Vision a estrutura de saída do modelo. Por exemplo, o arquivo classification_1.0.0.yaml a seguir descreve informações de saída de um modelo de classificação de imagens:

title: Classification
type: object
description: >
  The predicted AnnotationSpecs.
properties:
  ids:
    type: array
    description: >
      The resource IDs of the AnnotationSpecs that had been identified.
    items:
      type: integer
      format: int64
      enum: [0]  # As values of this enum all AnnotationSpec IDs the Model
      # was trained on will be populated.
  displayNames:
    type: array
    description: >
      The display names of the AnnotationSpecs that had been identified,
      order matches the IDs.
    items:
      type: string
      enum: [""]  # As values of this enum all AnnotationSpec display_names
      # the Model was trained on will be populated.
  confidences:
    type: array
    description: >
      The Model's confidences in correctness of the predicted IDs, higher
      value means higher confidence. Order matches the Ids.
    items:
      type: number
      format: float
      minimum: 0.0
      maximum: 1.0

Adicionar o modelo treinado de forma personalizada

Use o exemplo a seguir para adicionar o modelo treinado personalizado da Vertex AI ao seu app.

Opcional. Anexar metadados do aplicativo

Além dos bytes de imagem, você pode definir attach_application_metadata para pedir à plataforma de apps da Vertex AI Vision que inclua os metadados do aplicativo a serem enviados ao contêiner personalizado.

Os metadados têm o seguinte esquema:

'appPlatformMetadata': {
     'application': STRING;
     'instanceId': STRING;
     'node': STRING;
     'processor': STRING;
   }

Opcional. Adicionar um tópico do Pub/Sub de configuração dinâmica

Para controlar dinamicamente a taxa de frames que o operador personalizado da Vertex envia frames de vídeo para contêineres personalizados da Vertex, crie um tópico do Pub/Sub. Adicione-o à seção Dynamic Configuration das configurações do nó.

Se o tópico do Pub/Sub estiver configurado, a taxa de frames inicial será 0. Durante o processamento de vídeo, é possível enviar mensagens do Pub/Sub para o tópico do Pub/Sub no seguinte formato em tempo real para mudar a taxa de frames:

{
  "stream_id": "input-stream-id",
  "fps": 5,
}

O campo stream_id precisa corresponder ao ID do fluxo de entrada do aplicativo.

Conta de serviço e permissões

A credencial de serviço padrão do contêiner personalizado foi configurada para a conta de serviço do Google da plataforma de apps do Vertex AI Vision. Para acessar outros serviços do Google Cloud no contêiner, conceda a permissão adequada a: service-<var>PROJECT_NUMBER</var>@gcp-sa-visionai.iam.gserviceaccount.com

Opcional. Notificação de evento do modelo com funções do Cloud Run e Pub/Sub

Na Vertex AI Vision, os modelos recebem dados de mídia de dispositivos como câmeras, executam previsões de IA sobre os dados e produzem anotações continuamente. Com frequência, você envia esses dados processados para um destino de dados ("coletor de dados"), como um armazenamento de mídia ou o BigQuery, para outros trabalhos de análise. No entanto, pode haver um caso em que algumas anotações precisam ser processadas de maneira diferente ou em que as necessidades de anotação são sensíveis ao tempo. As integrações com funções do Cloud Run e Pub/Sub ajudam você a atender a essas necessidades.

Modelos compatíveis

Os seguintes modelos oferecem geração de eventos de funções do Cloud Run e integrações de notificação de eventos do Pub/Sub:

• Modelo de análise de ocupação
• Modelos personalizados da Vertex AI

Configurar funções do Cloud Run para processar a saída do modelo

Para acionar notificações baseadas em eventos, primeiro configure as funções do Cloud Run para processar a saída do modelo e gerar eventos.

Sua função do Cloud Run se conecta ao modelo e detecta a saída dele como ação de pós-processamento. A função do Cloud Run precisa retornar um AppPlatformCloudFunctionResponse. Os eventos (appplatformeventbody) são enviados ao tópico do Pub/Sub que você configura na próxima etapa.

Para conferir um exemplo de função do Cloud Run, consulte Ativar a notificação de eventos do modelo com o Cloud Functions e o Pub/Sub.

Use as instruções a seguir para enviar o fluxo de saída do modelo para sua função do Cloud Run:

Ativar a notificação de eventos do modelo com o Pub/Sub

Depois de configurar as funções do Cloud Run para processar a saída do modelo e gerar eventos, é possível configurar a notificação de eventos com o Pub/Sub. Para ler mensagens de um tópico, você também precisa Escolher e criar uma assinatura do Pub/Sub.

Conectar a saída do modelo a um nó downstream

Depois de criar um nó de modelo, é possível conectar a saída dele a outro nó.

Conectar a saída a um destino de dados

Depois de criar o fluxo de ingestão de dados e adicionar os nodes de processamento ao app, você precisa escolher para onde enviar os dados processados. Esse destino de dados é o ponto final do gráfico do app que aceita dados de stream sem produzir nenhum dado de stream. O destino escolhido depende de como você usa os dados de saída do app.

É possível conectar dados de saída do app aos seguintes destinos:

1. Vision Warehouse: armazene dados de vídeo originais ou analisados que você pode visualizar e consultar.

   Para mais informações sobre como enviar dados de saída do app para um Vision Warehouse, consulte Conectar e armazenar dados em um data warehouse.

2. BigQuery: armazene dados no BigQuery para usar os recursos de análise off-line.

   Para mais informações sobre como enviar dados de saída do app para o BigQuery, consulte Conectar e armazenar dados no BigQuery.

3. Dados de transmissão ao vivo: se você quiser um controle mais granular para agir com base em análises em tempo real, poderá receber a saída ao vivo do seu app.

   Para mais informações sobre como transmitir dados de saída do app diretamente, consulte Ativar a saída de transmissão ao vivo.

Atualizar um app

Apps não implantados

Faça as modificações necessárias no app (como adicionar ou remover nós de componentes). A Vertex AI Vision vai armazenar as mudanças automaticamente.

A seguir

• Saiba como implantar seu app para ingerir e analisar dados em Implantar um aplicativo.
• Leia as instruções sobre como iniciar a ingestão de dados de um fluxo de entrada de um app em Criar e gerenciar fluxos.
• Saiba como listar apps e ver as instâncias de um app implantado em Gerenciamento de aplicativos.
• Saiba como ler dados de entrada do app de um fluxo de ingestão ou dados de saída do modelo analisado em Ler dados de fluxo.