Optische Zeichenerkennung (OCR) ausprobieren

In diesem Leitfaden wird beschrieben, wie Sie einen OCR-Test (Optical Character Recognition, optische Zeichenerkennung) mit dem Vertex AI Vision-Dienst von Google durchführen.

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der Vertex AI-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Vertex AI Python API.

1. Erstellen Sie eine Python-Datei mit dem Namen ocr_test.py. Ersetzen Sie den Wert image_uri_to_test durch den URI eines Quellbilds, wie unten gezeigt:

   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)
   

   Ersetzen Sie Folgendes:

   • IMAGE_URI durch den URI eines öffentlich verfügbaren Bildes, das Text enthält, z. B. „https://cloud.google.com/vision/docs/images/sign.jpg“. Alternativ können Sie einen Cloud Storage-URI angeben, z. B. „gs://your-bucket/your-image.png“.

2. Dockerfile erstellen:

   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. Erstellen Sie das Docker-Image für die Übersetzungsanwendung:

   docker build -t ocr-app .
   

4. Folgen Sie der Anleitung unter Docker konfigurieren, um:

   1. Docker konfigurieren
   2. Erstellen Sie ein Secret und
   3. Laden Sie das Bild in HaaS hoch.

5. Melden Sie sich im Nutzercluster an und generieren Sie die kubeconfig-Datei mit einer Nutzeridentität. Achten Sie darauf, dass Sie den kubeconfig-Pfad als Umgebungsvariable festlegen:

   export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
   

6. Erstellen Sie ein Kubernetes-Secret, indem Sie den folgenden Befehl in Ihr Terminal einfügen und Ihren API-Schlüssel einfügen:

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

   Mit diesem Befehl wird ein Secret mit dem Namen gcp-api-key-secret und dem Schlüssel GCP_API_KEY erstellt.

7. Wenden Sie das Kubernetes-Manifest an:

   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
   
   

   Ersetzen Sie Folgendes:

   • HARBOR_INSTANCE_URL: Die URL der Harbor-Instanz.
   • HARBOR_PROJECT: das Harbor-Projekt.
   • SECRET: Der Name des Secrets, das zum Speichern von Docker-Anmeldedaten erstellt wurde.

8. Prüfen Sie den Jobstatus:

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

9. Nachdem der Job abgeschlossen ist, können Sie die OCR-Ausgabe in den Pod-Logs ansehen:

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