Optische Zeichenerkennung (OCR) ausprobieren

Mit der optischen Zeichenerkennung (Optical Character Recognition, OCR) der Cloud Vision API können Sie gedruckten und handschriftlichen Text aus Bildern extrahieren. In dieser Anleitung containerisieren Sie einen Python-Client, der OCR für ein Bild ausführt, und stellen ihn als Job in der Google Distributed Cloud (GDC) Sandbox bereit.

Zum Ausführen dieser Arbeitslast benötigen Sie ein aktives Google Cloud -Projekt mit aktivierter Cloud Vision API, einen gültigen API-Schlüssel sowie Zugriff auf Ihre GDC-Sandbox-Instanz und die Harbor-Container-Registry. 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 unter Vertex AI verwenden und in der Referenzdokumentation zur Vertex AI Python API.

  1. Erstellen Sie eine Python-Datei ocr_test.py. Ersetzen Sie den Wert image_uri_to_test durch den URI eines Quell-Images, wie hier 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. So erstellen Sie ein 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. 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. Secret erstellen
    3. Laden Sie das Image in HaaS hoch.
  5. Melden Sie sich im Nutzercluster an und generieren Sie die kubeconfig-Datei mit einer Nutzeridentität. Legen Sie den kubeconfig-Pfad als Umgebungsvariable fest:

    export KUBECONFIG=${CLUSTER_KUBECONFIG_PATH}
    
  6. Erstellen Sie ein Kubernetes-Secret, indem Sie den folgenden Befehl in Ihrem Terminal ausführen 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