Prova il riconoscimento ottico dei caratteri (OCR)

Questa guida ti illustra la procedura per eseguire un test di riconoscimento ottico dei caratteri (OCR) utilizzando il servizio Vertex AI Vision di Google.

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Vertex AI per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Python di Vertex AI.

1. Crea un file Python ocr_test.py. Sostituisci il valore image_uri_to_test con l'URI di un'immagine di origine, come mostrato:

   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)
   

   Sostituisci quanto segue:

   • IMAGE_URI con l'URI di un'immagine disponibile pubblicamente che contiene testo, ad esempio, "https://cloud.google.com/vision/docs/images/sign.jpg". In alternativa, puoi specificare un URI Cloud Storage, ad esempio, "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. Crea l'immagine Docker per l'applicazione di traduzione:

   docker build -t ocr-app .
   

4. Segui le istruzioni riportate in Configura Docker per:

   1. Configura Docker,
   2. Crea un secret e
   3. Carica l'immagine su HaaS.

5. Accedi al cluster utente e genera il relativo file kubeconfig con un'identità utente. Assicurati di impostare il percorso kubeconfig come variabile di ambiente:

   export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
   

6. Crea un secret Kubernetes eseguendo il seguente comando nel terminale e incollando la chiave API:

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

   Questo comando crea un secret denominato gcp-api-key-secret con una chiave GCP_API_KEY.

7. Applica il manifest 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
   
   

   Sostituisci quanto segue:

   • HARBOR_INSTANCE_URL: l'URL dell'istanza Harbor.
   • HARBOR_PROJECT: il progetto Harbor.
   • SECRET: il nome del secret creato per archiviare le credenziali Docker.

8. Controlla lo stato del job:

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

9. Al termine del job, puoi visualizzare l'output OCR nei log del pod:

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