Prueba el reconocimiento óptico de caracteres (OCR)

En esta guía, se explica el proceso para ejecutar una prueba de reconocimiento óptico de caracteres (OCR) con el servicio de Vertex AI Vision de Google.

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python que se encuentran en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Vertex AI para Python.

1. Crea un archivo de Python ocr_test.py. Reemplaza el valor image_uri_to_test por el URI de una imagen fuente, como se muestra a continuación:

   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)
   

   Reemplaza lo siguiente:

   • IMAGE_URI con el URI de una imagen disponible públicamente que contenga texto, por ejemplo, "https://cloud.google.com/vision/docs/images/sign.jpg". Como alternativa, puedes especificar un URI de Cloud Storage, por ejemplo, "gs://your-bucket/your-image.png".

2. Crea un 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. Compila la imagen de Docker para la aplicación de traducción:

   docker build -t ocr-app .
   

4. Sigue las instrucciones en Configura Docker para hacer lo siguiente:

   1. Configura Docker.
   2. Crea un secreto.
   3. Sube la imagen a HaaS.

5. Accede al clúster de usuario y genera su archivo kubeconfig con una identidad de usuario. Asegúrate de configurar la ruta de kubeconfig como una variable de entorno:

   export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
   

6. Ejecuta el siguiente comando en tu terminal y pega tu clave de API para crear un secreto de Kubernetes:

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

   Este comando crea un secreto llamado gcp-api-key-secret con una clave GCP_API_KEY.

7. Aplica el manifiesto de 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
   
   

   Reemplaza lo siguiente:

   • HARBOR_INSTANCE_URL: Es la URL de la instancia de Harbor.
   • HARBOR_PROJECT: Es el proyecto de Harbor.
   • SECRET: Es el nombre del secreto creado para almacenar las credenciales de Docker.

8. Verifica el estado del trabajo:

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

9. Una vez que el trabajo se complete, puedes ver el resultado del OCR en los registros del pod:

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