KI-Vision-Inspektor
Erstellen Sie KI-Systeme, die visuelle Daten analysieren, interpretieren und verstehen – von einfachen Bildbeschreibungen bis hin zu produktionsreifen Qualitätsinspektionssystemen.
Einführung
Computer Vision ist eine der wirkungsvollsten Anwendungen von KI. Von der Qualitätskontrolle in der Fertigung bis zur medizinischen Bildgebung – KI-Visionssysteme können Bilder mit einer Geschwindigkeit und Konsistenz analysieren, die menschliche Inspektoren übertrifft.
In diesem Leitfaden erstellen Sie einen vollständigen KI-Vision-Inspektor, der Bilder beschreiben, Objekte erkennen, Visuals vergleichen und automatisierte Qualitätsprüfungen durchführen kann.
Wie KI-Vision funktioniert
KI-Visionsmodelle verarbeiten Bilder durch eine mehrstufige Pipeline:
Bildeingabe
Das Bild wird geladen und in ein Format konvertiert, das das Modell verarbeiten kann (normalerweise Base64-Kodierung oder eine URL).
Merkmalsextraktion
Das Modell identifiziert Low-Level-Merkmale (Kanten, Formen, Texturen) und kombiniert sie zu höherstufigen Konzepten (Gesichter, Objekte, Szenen).
Semantische Analyse
Das Modell versteht, was die Objekte sind, ihre Beziehungen und den Gesamtkontext des Bildes.
Strukturierte Ausgabe
Die Analyse wird als natürlichsprachliche Beschreibungen, JSON-Daten oder Klassifizierungslabels zurückgegeben.
💡 Verfügbare Visionsmodelle
GPT-4o (OpenAI) und Claude 3.5 (Anthropic) sind die aktuellen Spitzenreiter für allgemeine Visionsaufgaben. Für spezialisierte Aufgaben wie medizinische Bildgebung oder Industrieinspektion übertreffen feinabgestimmte Modelle oft allgemeine Modelle.
Einrichtung
Installieren Sie die erforderlichen Bibliotheken für die Arbeit mit Bildern und der OpenAI-API:
pip install openai pillow opencv-python numpyimport openai
import base64
import os
from dotenv import load_dotenv
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def encode_image(image_path):
"""Convert an image file to base64 for the API."""
with open(image_path, "rb") as f:
return base64.b64encode(f.read()).decode("utf-8")Bildanalyse
Die einfachste Visionsaufgabe ist, die KI zu bitten, ein Bild zu beschreiben oder zu analysieren:
def analyze_image(image_path, question="What do you see in this image?"):
"""Analyze an image using GPT-4 Vision."""
base64_image = encode_image(image_path)
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": question},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}",
"detail": "high"
}
}
]
}
],
max_tokens=1000
)
return response.choices[0].message.content
# Usage
result = analyze_image("photo.jpg", "Describe this image in detail.")
print(result)Zwei Bilder vergleichen
Visionsmodelle können mehrere Bilder vergleichen, was nützlich ist für Qualitätskontrolle, Vorher/Nachher-Analyse und Änderungserkennung:
def compare_images(image_path_1, image_path_2, criteria):
"""Compare two images based on specific criteria."""
img1 = encode_image(image_path_1)
img2 = encode_image(image_path_2)
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": f"""Compare these two images.
Criteria: {criteria}
Provide a detailed comparison in JSON format:
{{"similarities": [...], "differences": [...],
"recommendation": "..."}}"""},
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img1}"}},
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img2}"}}
]
}
],
response_format={"type": "json_object"},
max_tokens=1000
)
return response.choices[0].message.contentObjekterkennung
KI kann einzelne Objekte innerhalb eines Bildes identifizieren und lokalisieren mit detaillierten Beschreibungen:
def detect_objects(image_path):
"""Detect and describe objects in an image."""
base64_image = encode_image(image_path)
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": """List every object you can
identify in this image. For each object provide:
- Name
- Approximate location (top-left, center, bottom-right, etc.)
- Color
- Size relative to the image (small, medium, large)
- Condition (if applicable)
Return as JSON: {"objects": [{"name": "", "location": "",
"color": "", "size": "", "condition": ""}]}"""},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}
}
]
}
],
response_format={"type": "json_object"},
max_tokens=1500
)
return response.choices[0].message.contentQualitätsinspektion
Industrielle Qualitätsinspektion ist eine der wertvollsten Anwendungen von KI-Vision. Hier ist eine wiederverwendbare Qualitätsinspektionsklasse:
class QualityInspector:
"""AI-powered visual quality inspection system."""
def __init__(self, reference_description=""):
self.client = openai.OpenAI()
self.reference = reference_description
self.inspection_log = []
def inspect(self, image_path, criteria=None):
"""Inspect a product image for quality issues."""
base64_image = encode_image(image_path)
prompt = f"""You are a quality control inspector.
Inspect this product image for defects or issues.
Reference standard: {self.reference}
{"Specific criteria: " + criteria if criteria else ""}
Report in JSON format:
{{"pass": true/false,
"confidence": 0.0-1.0,
"defects": [{{"type": "", "severity": "low/medium/high",
"location": "", "description": ""}}],
"overall_quality": "excellent/good/acceptable/poor/reject",
"notes": ""}}"""
response = self.client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "user", "content": [
{"type": "text", "text": prompt},
{"type": "image_url", "image_url": {
"url": f"data:image/jpeg;base64,{base64_image}"
}}
]}
],
response_format={"type": "json_object"}
)
result = response.choices[0].message.content
self.inspection_log.append(result)
return result
# Usage
inspector = QualityInspector(
reference_description="Smooth surface, no scratches, uniform color"
)
result = inspector.inspect("product_photo.jpg")
print(result)✅ Genauigkeit verbessern
Für kritische Qualitätsinspektion liefern Sie Referenzbilder von sowohl einwandfreien als auch fehlerhaften Produkten zusammen mit Ihrem Prompt. Verwenden Sie den 'high' Detail-Modus für die Bild-URL, um feine Defekte zu erfassen. Erwägen Sie mehrere Inspektionen pro Bild und Konsensentscheidung bei wichtigen Entscheidungen.
Echtzeit-Verarbeitung
Für Echtzeitanwendungen wie Überwachung oder Live-Inspektion können Sie Videoframes in regelmäßigen Intervallen verarbeiten:
import cv2
import time
def process_video_frames(video_source=0, interval=5):
"""Analyze video frames at regular intervals."""
cap = cv2.VideoCapture(video_source)
last_analysis = 0
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
current_time = time.time()
if current_time - last_analysis >= interval:
# Save frame temporarily
cv2.imwrite("temp_frame.jpg", frame)
# Analyze with AI
result = analyze_image(
"temp_frame.jpg",
"Describe what you see. Flag any safety concerns."
)
print(f"Analysis: {result}")
last_analysis = current_time
cv2.imshow("Vision Inspector", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()Zusammenfassung
Sie haben ein vollständiges KI-Vision-Inspektionssystem erstellt. Wichtigste Erkenntnisse:
- Moderne Visionsmodelle können Bilder mit bemerkenswerter Genauigkeit analysieren, vergleichen und verstehen.
- Objekterkennung und Qualitätsinspektion sind hochwertige reale Anwendungen.
- Für qualitätskritische Systeme verwenden Sie Referenzbilder und mehrere Inspektionsdurchgänge.
- Echtzeit-Verarbeitung ist durch Analyse von Videoframes in regelmäßigen Intervallen erreichbar.