Lernpfad
Natürliche Sprachverarbeitung in Python
0 Min.
Vision Language Models (VLMs) verändern gerade die Industrie, weil sie KI-Systemen helfen, Bilder und Texte zu verstehen und zu verarbeiten. Anders als alte Computer-Vision-Modelle können moderne VLMs komplexe Bilder verstehen, detaillierte Fragen zu visuellen Inhalten beantworten und sogar Videos und Dokumente mit eingebettetem Text verarbeiten.
Diese Eigenschaft macht sie super für die medizinische Diagnose, automatisierte Qualitätskontrolle und sensible Anwendungen, bei denen es mehr auf Präzision als auf Geschwindigkeit ankommt.
In diesem Blog schauen wir uns die besten Vision-Language-Modelle von 2025 an, sowohl Open-Source-Modelle als auch proprietäre Optionen. Wir zeigen ihre einzigartigen Fähigkeiten und präsentieren dann ihre Leistung und Benchmark-Ergebnisse. Für Entwickler und Forscher haben wir auch Beispiel-Codeausschnitte beigefügt, damit du diese Modelle schnell selbst ausprobieren kannst.
Wenn du mehr über die Grundlagen dieser Modelle erfahren möchtest, schau dir unbedingt unseren Kurs „Bildverarbeitung in Python“ an. Bildverarbeitung in Python an.
1. Gemini 2.5 Pro
Gemini 2.5 Pro ist Googles fortschrittlichstes KI-Modell und führt aktuell die Ranglisten von LMArena und WebDevArena sowohl für Bildverarbeitungs- als auch für Programmieraufgaben an. Es ist für komplexes Denken und Verstehen von Texten, Bildern, Audio- und Videodateien gedacht.
Was die Fähigkeiten im Bereich Vision-Sprache angeht, ist es eines der besten Modelle auf der Open LLM-Rangliste. Gemini 2.5 Pro kann Bilder und Videos verstehen und detaillierte, kontextbezogene Beschreibungen erstellen, während es Fragen zu visuellen Inhalten beantwortet.
Quelle: Google Gemini
Du kannst Gemini 2.5 Pro kostenlos über die Gemini-Web-App unter gemini.google.com/app oder über Google AI Studio nutzen.
Für Entwickler ist Gemini 2.5 Pro auch über die Gemini API, Vertex AI und das offizielle Python SDK verfügbar, sodass die Bildverarbeitungsfunktionen ganz einfach in eigene Anwendungen oder Workflows integriert werden können.
Anwendungsbeispiel:
from google.genai import types
with open('path/to/image.jpg', 'rb') as f:
image_bytes = f.read()
response = client.models.generate_content(
model='gemini-2.5-pro',
contents=[
types.Part.from_bytes(
data=image_bytes,
mime_type='image/jpeg',
),
'Explain the image.'
]
)
print(response.text)2. InternVL3-78B
InternVL3 ist eine fortschrittliche Serie multimodaler großer Sprachmodelle (MLLMs), die besser ist als ihr Vorgänger InternVL 2.5. Es ist super in multimodaler Wahrnehmung und Argumentation und hat verbesserte Fähigkeiten, wie zum Beispiel Werkzeugnutzung, GUI-Agenten, industrielle Bildanalyse und 3D-Sichtwahrnehmung.
Das Modell InternVL3-78B nutzt InternViT-6B-448px-V2_5 für seine Bildverarbeitungskomponente und Qwen2.5-72B für seine Sprachkomponente. Mit insgesamt 78,41 Milliarden Parametern hat InternVL3-78B beim MMMU-Benchmark eine Punktzahl von 72,2 erreicht und damit einen neuen Rekord unter den Open-Source-MLLMs aufgestellt. Seine Leistung ist mit der von führenden proprietären Modellen vergleichbar.
Quelle: OpenGVLab/InternVL3-78B · Hugging Face
Anwendungsbeispiel:
# pip install lmdeploy>=0.7.3
from lmdeploy import pipeline, TurbomindEngineConfig, ChatTemplateConfig
from lmdeploy.vl import load_image
model = 'OpenGVLab/InternVL3-78B'
image = load_image('https://raw.githubusercontent.com/open-mmlab/mmdeploy/main/tests/data/tiger.jpeg')
pipe = pipeline(model, backend_config=TurbomindEngineConfig(session_len=16384, tp=4), chat_template_config=ChatTemplateConfig(model_name='internvl2_5'))
response = pipe(('Explain the image.', image))
print(response.text)3. Ovis2-34B
Ovis2 ist eine Reihe von multimodalen großen Sprachmodellen (MLLMs), die von AIDC-AI entwickelt wurden. Diese Modelle sind so gemacht, dass sie visuelle und textuelle Einbettungen gut aufeinander abstimmen. Das Modell Ovis2-34B nutzt vor allem aimv2-1B-patch14-448 als Bild-Encoder und Qwen2.5-32B-Instruct als Sprachmodell, mit insgesamt 34 Milliarden Parametern. Es unterstützt eine maximale Kontextlänge von 32.768 Tokens und nutzt die Genauigkeit bfloat16 für eine effiziente Verarbeitung.
Ovis2-34B hat bei verschiedenen Benchmark-Tests echt gut abgeschnitten und dabei die folgenden Ergebnisse erzielt:
- MMBench-V1.1: 86,6 %
- MMStar: 69,2 %
- MMMUval: 66,7 %
- MathVista: 76,1 %
- MMVet: 77,1 %
- VideoMME: 75,6 % mit Untertiteln
Quelle: AIDC-AI/Ovis2-34B · Hugging Face
Anwendungsbeispiel:
import torch
from PIL import Image
from transformers import AutoModelForCausalLM
# load model
model = AutoModelForCausalLM.from_pretrained("AIDC-AI/Ovis2-34B",
torch_dtype=torch.bfloat16,
multimodal_max_length=32768,
trust_remote_code=True).cuda()
text_tokenizer = model.get_text_tokenizer()
visual_tokenizer = model.get_visual_tokenizer()
# single-image input
image_path = '/data/images/example_1.jpg'
images = [Image.open(image_path)]
max_partition = 9
text = 'Describe the image.'
query = f'<image>\n{text}'
# format conversation
prompt, input_ids, pixel_values = model.preprocess_inputs(query, images, max_partition=max_partition)
attention_mask = torch.ne(input_ids, text_tokenizer.pad_token_id)
input_ids = input_ids.unsqueeze(0).to(device=model.device)
attention_mask = attention_mask.unsqueeze(0).to(device=model.device)
if pixel_values is not None:
pixel_values = pixel_values.to(dtype=visual_tokenizer.dtype, device=visual_tokenizer.device)
pixel_values = [pixel_values]
# generate output
with torch.inference_mode():
gen_kwargs = dict(
max_new_tokens=1024,
do_sample=False,
top_p=None,
top_k=None,
temperature=None,
repetition_penalty=None,
eos_token_id=model.generation_config.eos_token_id,
pad_token_id=text_tokenizer.pad_token_id,
use_cache=True
)
output_ids = model.generate(input_ids, pixel_values=pixel_values, attention_mask=attention_mask, **gen_kwargs)[0]
output = text_tokenizer.decode(output_ids, skip_special_tokens=True)
print(f'Output:\n{output}')4. Qwen2.5-VL-72B-Instruct
Qwen2.5-VL-72B-Instruct ist ein multimodales großes Sprachmodell (MLLM) aus der Qwen-Familie, das entwickelt wurde, um sowohl visuelle als auch textuelle Infos zu verstehen und zu verarbeiten. Viele Open-Source-MLLM-Modelle basieren darauf, was zeigt, dass die Qwen-Modellreihe eine wichtige Rolle bei der Weiterentwicklung der KI-Forschung spielt.
Qwen2.5-VL-72B-Instruct zeigt bei verschiedenen Benchmarks eine starke Leistung, einschließlich seiner Fähigkeiten im Bereich Bild- und Videoverständnis sowie bei Agentenfunktionen. Es erreicht 70,2 Punkte im MMMUval-Benchmark, 74,8 Punkte im MathVista_MINI und 70,8 Punkte im MMStar.
Quelle: Qwen/Qwen2.5-VL-72B-Instruct · Hugging Face
Anwendungsbeispiel:
# pip install qwen-vl-utils[decord]==0.0.8
from transformers import Qwen2_5_VLForConditionalGeneration, AutoTokenizer, AutoProcessor
from qwen_vl_utils import process_vision_info
# default: Load the model on the available device(s)
model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
"Qwen/Qwen2.5-VL-72B-Instruct", torch_dtype="auto", device_map="auto"
)
# default processer
processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-72B-Instruct")
messages = [
{
"role": "user",
"content": [
{
"type": "image",
"image": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen-VL/assets/demo.jpeg",
},
{"type": "text", "text": "Describe this image."},
],
}
]
# Preparation for inference
text = processor.apply_chat_template(
messages, tokenize=False, add_generation_prompt=True
)
image_inputs, video_inputs = process_vision_info(messages)
inputs = processor(
text=[text],
images=image_inputs,
videos=video_inputs,
padding=True,
return_tensors="pt",
)
inputs = inputs.to("cuda")
# Inference: Generation of the output
generated_ids = model.generate(**inputs, max_new_tokens=128)
generated_ids_trimmed = [
out_ids[len(in_ids) :] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
]
output_text = processor.batch_decode(
generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
)
print(output_text)5. o3 Neueste Version
OpenAI's o3 ist ein neues Denkmodell, das für mehr Intelligenz, niedrigere Kosten und eine effizientere Nutzung von Tokens in Anwendungen sorgen soll. Es ist eine neue Generation von Modellen, die auf fortschrittliche Denkfähigkeiten setzen.
Dieses Modell setzt neue Maßstäbe für Aufgaben in Mathe, Naturwissenschaften, Programmieren und visuelles Denken. Bei verschiedenen Sehtests ist es besser als o4-min und o1 und genauso gut wie o3 Pro.
Quelle: Wir stellen vor: OpenAI o3 und o4-mini | OpenAI
Anwendungsbeispiel:
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="o3-2025-04-16",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": "what's in this image?"},
{
"type": "input_image",
"image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
},
],
}],
)
print(response.output_text)6. GPT 4.1 (14.04.2025)
GPT-4.1 ist eine neue Familie von Modellen ohne Schlussfolgerungsfähigkeit, zu der GPT-4.1, GPT-4.1 Mini und GPT-4.1 Nano gehören. Diese Modelle haben ihre Vorgänger GPT-4o und GPT-4o Mini in verschiedenen Benchmarks übertroffen.
GPT-4.1 hat immer noch super Bildverarbeitungsfähigkeiten und kann jetzt auch besser Diagramme, Grafiken und visuelle Matheaufgaben analysieren. Es ist super bei Aufgaben wie dem Zählen von Objekten, der Beantwortung visueller Fragen und verschiedenen Formen der optischen Zeichenerkennung (OCR).
Quelle: Wir stellen GPT-4.1 in der API vor | OpenAI
Anwendungsbeispiel:
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-4.1-2025-04-14",
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": "what's in this image?"},
{
"type": "input_image",
"image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
},
],
}],
)
print(response.output_text)7. Claude Sonnet 4
Anthropic hat die nächste Generation seiner Claude-Modelle vorgestellt: Claude 4 Opus und Claude 4 Sonett. Diese Modelle sollen neue Standards in Sachen Codierung, fortgeschrittenes Denken und KI-Fähigkeiten setzen.
Sie haben bessere Sehfähigkeiten, mit denen man Bilder besser verstehen und dann Codes erstellen oder Infos zu den Bildern geben kann. Obwohl es im Grunde ein Codierungsmodell ist, hat es auch multimodale Fähigkeiten, sodass es verschiedene Dateiformate verstehen kann.
Wenn du dir die Vergleichstabelle unten ansiehst, wirst du feststellen, dass Claude 4 alle Top-Modelle außer dem GPT-3-Modell von OpenAI übertrifft, vor allem beim visuellen Schlussfolgern und bei der Beantwortung visueller Fragen.
Quelle: Wir stellen Claude 4 vor \ Anthropic
Anwendungsbeispiel:
import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=1024,
messages=[
{
"role": "user",
"content": [
{
"type": "image",
"source": {
"type": "url",
"url": "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
},
},
{
"type": "text",
"text": "Describe this image."
}
],
}
],
)
print(message)8. Kimi-VL-A3B-Thinking-2506
Das Kimi-VL-A3B-Thinking-2506 ist ein Open-Source-Modell, das einen großen Schritt in Richtung multimodale KI macht. Es ist super bei Tests für multimodales Denken und hat echt beeindruckende Genauigkeitswerte hingelegt: 56,9 bei MathVision, 80,1 bei MathVista, 46,3 bei MMMU-Pro und 64,0 bei MMMU, während die „Denkzeit” um durchschnittlich 20 % reduziert wurde.
Neben den Denkfähigkeiten zeigt die Version 2506 auch eine verbesserte allgemeine visuelle Wahrnehmung und ein besseres Verständnis. Es erreicht oder übertrifft sogar die Leistung von Modellen ohne künstliche Intelligenz in Benchmarks wie MMBench-EN-v1.1 (84,4), MMStar (70,4), RealWorldQA (70,0) und MMVet (78,4).
Quelle: MoonshotAI/Kimi-VL: Kimi-VL
Anwendungsbeispiel:
from transformers import AutoProcessor
from vllm import LLM, SamplingParams
model_path = "moonshotai/Kimi-VL-A3B-Thinking-2506"
llm = LLM(
model_path,
trust_remote_code=True,
max_num_seqs=8,
max_model_len=131072,
limit_mm_per_prompt={"image": 256}
)
processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
sampling_params = SamplingParams(max_tokens=32768, temperature=0.8)
import requests
from PIL import Image
def extract_thinking_and_summary(text: str, bot: str = "◁think▷", eot: str = "◁/think▷") -> str:
if bot in text and eot not in text:
return ""
if eot in text:
return text[text.index(bot) + len(bot):text.index(eot)].strip(), text[text.index(eot) + len(eot) :].strip()
return "", text
OUTPUT_FORMAT = "--------Thinking--------\n{thinking}\n\n--------Summary--------\n{summary}"
url = "https://huggingface.co/spaces/moonshotai/Kimi-VL-A3B-Thinking/resolve/main/images/demo6.jpeg"
image = Image.open(requests.get(url,stream=True).raw)
messages = [
{"role": "user", "content": [{"type": "image", "image": ""}, {"type": "text", "text": "What kind of cat is this? Answer with one word."}]}
]
text = processor.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt")
outputs = llm.generate([{"prompt": text, "multi_modal_data": {"image": image}}], sampling_params=sampling_params)
generated_text = outputs[0].outputs[0].text
thinking, summary = extract_thinking_and_summary(generated_text)
print(OUTPUT_FORMAT.format(thinking=thinking, summary=summary))9. Gemma-3-27b-it
Gemma 3 ist eine Familie multimodaler KI-Modelle, die von Google entwickelt wurden und sowohl Text- als auch Bildeingaben verarbeiten können, um Textausgaben zu erzeugen. Diese Modelle gibt's in verschiedenen Größen: 1B, 4B, 12B und 27B, die auf unterschiedliche Hardware- und Leistungsanforderungen zugeschnitten sind.
Die größte Variante, Gemma 3 27B, hat bei Tests mit Menschen echt gut abgeschnitten und sogar größere Modelle wie Llama 3-405B und DeepSeek-V3 übertroffen.
Die Modelle zeigen in verschiedenen Benchmarks starke Leistungen. Sie sind besonders gut bei multimodalen Aufgaben und haben bei Benchmarks wie COCOcap (116), DocVQA (85,6), MMMU (56,1) und VQAv2 (72,9) echt gute Ergebnisse erzielt.
Quelle: VLM-Rangliste öffnen
Anwendungsbeispiel:
# pip install accelerate
from transformers import AutoProcessor, Gemma3ForConditionalGeneration
from PIL import Image
import requests
import torch
model_id = "google/gemma-3-27b-it"
model = Gemma3ForConditionalGeneration.from_pretrained(
model_id, device_map="auto"
).eval()
processor = AutoProcessor.from_pretrained(model_id)
messages = [
{
"role": "system",
"content": [{"type": "text", "text": "You are a helpful assistant."}]
},
{
"role": "user",
"content": [
{"type": "image", "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"},
{"type": "text", "text": "Describe this image in detail."}
]
}
]
inputs = processor.apply_chat_template(
messages, add_generation_prompt=True, tokenize=True,
return_dict=True, return_tensors="pt"
).to(model.device, dtype=torch.bfloat16)
input_len = inputs["input_ids"].shape[-1]
with torch.inference_mode():
generation = model.generate(**inputs, max_new_tokens=100, do_sample=False)
generation = generation[0][input_len:]
decoded = processor.decode(generation, skip_special_tokens=True)
print(decoded)10. Llama-3.2-90B-Vision-Instruct
Die Llama 3.2 90B Vision Instruct-Modell ist ein fortschrittliches multimodales Sprachmodell, das von Meta entwickelt wurde. Es ist für Aufgaben wie visuelle Erkennung, Bildinterpretation und Bildbeschriftung gedacht.
Llama 3.2 90B Vision Instruct basiert auf der reinen Textversion Llama 3.1 und hat einen extra trainierten Bildverarbeitungsadapter, der Bilder und Text als Eingaben verarbeiten und präzise Textausgaben erstellen kann.
Das Modell Llama 3.2 90B Vision wurde in großem Stil trainiert und benötigte 8,85 Millionen GPU-Stunden. Es zeigt echt gute Leistung bei Benchmarks wie VQAv2 (73,6), Text VQA (73,5) und DocVQA (70,7).
Quelle: llama-models
Anwendungsbeispiel:
import requests
import torch
from PIL import Image
from transformers import MllamaForConditionalGeneration, AutoProcessor
model_id = "meta-llama/Llama-3.2-90B-Vision-Instruct"
model = MllamaForConditionalGeneration.from_pretrained(
model_id,
torch_dtype=torch.bfloat16,
device_map="auto",
)
processor = AutoProcessor.from_pretrained(model_id)
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg"
image = Image.open(requests.get(url, stream=True).raw)
messages = [
{"role": "user", "content": [
{"type": "image"},
{"type": "text", "text": "If I had to write a haiku for this one, it would be: "}
]}
]
input_text = processor.apply_chat_template(messages, add_generation_prompt=True)
inputs = processor(
image,
input_text,
add_special_tokens=False,
return_tensors="pt",
).to(model.device)
output = model.generate(**inputs, max_new_tokens=30)
print(processor.decode(output[0]))Abschließende Gedanken
Vision-Language-Modelle verändern total, wie wir mit visuellen und textuellen Infos umgehen, und bieten in vielen Branchen echt beeindruckende Genauigkeit und Flexibilität. Diese Modelle verbinden Computer Vision und natürliche Sprachverarbeitung nahtlos miteinander und ermöglichen so neue Anwendungen, von der fortgeschrittenen Objekterkennung bis hin zu intuitiven visuellen Assistenten.
Wenn Datenschutz und Sicherheit für dich super wichtig sind, schau dir mal Open-Source-Modelle für die Bildverarbeitung an. Wenn du diese Modelle lokal ausführst, hast du die volle Kontrolle über deine Daten, was sie perfekt für sensible Umgebungen macht. Open-Source-VLMs sind auch super anpassbar; die meisten kannst du mit nur ein paar hundert Samples feinabstimmen, um tolle Ergebnisse zu kriegen, die genau zu deinen Bedürfnissen passen.
Eigene Modelle hingegen bieten zuverlässigen und kostengünstigen Zugang zu modernsten Funktionen. Sie sind in der Regel sehr genau und lassen sich mit nur wenigen Zeilen Code in deinen Arbeitsablauf integrieren, sodass sie auch für Teams ohne tiefgreifende KI-Kenntnisse zugänglich sind.
Wenn du mehr über Sprachmodelle für Bilder erfahren möchtest, schau dir unbedingt diese Ressourcen an:
- Bildverarbeitung in Python: Praktische Übungen zu wichtigen Bildbearbeitungstechniken wie Manipulation, Analyse und Merkmalsextraktion.
- Deep Learning für Bilder mit PyTorch: Praktische Erfahrung mit Convolutional Neural Networks (CNNs), Transfer Learning und der Entwicklung von benutzerdefinierten Bildverarbeitungsmodellen.
- Natürliche Sprachverarbeitung in Python: Lernpfad zur Verarbeitung und Analyse von Textdaten, die für multimodale Anwendungen, die NLP und Computer Vision kombinieren, super wichtig sind.
