Nutzung von Serverless und generativer KI für Bildunterschriften auf GCP

Nutzung von Serverless und generativer KI für Bildunterschriften auf GCP

Im heutigen Zeitalter einer Fülle von Daten, insbesondere visueller Daten, ist es unerlässlich, Bilder effizient zu verstehen und zu kategorisieren. Ob zur Verbesserung von Suchfunktionen, zur Unterstützung von Menschen mit Behinderungen oder einfach zur Zusammenfassung umfangreicher Galerien - die Automatisierung von Bildunterschriften wird immer wichtiger.

In meinem jüngsten Projekt habe ich eine nahtlose Integration der serverlosen Architektur mit der Leistung der generativen KI erforscht, um Bilder auf der Google Cloud Platform (GCP) automatisch zu beschriften. Das zugrunde liegende Ziel war es, die skalierbare und effiziente Infrastruktur von GCP zu nutzen, ohne den Overhead der Serververwaltung, und gleichzeitig von den Fähigkeiten von VertexAI bei der Bilduntertitelung zu profitieren. Das Ergebnis? Eine automatisierte, ereignisgesteuerte Anwendung, die nach der Einrichtung nur minimale bis gar keine Wartung erfordert und sofortige, präzise Bildunterschriften für jedes in einen bestimmten Speicherbereich hochgeladene Bild liefert.

In diesem Blog-Beitrag gehe ich näher darauf ein, wie dieses System entwickelt wurde, welcher Code ihm zugrunde liegt und wie Sie es mit Terraform, einem beliebten Infrastructure as Code (IAC) Tool, in Ihrer eigenen GCP-Umgebung einrichten können. Egal, ob Sie ein Entwickler sind, der nach einer skalierbaren Lösung für Bildunterschriften sucht, oder ein Technikbegeisterter, der mehr über serverlose und KI-Integrationen erfahren möchte, dieser Beitrag verspricht eine Mischung aus technischer Tiefe und praktischen Einblicken. Ich gebe Ihnen zunächst die Kurzfassung und danach können wir eintauchen!

TL;DR

Wir haben ein automatisiertes, serverloses System auf der Google Cloud Platform aufgebaut:

• Benutzer laden Bilder in einen Google Cloud Storage Bucket hoch.
• Ein Pub/Sub-Thema erkennt diesen Upload und benachrichtigt unsere Haupt-Python-Cloud-Funktion.
• Diese Funktion nutzt Vertex AI, um Beschriftungen für die Bilder zu erstellen.
• Die Bildunterschriften werden dann zusammen mit den Dateinamen der Bilder in Google Cloud Firestore gespeichert.
• Das Endergebnis? Benutzer werfen ein Bild in einen Eimer und erhalten schnell eine von KI erstellte Beschriftung von Firestore. Es ist effizient, skalierbar und nutzt das Beste aus Cloud und KI!
• Sie finden den Quellcode unter https://github.com/binxio/tf-serverless-image-caption-generator.

Technologischer Überblick: Entpacken der Bausteine

Bevor wir uns in die Feinheiten des Codes und der Bereitstellung vertiefen, sollten wir uns einen Moment Zeit nehmen, um die Schlüsseltechnologien und -komponenten zu erläutern, die das Rückgrat dieser Lösung bilden. Wenn Sie diese verstehen, können Sie sich ein klareres Bild davon machen, wie alles in unserem serverlosen, KI-gesteuerten Bilduntertitelungssystem nahtlos zusammenhängt.

• Firestore Datenbank: Eine flexible, skalierbare Datenbank für Mobil-, Web- und Serveranwendungen von Firebase und Google Cloud. In unserem Setup werden hier die Bildunterschriften gespeichert.
• Cloud-Speicher Bucket: Der einheitliche Objektspeicher von GCP, der das weltweite Speichern und Abrufen beliebiger Datenmengen ermöglicht. Hier werden die Bilder hochgeladen und der Quellcode der Cloud-Funktion gespeichert.
• Cloud Pub/Sub: Ein Echtzeit-Nachrichtendienst, mit dem Sie Nachrichten zwischen unabhängigen Anwendungen senden und empfangen können. Er hilft bei Eimer-Benachrichtigungen, wenn ein neues Bild hinzugefügt wird.
• Das ImageCaptioningModel von VertexAI: Das ImageCaptioningModel, ein fortschrittliches Modell von VertexAI (eine Suite von Tools für maschinelles Lernen auf GCP), verwendet generative KI-Techniken, um Beschreibungen für Bilder zu erstellen. In unserem System ist es die treibende Kraft hinter der Erstellung der Bildunterschriften.
• Python: Diese Python-Cloud-Funktion dient als Brücke zwischen unserem Cloud Storage Bucket und VertexAI und wird ausgelöst, sobald ein neues Bild hochgeladen wird. Sie ruft das Bild ab, erhält mithilfe von VertexAI eine Beschriftung und speichert das Ergebnis dann im Firestore.
• Terraform: - Ein Tool für die sichere und effiziente Erstellung, Änderung und Versionierung von Infrastrukturen. Mit Terraform können wir die gesamte Infrastruktur kodifizieren und so Wiederholbarkeit und Skalierbarkeit ohne manuelle Eingriffe gewährleisten.

Den Terraform Code verstehen

Terraform ist ein wichtiges Werkzeug in diesem Projekt. Es ermöglicht uns die Definition und Bereitstellung der erforderlichen Infrastruktur mithilfe einer deklarativen Konfigurationssprache. Schauen wir uns nun die verschiedenen Komponenten unserer serverlosen Anwendung an, wie sie durch unsere Terraform-Konfigurationen definiert sind. Jedes Snippet bietet einen Einblick in die Orchestrierung der einzelnen Segmente auf der Google Cloud Platform.

Variablen-Deklarationen und Provider-Konfiguration

Diese Segmente bestimmen, in welchem GCP-Projekt und welcher Region die Ressourcen erstellt werden sollen. Einige dieser Variablen benötige ich auch später noch, deshalb habe ich sie am Anfang der Terraform-Datei definiert.

variable "project_id" { ... }
variable "region" { ... }
variable "location" { ... }

provider "google" {
  project = var.project_id
  region  = var.region
}

Cloud-Speicherplatz für Bilder

Ein spezieller Bucket für die Speicherung von Bildern. Wenn diese Bilder hochgeladen werden, dienen sie als Auslöser für unsere ereignisgesteuerte Architektur.

resource "google_storage_bucket" "image_bucket" {
  name = "your-image-bucket"
  location = "US"
}

Bereitstellung von Cloud-Funktionen

Dies ist das Herzstück der serverlosen Anwendung. Die Funktion tritt immer dann in Aktion, wenn eine Nachricht den Weg in das Pub/Sub-Thema findet. Ihr Quellcode, der in ein Zip-Archiv gepackt ist, wird in einen bestimmten Speicherbereich hochgeladen.

resource "google_cloudfunctions_function" "process_image_function" {
  name                  = "process-image"
  description           = "Processes uploaded image data"
  available_memory_mb   = 1024
  source_archive_bucket = google_storage_bucket.cloudfunction_bucket.name
  source_archive_object = google_storage_bucket_object.function_archive.name
  entry_point           = "process_image"
  runtime               = "python311"

  labels = {
    zip-md5 = local.combined_md5
  }

  event_trigger {
    event_type = "google.pubsub.topic.publish"
    resource   = google_pubsub_topic.bucket_notifications.name
  }
}

Der labels{}-Teil ist ein Mechanismus, um die Funktion nur dann neu zu verteilen, wenn sie geändert wird. Der nächste Schnipsel erklärt, wie das gemacht wurde.

Erstellung und Aktualisierung von Zip-Dateien

Mithilfe von MD5-Prüfsummen packt das System die Cloud-Funktion intelligent neu und stellt sie nur dann bereit, wenn sich der Quellcode oder seine Abhängigkeiten ändern.

locals {
  main_md5       = md5(file("${path.module}/function/main.py"))
  requirements_md5 = md5(file("${path.module}/function/requirements.txt"))
  combined_md5   = md5("${local.main_md5}${local.requirements_md5}")
}

resource "null_resource" "create_zip" {
  triggers = {
    file1_checksum = md5(file("${path.module}/function/main.py"))
    file2_checksum = md5(file("${path.module}/function/requirements.txt"))
  }

  provisioner "local-exec" {
    command = "zip -j ${path.module}/${local.combined_md5}.zip ${path.module}/function/*"
  }
}

Pub/Sub Topic für Bucket-Benachrichtigungen

Das Pub/Sub-Thema ist darauf vorbereitet, Benachrichtigungen zu erfassen, wenn Bilder zum Speicherbereich hinzugefügt werden. Eine Bindung legt die Berechtigungen fest, während eine Benachrichtigungskonfiguration den Bucket an das Thema bindet.

resource "google_pubsub_topic" "bucket_notifications" {
  name = "bucket-notifications-topic"
}

resource "google_pubsub_topic_iam_binding" "bucket_pubsub_publisher" {
  topic = google_pubsub_topic.bucket_notifications.name
  role  = "roles/pubsub.publisher"
  members = [
    "serviceAccount:service-<service_account_id>@gs-project-accounts.iam.gserviceaccount.com"
  ]
}

resource "google_storage_notification" "bucket_notification" {
  bucket        = google_storage_bucket.image_bucket.name
  payload_format = "JSON_API_V1"
  topic         = google_pubsub_topic.bucket_notifications.name
  depends_on = [google_pubsub_topic_iam_binding.bucket_pubsub_publisher]
}

Konfiguration der Firestore-Datenbank

Firestore, eine NoSQL-Datenbank, wird zum Speichern von Bildunterschriften verwendet. Die folgende Konfiguration stellt den Firestore-Dienst bereit und richtet eine native Datenbankinstanz ein.

resource "google_firestore_database" "your-amazing-database" {
  project     = var.project_id
  name        = "your-amazing-database"
  location_id = var.location
  type        = "FIRESTORE_NATIVE"
}

Mit diesen Segmenten ermöglicht das Terraform-Skript die Erstellung einer automatisierten, effizienten und ereignisgesteuerten Architektur auf GCP. Das orchestrierte Zusammenspiel dieser Komponenten erleichtert die Generierung von Bildunterschriften mit Hilfe von KI.

Die Python Cloud-Funktion für Bildunterschriften

Nachdem wir unsere Infrastruktur mit Terraform effizient eingerichtet haben, wagen wir uns nun an das Herzstück unserer Lösung: die serverlose Python-Cloud-Funktion, die Vertex AI nutzt, um in Google Cloud Storage gespeicherte Bilder zu erfassen. Schauen wir uns das mal an:

Einrichten

Zu Beginn importieren wir die erforderlichen Bibliotheken, einschließlich der Protokollierung für die Fehlersuche und Tracebacks für eine detaillierte Fehlerbehandlung. Die Module Google Cloud Storage und Firestore ermöglichen die Interaktion mit ihren jeweiligen Diensten. Das Vertex AI-Bildbeschriftungsmodell wird hier der Superstar sein und unserer Funktion ihre KI-Fähigkeiten verleihen.

import logging
import traceback
from google.cloud import storage, firestore
from vertexai.vision_models._vision_models import Image, ImageCaptioningModel
import os

Initialisierung des Captioning-Modells und des Firestore-Clients

Wir laden unser ImageCaptioningModel vor und initialisieren einen Firestore-Client. Dadurch, dass wir dies im globalen Bereich tun, wird sichergestellt, dass dies nur einmal geschieht und nicht bei jedem Funktionsaufruf, was der Leistung zugute kommt.

model = ImageCaptioningModel.from_pretrained("imagetext@001")
db = firestore.Client()

Bilder verarbeiten

Dies ist die Methode, die ausgelöst wird, wenn ein neues Bild in den Bucket hochgeladen wird: - Ereignisanalyse: Zunächst dekodiert die Funktion das eingehende Ereignis und erkennt den Ereignistyp und die Details des Zielobjekts. - Bild-Download: Wenn das Ereignis auf ein neues Bild hinweist, wird das Bild zur Verarbeitung in einen temporären lokalen Speicher heruntergeladen. - Beschriftung: Das Bild wird dann an die Funktion weitergegeben, die mit Hilfe von Vertex AI eine passende Beschriftung bestimmt. - Firestore-Speicherung: Nach der Beschriftung werden der Name des Bildes und die berechnete Beschriftung als Dokument in Firestore gespeichert.

def process_image(data, context):
    """Triggered from a message on a Cloud Pub/Sub topic."""
    logging.info("Function started.")
    logging.info("Received data: " + str(data))

    try:
        attributes = data.get('attributes', {})
        event_type = attributes.get('eventType')
        event_type = attributes['eventType']
        bucket_id = attributes['bucketId']
        object_id = attributes['objectId']

        if event_type != "OBJECT_FINALIZE":
            logging.info("Event type is not OBJECT_FINALIZE. Exiting function.")
            return "No action taken"

        # Initialize a client
        storage_client = storage.Client()
        bucket = storage_client.bucket(bucket_id)
        blob = bucket.blob(object_id)

        # Download the blob to a local file
        blob.download_to_filename(f'/tmp/{object_id}')
        logging.info(f'{object_id} downloaded to /tmp/{object_id}.')

        captions = get_captions(f'/tmp/{object_id}')

        if captions:
            first_caption = captions[0]
            logging.info(first_caption)

            # Store filename and caption in Firestore
            doc_ref = db.collection('captions').document(object_id)
            doc_ref.set({
                'filename': object_id,
                'caption': first_caption
            })

            logging.info(f"Stored {object_id} and its caption in Firestore.")
    except Exception as e:
        stack_trace = traceback.format_exc()
        logging.error(f"Error during processing: {e}n{stack_trace}")
    return "Processed image data"

Bildbeschriftung mit Vertex AI

Das aus der Datei geladene Bild wird in das vortrainierte Bildverarbeitungsmodell von GCP Vertex AI eingespeist. Das Modell liefert dann die oberste Beschriftung (da wir number_of_results auf 1 gesetzt haben).

def get_captions(filename):
    image = Image.load_from_file(filename)
    caption = model.get_captions(
        image=image,
        number_of_results=1,
        language="en",
    )
    return(caption)

Ablauf der serverlosen Anwendung

• Hochladen: Ein Benutzer lädt ein Bild in den Cloud Storage Bucket hoch.
• Benachrichtigung: Das Upload-Ereignis löst eine Pub/Sub-Nachricht aus.
• Aufforderung: Diese Nachricht aktiviert dann unsere Cloud-Funktion.
• Beschriftung: Innerhalb der Funktion verarbeitet das Vertex AI-Modell das Bild und leitet daraus eine passende Beschriftung ab.
• Abspeichern: Die Bildunterschrift findet zusammen mit dem Dateinamen des Bildes ihren Platz im Firestore.

Bilder können in großen Mengen in den Bucket hochgeladen werden, und unsere Cloud-Funktion erstellt parallel dazu Bildunterschriften.

Wie man sie einsetzt

Klonen Sie das Repository:

git clone git@github.com:binxio/tf-serverless-image-caption-generator.git
cd tf-serverless-image-caption-generator

Initialisieren Sie Terraform:

terraform init

Variablen aktualisieren: Vielleicht möchten Sie die Standardwerte für project_id, region und location in den Terraform-Dateien anpassen oder sie mit der Option -var in terraform apply überschreiben.

Überprüfen und übernehmen Sie die Änderungen:

terraform plan
terraform apply

Überprüfen Sie die Ressourcen, die erstellt/geändert werden sollen, und geben Sie Ja ein, wenn Sie dazu aufgefordert werden.

Nach der Bereitstellung navigieren Sie zur Google Cloud Console, um sicherzustellen, dass die Ressourcen erstellt wurden.

Zusammenfassend

Durch die Kombination von Google Cloud-Speicher, Pub/Sub und Firestore mit Vertex AI haben wir einen Bruchteil des Potenzials der Verschmelzung von Cloud- und AI-Technologie aufgezeigt. In der sich schnell entwickelnden digitalen Landschaft von heute ist es für Entwickler, Unternehmen und neugierige Einzelpersonen gleichermaßen wichtig, die ihnen zur Verfügung stehenden Tools zu nutzen, kontinuierlich zu lernen und zu innovieren. Die in diesem Projekt gezeigte Synergie zwischen Cloud und KI ebnet den Weg für zahllose Anwendungen - begrenzt nur durch unsere Vorstellungskraft.

Auf weitere solche Integrationen, Abenteuer und die unerforschten Grenzen der Technik, die wir noch erkunden müssen. Vorwärts und aufwärts!