Testar o reconhecimento óptico de caracteres (OCR)

O reconhecimento óptico de caracteres (OCR) com a API Cloud Vision permite extrair textos impressos e escritos à mão de imagens. Neste tutorial, você vai conteinerizar um cliente Python que executa o OCR em uma imagem e implantá-lo como um job no sandbox do Google Distributed Cloud (GDC).

Para executar essa carga de trabalho, você precisa de um projeto ativo do Google Cloud com a API Cloud Vision ativada, uma chave de API válida e acesso à instância do sandbox do GDC e ao Container Registry do Harbor. Antes de testar esse exemplo, siga as instruções de configuração para Python no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte Como usar a Vertex AI e a documentação de referência da API Python da Vertex AI.

1. Crie um arquivo Python ocr_test.py. Substitua o valor image_uri_to_test pelo URI de uma imagem de origem, conforme mostrado:

   import os
   import requests
   import json
   
   def detect_text_rest(image_uri):
       """Performs Optical Character Recognition (OCR) on an image by invoking the Vertex AI REST API."""
   
       # Securely fetch the API key from environment variables
       api_key = os.environ.get("GCP_API_KEY")
       if not api_key:
           raise ValueError("GCP_API_KEY environment variable must be defined.")
   
       # Construct the Vision API endpoint URL
       vision_api_url = f"https://vision.googleapis.com/v1/images:annotate?key={api_key}"
   
       print(f"Initiating OCR process for image: {image_uri}")
   
       # Define the request payload for text detection
       request_payload = {
           "requests": [
               {
                   "image": {
                       "source": {
                           "imageUri": image_uri
                       }
                   },
                   "features": [
                       {
                           "type": "TEXT_DETECTION"
                       }
                   ]
               }
           ]
       }
   
       # Send a POST request to the Vision API
       response = requests.post(vision_api_url, json=request_payload)
       response.raise_for_status()  # Check for HTTP errors
   
       response_json = response.json()
   
       print("\n--- OCR Results ---")
   
       # Extract and print the detected text
       if "textAnnotations" in response_json["responses"]:
           full_text = response_json["responses"]["textAnnotations"]["description"]
           print(f"Detected Text:\n{full_text}")
       else:
           print("No text was detected in the image.")
   
       print("--- End of Results ---\n")
   
   if __name__ == "__main__":
       # URI of a publicly available image, or a storage bucket
       image_uri_to_test = "IMAGE_URI"
   
       detect_text_rest(image_uri_to_test)
   

   Substitua:

   • IMAGE_URI pelo URI de uma imagem disponível publicamente que contenha texto, por exemplo, "https://cloud.google.com/vision/docs/images/sign.jpg". Como alternativa, especifique um URI do Cloud Storage, por exemplo, "gs://your-bucket/your-image.png".

2. Crie um Dockerfile:

   ROM python:3.9-slim
   
   WORKDIR /app
   
   COPY ocr_test.py /app/
   
   # Install 'requests' for HTTP calls
   RUN pip install --no-cache-dir requests
   
   CMD ["python", "ocr_test.py"]
   

3. Crie a imagem Docker para o aplicativo de tradução:

   docker build -t ocr-app .
   

4. Siga as instruções em Configurar o Docker para:

   1. Configurar o Docker
   2. Criar um secret e
   3. Faça upload da imagem para o HaaS.

5. Faça login no cluster de usuário e gere o arquivo kubeconfig dele com uma identidade de usuário. Defina o caminho do kubeconfig como uma variável de ambiente:

   export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
   

6. Crie um secret do Kubernetes executando o seguinte comando no terminal e colando sua chave de API:

   kubectl create secret generic gcp-api-key-secret \
     --from-literal=GCP_API_KEY='PASTE_YOUR_API_KEY_HERE'
   

   Esse comando cria um secret chamado gcp-api-key-secret com uma chave GCP_API_KEY.

7. Aplique o manifesto do Kubernetes:

   apiVersion: batch/v1
   kind: Job
   metadata:
     name: ocr-test-job-apikey
   spec:
     template:
       spec:
         containers:
         - name: ocr-test-container
           image: HARBOR_INSTANCE_URL/HARBOR_PROJECT/ocr-app:latest # Your image path
           # Mount the API key from the secret into the container
           # as an environment variable named GCP_API_KEY.
           imagePullSecrets:
           - name: ${SECRET}
           envFrom:
           - secretRef:
               name: gcp-api-key-secret
         restartPolicy: Never
     backoffLimit: 4
   
   

   Substitua:

   • HARBOR_INSTANCE_URL: o URL da instância do Harbor.
   • HARBOR_PROJECT: o projeto do Harbor.
   • SECRET: o nome do secret criado para armazenar as credenciais do Docker.

8. Verifique o status do job:

   kubectl get jobs/ocr-test-job-apikey
   # It will show 0/1 completions, then 1/1 after it succeeds
   

9. Depois que o job for concluído, você poderá ver a saída do OCR nos registros do pod:

   kubectl logs -l job-name=ocr-test-job-apikey