Essayer la reconnaissance optique des caractères (OCR)

La reconnaissance optique des caractères (OCR) avec l'API Cloud Vision vous permet d'extraire du texte imprimé et manuscrit à partir d'images. Dans ce tutoriel, vous allez conteneuriser un client Python qui exécute l'OCR sur une image et le déployer en tant que job dans Google Distributed Cloud (GDC) Sandbox.

Pour exécuter cette charge de travail, vous avez besoin d'un projet Google Cloud actif avec l'API Cloud Vision activée, d'une clé API valide et d'un accès à votre instance GDC Sandbox et au registre de conteneurs Harbor. Avant d'essayer cet exemple, suivez les instructions de configuration pour Python décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez Utiliser Vertex AI et la documentation de référence de l'API Vertex AI en langage Python.

1. Créez un fichier Python ocr_test.py. Remplacez la valeur image_uri_to_test par l'URI d'une image source, comme indiqué ci-dessous :

   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)
   

   Remplacez les éléments suivants :

   • IMAGE_URI par l'URI d'une image accessible au public contenant du texte, par exemple "https://cloud.google.com/vision/docs/images/sign.jpg". Vous pouvez également spécifier un URI Cloud Storage, par exemple "gs://your-bucket/your-image.png".

2. Créez un fichier 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. Créez l'image Docker pour l'application de traduction :

   docker build -t ocr-app .
   

4. Suivez les instructions de la section Configurer Docker pour :

   1. Configurer Docker
   2. Créer un secret
   3. Importez l'image dans HaaS.

5. Connectez-vous au cluster d'utilisateur et générez son fichier kubeconfig avec une identité utilisateur. Veillez à définir le chemin d'accès kubeconfig en tant que variable d'environnement :

   export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
   

6. Créez un secret Kubernetes en exécutant la commande suivante dans votre terminal, en collant votre clé API :

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

   Cette commande crée un secret nommé gcp-api-key-secret avec une clé GCP_API_KEY.

7. Appliquez le fichier manifeste 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
   
   

   Remplacez les éléments suivants :

   • HARBOR_INSTANCE_URL : URL de l'instance Harbor.
   • HARBOR_PROJECT : projet Harbor.
   • SECRET : nom du secret créé pour stocker les identifiants Docker.

8. Vérifiez l'état du job :

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

9. Une fois le job terminé, vous pouvez afficher le résultat de l'OCR dans les journaux du pod :

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