Multimodale KI

KI kann nicht nur sprechen, sondern auch Bilder sehen, Töne hören und Videos verstehen – meistere multimodale Werkzeuge und Technologien.

Lange Zeit war KI einzel-sensorisch.

Text-KI konnte nur Text verarbeiten, zum Beispiel ChatGPT bitten, Artikel zu schreiben.
Bild-KI konnte nur Bilder verarbeiten, zum Beispiel Midjourney bitten, Bilder zu zeichnen.
Audio-KI konnte nur Klang verarbeiten, zum Beispiel Whisper bitten, Sprache zu transkribieren.

Aber die reale Welt ist multimodal – wenn wir Bücher lesen, sehen wir Illustrationen, beim Ansehen von Filmen gibt es Bild und Ton, und bei der Kommunikation mit anderen beobachten wir Gesichtsausdrücke und Tonfall.

Multimodale KI ist eine KI, die gleichzeitig mehrere Arten von Inhalten verstehen und erzeugen kann, als würde man der KI Augen, Ohren und einen Mund geben, sodass sie auf eine Weise mit der Welt interagieren kann, die dem Menschen näher kommt.

Ein praktisches Beispiel: Sie geben der KI ein Foto eines Einkaufsbelegs; sie kann den Text darauf erkennen (OCR), verstehen, welche Artikel gekauft wurden, Ihnen helfen, es in eine Tabelle zu organisieren, und es Ihnen sogar vorlesen. Dies ist eine typische multimodale Aufgabe.

Was ist multimodale KI

Lassen Sie uns zunächst ein paar grundlegende Konzepte klären.

Single-modal vs. Multimodal

Modalität bezeichnet die Form, in der Informationen ausgedrückt werden.

Text, Bilder, Audio und Video sind alles verschiedene Modalitäten.

Type	Beschreibung	Typische Produkte
Eindimensionale KI	Kann nur eine Modalität verarbeiten	Frühes GPT-3 (nur Text), Stable Diffusion (nur Bilder)
Multimodale KI	Kann mehrere Modalitäten gleichzeitig verarbeiten	GPT-4o, Claude 3, Gemini

Der Kerndurchbruch der multimodalen KI ist:Sie kann Informationen aus verschiedenen Modalitäten in eine gemeinsame Sprache zum Verständnis übersetzen。

Wenn sie zum Beispiel ein Bild einer „Katze“ sieht, kann sie das Bild in einen Vektor (eine Menge von Zahlen) umwandeln; wenn sie das Wort „Katze“ sieht, kann sie es ebenfalls in einen Vektor umwandeln. Diese beiden Vektoren liegen im mathematischen Raum nah beieinander, da sie dasselbe Konzept repräsentieren.

Hauptherausforderungen multimodaler KI

Multimodalität klingt einfach, ist aber in der Praxis sehr schwierig.

Die erste Herausforderung ist die „Ausrichtung“ (Alignment) – wie sorgt man dafür, dass die „Katze“ in einem Bild und die „Katze“ im Text für das Modell als dasselbe Ding erscheinen?
Die zweite Herausforderung ist die „Fusion“ – wie kombiniert man ihre Informationen, wenn man gleichzeitig ein Bild und einen Text sieht?
Die dritte Herausforderung ist die „Generierung“ – wie generiert man ein Bild basierend auf einer Textbeschreibung oder eine Textbeschreibung basierend auf einem Bild?
Glücklicherweise werden diese Probleme schrittweise gelöst. Nach 2024 sind fast alle Mainstream-Großmodelle multimodal.

Bildverständnis (Vision)

Beim Bildverständnis geht es darum, die KI Bilder verstehen zu lassen – Inhalte zu beschreiben, Text zu erkennen, Diagramme zu analysieren und Details zu erkennen.

Mainstream-Großmodelle unterstützen jetzt die Bildeingabe.

Es gibt normalerweise zwei Möglichkeiten, sie zu nutzen:

Die eine besteht darin, die Bilddatei direkt hochzuladen, zum Beispiel durch Klicken auf das Bildsymbol in der ChatGPT-Webversion zum Hochladen.
Eine andere Möglichkeit besteht darin, das Bild mittels Base64-Kodierung in die API-Anfrage einzubetten, was für programmatische Aufrufe geeignet ist.

Modell	Bildeingabemethoden	Unterstützte Bildformate
GPT	URL, Base64, direkter Upload	JPG, PNG, WEBP, GIF
Claude	Base64, direkter Upload	JPG, PNG, WEBP, GIF
Gemini	Direkter Upload, Google Drive	JPG, PNG, WEBP

Häufige Vision-Aufgaben sind:

Bildbeschreibung – Was ist auf diesem Bild zu sehen?
OCR – Text aus einem Bild extrahieren.
Diagrammanalyse – Was sagt uns dieses Balkendiagramm?
Detailerkennung – Helfen Sie mir, diesen Entwurf auf Probleme zu überprüfen.

Praxis: Aufrufen der GPT-4o Vision API mit Python

Schauen wir uns ein vollständiges Beispiel an – die Verwendung der API zur Analyse eines Bildes.

Beispiel

# ============================================
# File: example_vision_demo.py
# Function: Analyze images using the GPT-4o Vision API
# ============================================

import base64
import requests
import os

# Configure API key (please replace with your real key)
# Get it from: https://platform.openai.com/api-keys
OPENAI_API_KEY = "sk-your-api-key-here"
OPENAI_API_URL = "https://api.openai.com/v1/chat/completions"

def encode_image_to_base64(image_path: str) -> str:
"""
Kodieren Sie die lokale Bilddatei als Base64-String
Dies ist das von der API benötigte Übertragungsformat
"""
with open(image_path, "rb") as image_file:
# Read the binary file content and encode it with Base64
base64_data = base64.b64encode(image_file.read()).decode("utf-8")
return base64_data

def analyze_image_with_gpt4o(
image_path: str,
prompt: str = "Please describe the content of this image in detail.",
model: str = "gpt-4o"
) -> str:
"""
Use the GPT-4o Vision API to analyze the image

Parameter description:
image_path: Local image file path (e.g., "example_test.jpg")
prompt: The question you want to ask or the task you want the AI to perform
model: The model name to use (default gpt-4o)

Rückgabe:
The AI's analysis result text
"""
# Step 1: Encode the image as Base64
base64_image = encode_image_to_base64(image_path)

# Step 2: Build the request headers
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {OPENAI_API_KEY}"
}

# Step 3: Build the request body
# Note: The image content is passed via the image_url field, in the format "data:image/jpeg;base64,..."
payload = {
"model": model,
"messages": [
{
"role": "user",
"content": [
# The first part is the text prompt
{"type": "text", "text": prompt},
# The second part is the image
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}
}
]
}
],
"max_tokens": 1000 # Limit output length to avoid high costs
}

# Step 4: Send the API request
print(f"Analyzing image: {image_path} ...")
response = requests.post(OPENAI_API_URL, headers=headers, json=payload)

# Step 5: Handle the response
if response.status_code == 200:
result = response.json()
# Extract the AI's answer
answer = result["choices"][0]["message"]["content"]
return answer
else:
# Print detailed error information when an error occurs
error_msg = f"Request failed: {response.status_code} - {response.text}"
print(error_msg)
return error_msg

def extract_text_from_image(image_path: str) -> str:
"""
Specially for OCR: Extract text from images
"""
prompt = """
Please extract all text content from this image.
Requirements:
1. Accurately reproduce the text, do not omit anything
2. Keep the original paragraphs and formatting
3. If there are tables, output them in table form
4. If there is no text in the image, please state so
This is the OCR test from the EXAMPLE tutorial.
"""
return analyze_image_with_gpt4o(image_path, prompt)

def analyze_chart(image_path: str) -> str:
"""
Speziell für die Diagrammanalyse
"""
prompt = """
Bitte analysieren Sie dieses Diagramm.
Bitte beantworten Sie die folgenden Fragen:
1. Um welche Art von Diagramm handelt es sich (Balkendiagramm, Liniendiagramm, Kreisdiagramm usw.)?
2. Wie lautet der Titel des Diagramms und welche Bedeutung haben die Achsen?
3. Was ist die Hauptaussage, die das Diagramm vermittelt?
4. Gibt es nennenswerte Trends oder Anomalien?
Dies ist der Diagrammanalyse-Test aus dem EXAMPLE-Tutorial.
"""
return analyze_image_with_gpt4o(image_path, prompt)

# ============================================
# Hauptprogramm: Demonstration verschiedener Vision-Analyseaufgaben
# ============================================

if __name__ == "__main__":
# Angenommen, wir haben ein Testbild (Sie müssen ein echtes Bild vorbereiten)
# Es kann sein: Produktfoto, Screenshot, Dokumentenfoto, Diagramm usw.
test_image = "example_test_image.jpg"

# Überprüfen, ob das Bild existiert
if not os.path.exists(test_image):
print(f"Tipp: Bitte bereiten Sie ein Bild vor, nennen Sie es {test_image} und legen Sie es in das aktuelle Verzeichnis")
print("Oder ändern Sie den Bildpfad im Code")
else:
# Aufgabe 1: Allgemeine Bildbeschreibung
print("\n" + "="*50)
print("Aufgabe 1: Bildbeschreibung")
print("="*50)
result1 = analyze_image_with_gpt4o(
test_image,
"Bitte beschreiben Sie dieses Bild detailliert, einschließlich Motiv, Hintergrund, Farben, Komposition usw."
)
print(result1)

# Aufgabe 2: OCR-Textextraktion
print("\n" + "="*50)
print("Aufgabe 2: OCR-Textextraktion")
print("="*50)
result2 = extract_text_from_image(test_image)
print(result2)

# Aufgabe 3: Diagrammanalyse (falls es sich bei dem Bild um ein Diagramm handelt)
print("\n" + "="*50)
print("Aufgabe 3: Diagrammanalyse")
print("="*50)
result3 = analyze_chart(test_image)
print(result3)

print("\n" + "="*50)
print("EXAMPLE-Tutorial-Demo abgeschlossen!")
print("="*50)

Bevor Sie dieses Programm ausführen, müssen Sie:

1. Abhängigkeiten installieren:pip install requests
2. Ein Testbild vorbereiten und benennenexample_test_image.jpg
3. Den API-Schlüssel durch Ihren eigenen ersetzen

Hinweis zu den Kosten: GPT-4o Vision wird nach Bildgröße abgerechnet. Ein 1024x1024 großes Bild kostet etwa $0.00765. Kleinere Bilder sind günstiger. Verwenden Sie zum Debuggen Bilder mit niedriger Auflösung und für die Produktion eine hohe Auflösung.

Text-zu-Bild

Text-to-Image ermöglicht es KI, Bilder aus Textbeschreibungen zu generieren. Dies ist ein weiteres sehr ausgereiftes multimodales Anwendungsgebiet.

Einführung in die Prinzipien von Diffusionsmodellen

Heutige Text-zu-Bild-Tools nutzen im Wesentlichen die Technologie von Diffusionsmodellen.

Eine einfache Art zu verstehen, wie es funktioniert:

Trainingsphase: Dem Modell wird ein klares Bild gezeigt, dem dann schrittweise Rauschen hinzugefügt wird, bis es zu einem vollständig verrauschten Bild wird. Das Modell lernt, wie es das verrauschte Bild Schritt für Schritt wieder in ein klares Bild verwandeln kann.
Generierungsphase: Dem Modell wird ein zufälliges Rauschbild gegeben, und es wird Schritt für Schritt entsprechend dem Text-Prompt entrauscht, wodurch schließlich ein klares Bild generiert wird, das der Beschreibung entspricht.

Dieser Vorgang dauert normalerweise 20-50 Schritte, sodass die Generierung eines Bildes einige Sekunden dauert.

Fortgeschrittene Midjourney-Nutzungstipps

Midjourney ist derzeit eines der beliebtesten Text-zu-Bild-Tools und wird über Discord verwendet.

Ein hochwertiger Prompt enthält normalerweise diese Elemente:

Motivbeschreibung — „eine Katze mit Hut“
Stil — „Studio Ghibli-Stil“, „Ölgemälde“, „3D-Render“
Beleuchtung — „natürliches Licht“, „cinematische Beleuchtung“, „Cyberpunk-Neonlichter“
Komposition — „Nahaufnahme“, „Weitwinkel“, „Ansicht von oben“
Qualität — „8K“, „ultradetailliert“, „fotografische Qualität“

Parameter	Beschreibung	Beispiel
--ar	Seitenverhältnis festlegen	--ar 16:9 (Video), --ar 3:4 (Mobil)
--v	Modellversion angeben	--v 6.0 (neueste Version)
--s	Stylisierungsgrad (0-1000)	--s 750 (starkes künstlerisches Gefühl)
--q	Render-Qualität (0.25-2)	--q 2 (höhere Qualität, langsamer)
--iw	Referenzbild-Gewichtung	--iw 1.5 (ähneln dem Referenzbild mehr)

Lokale Bereitstellung von Stable Diffusion

Wenn Sie die vollständige Kontrolle behalten möchten, können Sie Stable Diffusion lokal ausführen:https://github.com/compvis/stable-diffusion。

Das am häufigsten verwendete Tool ist die WebUI von Automatic1111.

Die Schritte sind ungefähr wie folgt:

1. Python 3.10 installieren
2. Stable Diffusion WebUI herunterladen
3. Modelldatei herunterladen (.safetensors-Format)
4. webui.bat (Windows) oder webui.sh (Mac/Linux) ausführen

Vorteile der lokalen Bereitstellung: Die Generierung ist kostenlos, es gibt keine Inhaltseinschränkungen, Sie können LoRA zum Feinabstimmen von Stilen verwenden und ControlNet für die präzise Kompositionssteuerung nutzen.

Nachteile: Sie benötigen eine GPU mit mindestens 6GB VRAM, und die Einrichtung ist etwas kompliziert.

Praxis: Bilder generieren mit der DALL·E 3 API

Wenn Sie eine einfache API-Methode zum Generieren von Bildern suchen, ist DALL·E 3 eine gute Wahl.

Beispiel

# ============================================
# Datei: example_dalle3_demo.py
# Funktion: Bilder mit der DALL·E 3 API generieren
# ============================================

import requests
import os
from datetime import datetime

# Konfigurieren Sie den API-Schlüssel (bitte durch Ihren echten Schlüssel ersetzen)
OPENAI_API_KEY = "sk-your-api-key-here"
DALLE3_API_URL = "https://api.openai.com/v1/images/generations"

def generate_image_with_dalle3(
prompt: str,
size: str = "1024x1024",
quality: str = "standard",
style: str = "vivid",
save_dir: str = "example_generated_images"
) -> dict:
"""
Bilder generieren mit der DALL·E 3 API

Parameterbeschreibungen:
prompt: Textbeschreibung, je detaillierter desto besser
size: Bildgröße
Options: 1024x1024, 1024x1792 (Portrait), 1792x1024 (Landscape)
quality: Bildqualität
Options: standard (Standard), hd (High Definition, teurer)
style: Stil
Optional: vivid (lebendig, künstlerischer), natural (natürlich, realistischer)
save_dir: Verzeichnis zum Speichern von Bildern

Rückgabe:
A dictionary containing the image URL and save path
"""
# Step 1: Prepare the request headers
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {OPENAI_API_KEY}"
}

# Step 2: Prepare the request body
payload = {
"model": "dall-e-3",
"prompt": prompt,
"n": 1, # DALL·E 3 can only generate 1 image at a time
"size": size,
"quality": quality,
"style": style
}

# Step 3: Send the request
print(f"Generating image, prompt: {prompt[:50]}...")
response = requests.post(DALLE3_API_URL, headers=headers, json=payload)

# Step 4: Handle the response
if response.status_code == 200:
result = response.json()
image_url = result["data"][0]["url"]
revised_prompt = result["data"][0].get("revised_prompt", prompt)

print(f"DALL·E 3 auto-optimized prompt: {revised_prompt}")

# Step 5: Download and save the image
if not os.path.exists(save_dir):
os.makedirs(save_dir)

# Generate a filename using a timestamp
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"example_dalle3_{timestamp}.png"
filepath = os.path.join(save_dir, filename)

# Download the image
image_response = requests.get(image_url)
if image_response.status_code == 200:
with open(filepath, "wb") as f:
f.write(image_response.content)
print(f"Image saved to: {filepath}")

return {
"image_url": image_url,
"filepath": filepath,
"revised_prompt": revised_prompt
}
else:
error_msg = f"Request failed: {response.status_code} - {response.text}"
print(error_msg)
return {"error": error_msg}

def generate_example_logo_demo():
"""Demo: Generate a EXAMPLE-style Logo"""
prompt = """
A cute and friendly robot mascot for EXAMPLE tutorial website.
Blue and green color scheme, modern flat design, white background.
The robot looks helpful and intelligent, with big friendly eyes.
Simple, clean, suitable for a tech education brand.
"""
# Chinese prompts work too; DALL·E 3 supports multiple languages
prompt = """
Design a cute and friendly robot mascot for the EXAMPLE tutorial website.
Blue-green color scheme, modern flat design, white background.
The robot looks helpful and smart, with big friendly eyes.
Simple and clean, suitable for a tech education brand.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1024x1024",
quality="hd",
style="vivid"
)

def generate_book_cover_demo():
"""Demo: Generate a book cover"""
prompt = """
Book cover design for "AI Tutorial for Beginners".
Modern minimalist style, deep blue and purple gradient background.
The title text is elegant and readable.
Subtle tech elements: floating geometric shapes, faint circuit patterns.
Professional, trustworthy, suitable for a programming book.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1024x1792", # Portrait orientation
quality="hd",
style="natural"
)

def generate_banner_demo():
"""Demo: Generate a banner ad"""
prompt = """
Web banner design for a coding tutorial website (EXAMPLE).
16:9 wide format. Modern gradient background from teal to blue.
Clean layout with space for text.
Abstract tech elements: floating code snippets, subtle grid lines.
Professional and inviting.
"""
return generate_image_with_dalle3(
prompt=prompt,
size="1792x1024", # Landscape orientation
quality="standard",
style="vivid"
)

# ============================================
# Main program: demonstrate different generation tasks
# ============================================

if __name__ == "__main__":
print("="*60)
print("EXAMPLE DALL·E 3 Image Generation Demo")
print("="*60)

# Task 1: Generate Logo
print("\n[Task 1] Generating Logo ...")
result1 = generate_example_logo_demo()

# Task 2: Generate book cover
print("\n[Task 2] Generating book cover ...")
result2 = generate_book_cover_demo()

# Task 3: Generate banner
print("\n[Task 3] Generating banner ...")
result3 = generate_banner_demo()

print("\n" + "="*60)
print("All tasks completed! Check the example_generated_images directory")
print("="*60)

DALL·E 3s Stärken: starkes Verständnis, macht keine kaputten Hände und Gesichter, generiert Text gut.

Es hat jedoch auch Einschränkungen: Es kann jeweils nur 1 Bild generieren, den Stil nicht präzise steuern und nicht wie Stable Diffusion feinabgestimmt werden.

Urheberrechtshinweis: Derzeit herrscht Einigkeit darüber, dass bei KI-generierten Bildern der Verfasser des Prompts die Nutzungsrechte besitzt, aber nicht das Urheberrecht innehat (da Urheberrechtsämter menschliche Urheberschaft erfordern). Für die kommerzielle Nutzung wird empfohlen, die Nutzungsbedingungen des Tools zu überprüfen.

Video-KI

Video-KI wird in zwei Kategorien unterteilt: Videogenerierung und Videoverständnis.

Im Vergleich zu Bildern ist Video technisch schwieriger – da Video eine Kombination aus „Zeit + Raum“ ist, die erfordert, dass jeder Frame kohärent und die Bewegungen natürlich wirken.

Vergleich von KI-Videogenerierungstools

2024 war das erste Jahr des KI-Videos, in dem mehrere Unternehmen Produkte zur Videogenerierung auf den Markt brachten.

Tool	Developer	Funktionen	Typische Dauer
Sora	OpenAI	Branchenführende Bilddetails und räumliches Szenenverständnis, realistische Physiklogik, noch nicht vollständig für die öffentliche Beta geöffnet	Bis zu 60 Sekunden
Runway Gen-4	Runway	All-in-One-Erstellungsplattform, die Text/Bild-zu-Video, KI-Nachbearbeitung, Motion Brush und VFX-Effekte integriert; die erste Wahl für professionelle Kreative in Übersee	10–20 Sekunden
Kling (Keling AI)	Kuaishou	Hervorragende Anpassung an chinesische Prompts, flüssige Charakterbewegungen, stabile Charaktere über Einstellungen hinweg, hohe Kosteneffizienz in China, unterstützt das Zusammenfügen mehrteiliger Narrative	5–30 Sekunden, bis zu 2 Minuten pro Segment
Pika	Pika Labs	Äußerst ausdrucksstark in Anime- und cineastischen Illustrationsstilen, konsistentes Charakterdesign, unterstützt Video-Stil-Neugenerierung und Frame-Interpolation	5–10 Sekunden
Veo	Google	Cineastische Beleuchtung und Kamerabewegung, stabile Langzeit-Einstellungs-Narrative, natürliches physikalisches Rendering, noch nicht öffentlich veröffentlicht	Über 60 Sekunden
Jimeng AI (Seedance)	ByteDance	Tief integriert in das CapCut-/Douyin-Ökosystem, präzises chinesisches Semantikverständnis, audiovisuelles Lip-Sync, unterstützt automatisches Storyboarding aus Skripten	5–15 Sekunden, mehrere Segmente zu einem vollständigen Film zusammengefügt
Tongyi Wanxiang Video	Alibaba DAMO Academy	Open-Source-Basismodell, stabile Multi-Subjekt-Interaktion, unterstützt Texterstellung in Bildern, kann lokal für Inferenz bereitgestellt werden.	2–15 Sekunden
Hailuo AI (Hailuo)	MiniMax (Xiyu)	Leichte, ultraschnelle Generierung; geeignet für die Umwandlung von Plakaten in dynamische Kurzvideos und Social-Media-Flash-Inhalte, mit herausragendem Anime-Stil-Rendering.	4–10 Sekunden
Luma Dream Machine	Luma AI	Erstklassige Physik-Dynamik-Simulation; realistische Effekte für Wasser, Feuer, Stoff und Explosionen mit cineastischer Kamerabewegung.	5–12 Sekunden
Zhiying	Tencent	Konzentriert sich auf KI-Bearbeitung und digitale Menschenvideos, mit massiven Kurzvideo-Vorlagen, One-Stop-Untertiteln, Synchronisation und Freistellung sowie niedrigen kommerziellen Hürden.	Keine Begrenzung der Videolänge; KI-generierte Clips sind 5–15 Sekunden lang.
Haiyi AI	Haiyi Technology	Unterstützt 4K/60fps-High-Frame-Rate-Ausgabe, videogenerierung mit mehreren verknüpften Bildern, wird mit einer vollständigen Produktions-Workstation geliefert und bietet ein großzügiges zeitlich begrenztes kostenloses Kontingent.	Einzelnes Segment bis zu 30 Sekunden.

KI-Video befindet sich noch in der Frühphase:

Vorteile: schnelle Kreativität, geringe Kosten und die Möglichkeit, Effekte zu erzielen, die bei Realaufnahmen sehr schwierig sind.
Nachteile: begrenzte Dauer, Details brechen leicht zusammen und die Physiklogik ist manchmal falsch (z. B. Objekte, die durch einander hindurchgehen, falsche Anzahl von Fingern).
Geeignete Szenarien: Konzeptdemonstrationen, Kurzvideomaterial, E-Commerce-Anzeigen, Spielanimationen.
Ungeeignete Szenarien: lange Filme, die präzise Kontrolle erfordern, ernsthafte Nachrichten, juristische Beweise.

Videoverständnis und -zusammenfassung

Neben dem Generieren von Videos kann KI Videos auch verstehen.

Häufige Aufgaben beim Videoverständnis:

Videozusammenfassung – „Worum geht es in diesem Video? Fassen Sie in 3 Sätzen zusammen.“
Inhaltssuche – „Finden Sie den Clip im Video, in dem jemand Fahrrad fährt.“
Fragebeantwortung – „Was hat die dritte Person im Video gesagt?“

Der typische technische Ansatz ist: Frames aus dem Video extrahieren (z. B. 1 Frame pro Sekunde), dann ein Visionsmodell verwenden, um jeden Frame einzeln zu betrachten, und schließlich die Informationen integrieren.

Zukünftige Trends

Die Entwicklungsrichtung von Video-KI ist klar:

Länger – von 10 Sekunden auf 1 Minute und dann auf 10 Minuten.
Kontrollierbarer – in der Lage, jede Einstellung mithilfe von Storyboards präzise zu steuern.
Konsistenter – derselbe Charakter bleibt über verschiedene Einstellungen hinweg konsistent.
Praktischer – von cool aussehen bis hin zur Lösung realer Probleme.
Was zu erwarten ist: In ein paar Jahren wird vielleicht jeder in der Lage sein, filmähnliche Videowerke mit KI zu erstellen.

Audio- und Sprach-KI

Audio-KI umfasst hauptsächlich: Speech-to-Text (ASR), Text-to-Speech (TTS) und Musikgenerierung.

Dies ist ein ziemlich ausgereifter Bereich.

Speech-to-Text (Whisper API)

Whisper ist das Open-Source-Spracherkennungsmodell von OpenAI. Es leistet sehr gute Arbeit und unterstützt 99 Sprachen.

Beispiel

# ============================================
# File: example_whisper_demo.py
# Function: Use Whisper API to transcribe speech
# ============================================

import requests
import os

# Configure API key
OPENAI_API_KEY = "sk-your-api-key-here"
WHISPER_API_URL = "https://api.openai.com/v1/audio/transcriptions"

def transcribe_audio_with_whisper(
audio_path: str,
language: str = "zh", # zh=Chinese, en=English, leave empty for auto-detect
prompt: str = "", # Optional: provide some terminology hints to improve accuracy
temperature: float = 0.0
) -> dict:
"""
Use Whisper API to transcribe audio files

Parameter description:
audio_path: audio file path (supports mp3, wav, m4a, etc.)
language: language code (optional, auto-detected if not specified)
Common codes: zh (Chinese), en (English), ja (Japanese)
prompt: prompt text (optional; write possible technical terms or names here)
temperature: sampling temperature (0.0 is most deterministic, 1.0 is more diverse)

Return:
A dictionary containing the transcribed text
"""
# Step 1: Check if the file exists
if not os.path.exists(audio_path):
return {"error": f"File not found: {audio_path}"}

# Step 2: Prepare the request headers
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}

# Step 3: Prepare the request body (note: audio must use multipart/form-data format)
files = {
"file": open(audio_path, "rb")
}
data = {
"model": "whisper-1",
"temperature": temperature
}
if language:
data["language"] = language
if prompt:
data["prompt"] = prompt

# Step 4: Send the request
print(f"Audio wird transkribiert: {audio_path} ...")
response = requests.post(WHISPER_API_URL, headers=headers, files=files, data=data)

# Step 5: Close the file
files["file"].close()

# Step 6: Process the response
if response.status_code == 200:
result = response.json()
text = result["text"]
print(f"Transkription abgeschlossen, insgesamt {len(text)} Zeichen.")
return {
"text": text,
"language": language
}
else:
error_msg = f"Request failed: {response.status_code} - {response.text}"
print(error_msg)
return {"error": error_msg}

def transcribe_with_timestamps(audio_path: str) -> dict:
"""
Transkription mit Zeitstempeln (unter Verwendung des verbose_json-Formats)
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
files = {"file": open(audio_path, "rb")}
data = {
"model": "whisper-1",
"response_format": "verbose_json", # Gibt detaillierte Informationen zurück, einschließlich Zeitstempeln
"timestamp_granularities": ["segment", "word"] # Unterstützt Zeitstempel auf Segment- und Wortebene
}

response = requests.post(WHISPER_API_URL, headers=headers, files=files, data=data)
files["file"].close()

if response.status_code == 200:
result = response.json()
return result
else:
return {"error": response.text}

def translate_audio_to_english(audio_path: str) -> dict:
"""
Audio aus jeder Sprache in englischen Text übersetzen
"""
headers = {
"Authorization": f"Bearer {OPENAI_API_KEY}"
}
files = {"file": open(audio_path, "rb")}
data = {
"model": "whisper-1",
"task": "translate" # Spezifisch angeben: Übersetzungsaufgabe
}

response = requests.post("https://api.openai.com/v1/audio/translations",
headers=headers, files=files, data=data)
files["file"].close()

if response.status_code == 200:
return response.json()
else:
return {"error": response.text}

def example_meeting_minutes_demo(audio_path: str) -> str:
"""
Praxis: Protokolle erstellen
Schritt 1: Aufnahme mit Whisper transkribieren
Schritt 2: Mit GPT-4o in ein Protokoll strukturieren
"""
# Zuerst transkribieren
print("Schritt 1: Meeting-Aufnahme wird transkribiert...")
transcribe_result = transcribe_audio_with_whisper(
audio_path,
language="zh",
prompt="Dies ist ein Meeting des technischen Teams von EXAMPLE, in dem Produktentwicklung, Fortschritte, technische Lösungen usw. besprochen werden."
)

if "error" in transcribe_result:
return transcribe_result["error"]

transcript = transcribe_result["text"]

# Dann strukturieren (hier vereinfacht; in einem echten Projekt können Sie die GPT-4o-API aufrufen)
print("Schritt 2: Meeting-Protokoll wird erstellt...")
# Zu Demonstrationszwecken den Transkripttext direkt zurückgeben
# In einem echten Projekt können Sie das Transkript an GPT-4o senden und es strukturieren lassen
return transcript

# ============================================
# Hauptprogramm
# ============================================

if __name__ == "__main__":
# Test-Audiodatei vorbereiten
test_audio = "example_test_audio.mp3"

if not os.path.exists(test_audio):
print(f"Hinweis: Bereiten Sie eine Audiodatei vor und nennen Sie sie {test_audio}")
print("Oder nehmen Sie eine Sprachnotiz auf Ihrem Telefon auf und speichern Sie sie als MP3")
else:
# Aufgabe 1: Einfache Transkription
print("\n" + "="*50)
print("Aufgabe 1: Einfache Transkription")
print("="*50)
result1 = transcribe_audio_with_whisper(test_audio, language="zh")
if "text" in result1:
print("Transkriptionsergebnis:")
print(result1["text"])

# Aufgabe 2: Transkription mit Zeitstempeln
print("\n" + "="*50)
print("Aufgabe 2: Transkription mit Zeitstempeln")
print("="*50)
result2 = transcribe_with_timestamps(test_audio)
if "segments" in result2:
print("Segmentinformationen:")
for seg in result2["segments"][:3]: # Nur die ersten 3 Segmente ausgeben
start = round(seg["start"], 2)
end = round(seg["end"], 2)
text = seg["text"]
print(f"[{start}-{end}] {text}")

print("\n" + "="*50)
print("EXAMPLE Whisper-Demo abgeschlossen!")
print("="*50)

Die Vorteile von Whisper sind: gute mehrsprachige Unterstützung, unempfindlich gegenüber Akzenten und automatische Interpunktion.

Typische Anwendungsbereiche: Transkription von Meeting-Aufnahmen, Erstellung von Video-Untertiteln, Podcast-Transkripte, Sprachtagebücher.

Text-to-Speech (TTS)

Mit Text-to-Speech kann KI Artikel "vorlesen".

OpenAI bietet auch eine TTS-API an, die mehrere Sprachstile unterstützt.

Andere TTS-Tools: ElevenLabs (am menschenähnlichsten), Azure TTS (für kommerzielle Zwecke), Edge TTS (kostenlos), Coqui (Open-Source).

Musikgenerierung (Suno, Udio)

Auch bei der Musikgenerierung hat es Durchbrüche gegeben.

Suno und Udio sind zwei repräsentative Produkte – Sie geben Liedtexte und Stilbeschreibungen ein, und sie können einen vollständigen Song mit Gesang und Begleitung generieren.

Leistungsgrenzen:

Möglich: Hintergrundmusik generieren, Song-Demos schreiben, Stile schnell ausprobieren.
Eingeschränkt bei: der exakten Kopie eines bestimmten Songs, der präzisen Steuerung von Noten, professioneller Nachbearbeitung.
Urheberrecht: Die Bedingungen variieren je nach Tool; bitte vor der kommerziellen Nutzung prüfen.

Einführung in multimodale Modellarchitekturen

Etwas Theorie hilft Ihnen, die Tools besser zu nutzen.

CLIP: Das Fundament der Bild-Text-Ausrichtung

CLIP (Contrastive Language-Image Pre-training) ist ein 2021 von OpenAI veröffentlichtes Modell.

Die Idee ist einfach: Bilder und Text gleichzeitig betrachten und lernen, sie einander zuzuordnen.

Geben Sie dem Modell während des Trainings eine Charge vonBild + Beschreibung-Paaren und lassen Sie es lernen:

1. Bilder in Vektoren umwandeln
2. Text in Vektoren umwandeln
3. Gepaarte Bild-Text-Vektoren so nah wie möglich und ungepaarte so weit wie möglich voneinander entfernen

CLIPs Bedeutung liegt in:Es hat bewiesen, dass „modalitätsübergreifendes Verstehen“ machbar ist。

Spätere Modelle wie Stable Diffusion und GPT-4o wurden alle von CLIP inspiriert.

LLaVA: Open-Source Multimodal LLM

LLaVA (Large Language and Vision Assistant) ist ein multimodales Open-Source-Modell.

Seine Architektur ist sehr klar:

Ein Vision-Encoder (z. B. ViT) – verantwortlich für das Sehen von Bildern
Ein großes Sprachmodell (z. B. LLaMA) – verantwortlich für das Sprechen
Eine Projektionsschicht – konvertiert Bildvektoren in ein Format, das das Sprachmodell verstehen kann

Das Training erfolgt in zwei Schritten:

Schritt 1: Prätraining-Ausrichtung – den Vision-Encoder und das Sprachmodell dazu bringen, dieselbe Sprache zu sprechen
Schritt 2: Instruktions-Feintuning – Training mit Bild-Frage-Antwort-Daten, um ihm beizubringen, gemäß Anweisungen zu antworten

LLaVA ist ein guter Ausgangspunkt für das Erlernen multimodaler Technologie – Open-Source-Code, klare Architektur, gute Ergebnisse.

Praxis: Erstellen eines Bildanalyse-Tools

Lassen Sie uns das bisherige Wissen integrieren und ein praktisches Bildanalyse-Tool entwickeln.

Beispiel

# ============================================
# File: example_image_analyzer.py
# Function: ein vollständiges multimodales Bildanalyse-Tool
# ============================================

import base64
import requests
import os
import json
from datetime import datetime
from typing import Optional, Dict, Any

class ExampleImageAnalyzer:
"""
EXAMPLE Bildanalyse – eine gekapselte multimodale Tool-Klasse
"""

def __init__(self, api_key: str, base_url: str = "https://api.openai.com/v1"):
"""
Analysator initialisieren

Parameter:
api_key: OpenAI API-Schlüssel
base_url: API-Adresse (konfigurierbarer Proxy)
"""
self.api_key = api_key
self.base_url = base_url
self.headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {api_key}"
}

def _encode_image(self, image_path: str) -> str:
"""Bild als Base64 kodieren"""
with open(image_path, "rb") as f:
return base64.b64encode(f.read()).decode("utf-8")

def _call_vision_api(
self,
image_path: str,
prompt: str,
model: str = "gpt-4o",
max_tokens: int = 2000
) -> Optional[str]:
"""Interne Methode: Vision-API aufrufen"""
base64_image = self._encode_image(image_path)

payload = {
"model": model,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}
}
]
}
],
"max_tokens": max_tokens
}

url = f"{self.base_url}/chat/completions"
response = requests.post(url, headers=self.headers, json=payload)

if response.status_code == 200:
return response.json()["choices"][0]["message"]["content"]
else:
print(f"API-Fehler: {response.status_code} - {response.text}")
return None

def describe(self, image_path: str) -> Optional[str]:
"""Den Bildinhalt detailliert beschreiben"""
prompt = """
Bitte beschreiben Sie dieses Bild deta einschließlich:
1. Hauptinhalt (welche Personen/Objekte sind vorhanden)
2. Hintergrundumgebung
3. Farben und Beleuchtung
4. Gesamte Atmosphäre
Auf Chinesisch antworten, mit einer klaren Struktur.
"""
return self._call_vision_api(image_path, prompt)

def extract_text(self, image_path: str) -> Optional[str]:
"""Gesamten Text aus dem Bild extrahieren (OCR)"""
prompt = """
Please extract all text content from this image.
Requirements:
1. Präzise und ohne Auslassungen wiedergeben
2. Die ursprüngliche Absatzstruktur beibehalten
3. Handelt es sich um eine Tabelle, als Markdown-Tabelle ausgeben
4. Wenn kein Text vorhanden ist, explizit „Kein erkennbarer Text im Bild“ angeben
"""
return self._call_vision_api(image_path, prompt)

def analyze_ui(self, image_path: str) -> Optional[str]:
"""UI-Design-Mockup (Screenshot) analysieren"""
prompt = """
Bitte analysieren Sie dieses UI-Design-Mockup:
1. Um welche Art von Benutzeroberfläche handelt es sich (APP, Webseite, Mini-Programm usw.)?
2. Was sind die Hauptfunktionsmodule der Benutzeroberfläche?
3. Welcher Designstil wird verwendet (Farbschema, Layout, Typografie)?
4. Was könnte verbessert werden?
Auf Chinesisch antworten, in Punkten aufgelistet.
"""
return self._call_vision_api(image_path, prompt)

def analyze_product(self, image_path: str) -> Optional[str]:
"""Produktbilder analysieren und E-Commerce-Werbetexte generieren"""
prompt = """
Bitte analysieren Sie dieses Produktbild und generieren Sie einen E-Commerce-Werbetext.
Der Werbetext sollte folgendes beinhalten:
1. Produktname und -typ
2. Äußere Merkmale (Farbe, Material, Design)
3. Eine attraktive Kurzdarstellung / Empfehlung (30-50 Zeichen)
Auf Chinesisch antworten, in einem freundlichen und positiven Ton.
"""
return self._call_vision_api(image_path, prompt)

def classify(self, image_path: str, categories: list = None) -> Optional[str]:
"""Das Bild klassifizieren"""
if categories is None:
categories = [
"Porträtfoto", "Landschaftsfoto", "Essensfoto", "Produktfoto",
"Design-Mockup/Screenshot", "Dokument/Tabelle", "Diagramm/Datenvisualisierung", "Anderes"
]
cat_list = "、".join(categories)
prompt = f"""
Bitte bestimmen Sie, zu welcher Kategorie dieses Bild gehört.
Optionale Kategorien: {cat_list}
Geben Sie nur den Namen der am besten übereinstimmenden Kategorie zurück, keinen anderen Text.
"""
return self._call_vision_api(image_path, prompt)

def full_analysis(self, image_path: str, output_dir: str = "example_analysis") -> Dict[str, Any]:
"""
Vollständige Analyse: Einen detaillierten Analysebericht generieren

Geben Sie ein Dict zurück, das alle Analyseergebnisse enthält
"""
print(f"Analysiere Bild: {image_path}")

# Zuerst klassifizieren
print("[1/5] Klassifiziere...")
category = self.classify(image_path) or "Unbekannt"

# Beschreibung
print("[2/5] Beschreibe...")
description = self.describe(image_path) or ""

# Text extrahieren
print("[3/5] OCR läuft...")
text = self.extract_text(image_path) or ""

# Spezalisierte Analyse basierend auf der Kategorie durchführen
print("[4/5] Spezalisierte Analyse läuft...")
special_analysis = ""
if "design" in category or "screenshot" in category:
special_analysis = self.analyze_ui(image_path) or ""
elif "product" in category or "merchandise" in category:
special_analysis = self.analyze_product(image_path) or ""

# Bericht speichern
print("[5/5] Generiere Bericht...")
if not os.path.exists(output_dir):
os.makedirs(output_dir)

timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
report = {
"image_file": os.path.basename(image_path),
"analysis_time": datetime.now().isoformat(),
"category": category,
"description": description,
"extracted_text": text,
"special_analysis": special_analysis
}

# JSON speichern
json_path = os.path.join(output_dir, f"report_{timestamp}.json")
with open(json_path, "w", encoding="utf-8") as f:
json.dump(report, f, ensure_ascii=False, indent=2)

# Lesbaren Text speichern
txt_path = os.path.join(output_dir, f"report_{timestamp}.txt")
with open(txt_path, "w", encoding="utf-8") as f:
f.write("="*60 + "\n")
f.write("BEISPIEL Bildanalysebericht\n")
f.write("="*60 + "\n\n")
f.write(f"Bild: {report['image_file']}"\n")
f.write(f"Zeit: {report['analysis_time']}"\n")
f.write(f"Kategorie: {report['category']}"\n\n")
f.write("-"*60 + "\n")
f.write("Bildbeschreibung:\n")
f.write("-"*60 + "\n")
f.write(report["description"] + "\n\n")
f.write("-"*60 + "\n")
f.write("Extrahierter Text:\n")
f.write("-"*60 + "\n")
f.write(report["extracted_text"] + "\n\n")
if report["special_analysis"]:
f.write("-"*60 + "\n")
f.write("Spezielle Analyse:\n")
f.write("-"*60 + "\n")
f.write(report["special_analysis"] + "\n")

print(f"Analyse abgeschlossen! Bericht gespeichert unter: {output_dir}")
return report

# ============================================
# Verwendungsbeispiel
# ============================================

def main():
# API-Schlüssel konfigurieren
api_key = "sk-your-api-key-here"

# Einen Analysator erstellen
analyzer = ExampleImageAnalyzer(api_key)

# Pfad des zu analysierenden Bildes
image_path = "example_test_image.jpg"

if not os.path.exists(image_path):
print(f"Bitte bereite das Bild vor: {image_path}")
return

# Methode 1: Eine einzelne Funktion separat verwenden
print("\n"Methode 1: Nur OCR verwenden")
print("-"*40)
text = analyzer.extract_text(image_path)
if text:
print("Extrahierter Text:")
print(text)

# Methode 2: Vollständige Analyse
print("\n"Methode 2: Vollständige Analyse")
print("-"*40)
report = analyzer.full_analysis(image_path)
print(f"Klassifizierungsergebnis: {report['category']}")
print(f"Bericht gespeichert")

if __name__ == "__main__":
main()

Dieses Tool kapselt gängige Bildanalysefunktionen und kann direkt in Projekten verwendet werden.

Du kannst es nach Bedarf erweitern:

Weitere Analyseszenarien hinzufügen (z. B. medizinische Bildgebung, industrielle Inspektion, Analyse von Bildungsfragen)
Eine einfache Webschnittstelle hinzufügen (mit Flask oder Gradio)
Stapelverarbeitung von Bildern in Ordnern unterstützen
Die Ergebnisse in einer Datenbank speichern

Weitere Erweiterungen