Verwendung von GPT-4 zur Bildgenerierung und -analyse

Name

Lynn Mikami

Published on 30.4.2024

Die Einführung von GPT-4 hat eine signifikante Weiterentwicklung im Bereich der künstlichen Intelligenz markiert und seine Fähigkeiten über den Text hinaus auf die Bildgenerierung und -analyse ausgeweitet. In diesem Artikel werden die vielseitigen Funktionen von GPT-4 untersucht und insbesondere auf seine Fähigkeit zur Verarbeitung und Generierung von Bildern eingegangen. Es wird eine umfassende Anleitung zur effektiven Nutzung dieser Funktionen gegeben.

Was ist GPT-4?

GPT-4, oder Generative Pre-trained Transformer 4, ist eine fortschrittliche Weiterentwicklung von KI-Modellen, die von OpenAI entwickelt wurden. Es zeichnet sich durch sein verbessertes Verständnis und die Erzeugung von textähnlichem Inhalt aus, aber das Besondere an GPT-4 ist seine Fähigkeit zur Interaktion mit Bildern. Dazu gehören die Generierung von Bildern aus Beschreibungen (GPT-4 Vision oder GPT-4V), die Analyse des Inhalts von Bildern und sogar das Lesen von in Bildern erfasstem Text, was es zu einem vielseitigen Werkzeug für verschiedene Anwendungen macht.

Verständnis der Bildfähigkeiten von GPT-4

Die Bildfähigkeiten von GPT-4, oft als GPT-4 Vision oder GPT-4V bezeichnet, ermöglichen es ihm, Bilder auf Basis von textuellen Beschreibungen zu verarbeiten und zu erzeugen. Das bedeutet, dass Sie ein Bild zur Analyse hochladen oder das Modell bitten können, neue Bilder von Grund auf zu erstellen. Egal ob es um die Erstellung von Kunstwerken, die Generierung von visuellem Inhalt oder die Extraktion von Informationen aus Bildern geht, GPT-4V ist für eine Vielzahl von Aufgaben ausgestattet und stellt eine leistungsstarke Ergänzung zur GPT-4-Suite dar.

Generierung von Bildern mit GPT-4

Die Generierung von Bildern mit GPT-4 ist unkompliziert. Benutzer können eine detaillierte Beschreibung des gewünschten Bildes eingeben und das Modell generiert ein entsprechendes Bild. Diese Funktion ist besonders nützlich für Künstler, Designer und Content-Ersteller, die ihre Ideen zum Leben erwecken möchten, ohne auf manuelles Zeichnen oder Designkenntnisse angewiesen zu sein. Sie ist auch von unschätzbarem Wert für die Erstellung von visuellen Elementen, die den textbasierten Inhalt ergänzen und die Benutzererfahrung insgesamt verbessern.

Verwendung von GPT-4 zur Bildanalyse

Neben der Generierung von Bildern kann GPT-4 auch den Inhalt von Fotos analysieren und interpretieren. Dazu gehört das Lesen von Text in Bildern, die Erkennung von Objekten und das Verständnis von Szenen. Um diese Funktion zu nutzen, können Benutzer ein Bild auf die Plattform hochladen und GPT-4 liefert Erkenntnisse basierend auf der Analyse des Bildes. Diese Fähigkeit ist besonders nützlich für Aufgaben, die bildbasierte Forschung, Datenextraktion und Verbesserungen der Zugänglichkeit beinhalten, wie zum Beispiel das Lesen von Text für sehbehinderte Benutzer.

Praktische Anwendungen von GPT-4 Vision

Die potenziellen Anwendungen der Bildfähigkeiten von GPT-4 sind vielfältig. Im Bildungsbereich kann es interaktives Lernen durch die Generierung von visuellen Hilfsmitteln erleichtern oder historische Fotografien analysieren. Marketers können GPT-4 nutzen, um überzeugende visuelle Elemente für Kampagnen zu erstellen oder Verbraucherfotos für Erkenntnisse zu analysieren. Darüber hinaus kann GPT-4 in der Kreativbranche bei der Designprozessunterstützung helfen, indem es anhand von Feedback erste Konzepte generiert oder vorhandene visuelle Elemente modifiziert.

Kombination von GPT-4V mit RAG - Erstellung einer Kleider-Matchmaker-App

Willkommen im Jupyter Notebook für die Kleider-Matchmaker-App! Dieses Projekt demonstriert die Leistungsfähigkeit des GPT-4V-Modells bei der Analyse von Bildern von Kleidungsstücken und der Extraktion von Schlüsselfunktionen wie Farbe, Stil und Typ. Der Kern unserer App basiert auf diesem fortschrittlichen Bildanalysemodell, das von OpenAI entwickelt wurde und es uns ermöglicht, die Merkmale des eingegebenen Kleidungsstücks genau zu identifizieren.

GPT-4V ist ein Modell, das die Verarbeitung natürlicher Sprache mit der Bilderkennung kombiniert und es ihm ermöglicht, basierend auf textuellen und visuellen Eingaben zu verstehen und Antworten zu generieren.

Aufbauend auf den Fähigkeiten des GPT-4V-Modells setzen wir einen benutzerdefinierten Matching-Algorithmus und die RAG-Technik ein, um unsere Wissensdatenbank nach Produkten zu durchsuchen, die zu den identifizierten Merkmalen passen. Dieser Algorithmus berücksichtigt Faktoren wie Farbkompatibilität und stilistische Kohärenz, um den Benutzern geeignete Empfehlungen zu bieten. Durch dieses Notebook möchten wir die praktische Anwendung dieser Technologien bei der Erstellung eines Kleiderempfehlungssystems zeigen.

Die Kombination von GPT-4 Vision + RAG (Retrieval-Augmented Generation) bietet mehrere Vorteile:

• Kontextuelles Verständnis: GPT-4 Vision kann Eingangsbilder analysieren und den Kontext verstehen, wie z.B. dargestellte Objekte, Szenen und Aktivitäten. Dadurch ermöglicht es präzisere und relevantere Vorschläge oder Informationen in verschiedenen Bereichen wie Innenarchitektur, Kochen oder Bildung.
• Umfangreiches Wissensspektrum: RAG kombiniert die generativen Fähigkeiten von GPT-4 mit einem Retrieval-Teil, der auf eine große Menge von Informationen in verschiedenen Bereichen zugreift. Dadurch kann das System Vorschläge oder Einblicke basierend auf einem breiten Wissensspektrum liefern, von historischen Fakten bis hin zu wissenschaftlichen Konzepten.
• Anpassbarkeit: Dieser Ansatz ermöglicht eine einfache Anpassung an spezifische Benutzerbedürfnisse oder -präferenzen in verschiedenen Anwendungen. Ob es darum geht, Empfehlungen an den individuellen Geschmack in der Kunst anzupassen oder Bildungsinhalte auf der Basis des Lernniveaus eines Schülers bereitzustellen - das System kann an personalisierte Erfahrungen angepasst werden.

Insgesamt bietet der Ansatz GPT-4 Vision + RAG eine leistungsstarke und flexible Lösung für verschiedene Modeanwendungen, indem er die Stärken generativer und auf Abruf basierter KI-Techniken nutzt.

Einrichtung der Umgebung

Zuerst installieren wir die erforderlichen Abhängigkeiten, importieren dann die Bibliotheken und schreiben einige Hilfsfunktionen, die wir später verwenden werden.

import gensim
 
# Load the pre-trained word2vec model
word2vec_model = gensim.models.KeyedVectors.load_word2vec_format("data/word2vec/GoogleNews-vectors-negative300.bin.gz", binary=True)
 
# Function to compute the similarity between two embeddings using the word2vec model
def compute_similarity(embedding_1, embedding_2):
    return word2vec_model.wv.cosine_similarities(embedding_1, embedding_2)
 
# Function to find the most similar item in the dataset for a given input query
def find_similar_items(query, df, n_results=5):
    # Embed the query text
    query_embedding = client.embeddings.create(
        input=query,
        model=EMBEDDING_MODEL
    ).data.embedding
    
    # Compute the similarities between the query embedding and all item embeddings in the dataset
    similarities = df['embeddings'].apply(lambda x: compute_similarity(query_embedding, x))
    
    # Find the indices of the top-n most similar items
    top_indices = np.argpartition(similarities, -n_results)[-n_results:]
    
    # Get the corresponding item names
    top_items = df.iloc[top_indices]['productDisplayName'].tolist()
    
    return top_items
 
# Example usage
query = "blue t-shirt"
similar_items = find_similar_items(query, styles_df)

In diesem Abschnitt entwickeln wir einen Cosinus-Ähnlichkeitsabfragealgorithmus, um ähnliche Elemente in unserem DataFrame zu finden. Zu diesem Zweck verwenden wir unsere eigene benutzerdefinierte Cosinus-Ähnlichkeitsfunktion. Obwohl die sklearn-Bibliothek eine integrierte Cosinus-Ähnlichkeitsfunktion bietet, haben kürzliche Updates ihres SDK zu Kompatibilitätsproblemen geführt, wodurch wir unsere eigene Standard-Cosinus-Ähnlichkeitsberechnung implementieren müssen.

Wenn Sie bereits eine Vektordatenbank eingerichtet haben, können Sie diesen Schritt überspringen. Die meisten Standarddatenbanken verfügen über eigene Suchfunktionen, die die nachfolgenden Schritte in dieser Anleitung vereinfachen. Es ist jedoch unser Ziel, zu zeigen, dass der Übereinstimmungsalgorithmus an bestimmte Anforderungen angepasst werden kann, z. B. an einen bestimmten Schwellenwert oder eine festgelegte Anzahl von zurückgegebenen Übereinstimmungen.

Die find_similar_items-Funktion akzeptiert vier Parameter:

• embedding: Das Einbettung, für das wir eine Übereinstimmung finden möchten.
• embeddings: Eine Liste von Einbettungen, die durchsucht werden sollen, um die besten Übereinstimmungen zu finden.
• threshold (optional): Dieser Parameter legt den Mindest-Ähnlichkeitswert fest, der für eine Übereinstimmung als gültig betrachtet werden soll. Ein höherer Schwellenwert führt zu engeren (besseren) Übereinstimmungen, während ein niedrigerer Schwellenwert ermöglicht, dass mehr Elemente zurückgegeben werden, auch wenn sie nicht so eng mit der ursprünglichen Einbettung übereinstimmen.
• top_k (optional): Dieser Parameter bestimmt die Anzahl der zurückzugebenden Elemente, die den angegebenen Schwellenwert überschreiten. Dies sind die am besten bewerteten Übereinstimmungen für die bereitgestellte Einbettung.

def cosine_similarity_manual(vec1, vec2):
    """Berechnet die Cosinus-Ähnlichkeit zwischen zwei Vektoren."""
    vec1 = np.array(vec1, dtype=float)
    vec2 = np.array(vec2, dtype=float)
 
 
    dot_product = np.dot(vec1, vec2)
    norm_vec1 = np.linalg.norm(vec1)
    norm_vec2 = np.linalg.norm(vec2)
    return dot_product / (norm_vec1 * norm_vec2)
 
 
def find_similar_items(input_embedding, embeddings, threshold=0.5, top_k=2):
    """Findet die ähnlichsten Elemente basierend auf der Cosinus-Ähnlichkeit."""
    
    # Berechne die Cosinus-Ähnlichkeit zwischen der Eingabe-Einbettung und allen anderen Einbettungen
    similarities = [(index, cosine_similarity_manual(input_embedding, vec)) for index, vec in enumerate(embeddings)]
    
    # Filtere alle Ähnlichkeiten aus, die unterhalb des Schwellenwerts liegen
    filtered_similarities = [(index, sim) for index, sim in similarities if sim >= threshold]
    
    # Sortiere die gefilterten Ähnlichkeiten nach Ähnlichkeitswert
    sorted_indices = sorted(filtered_similarities, key=lambda x: x[1], reverse=True)[:top_k]
 
    # Gib die top-k ähnlichsten Elemente zurück
    return sorted_indices

def find_matching_items_with_rag(df_items, item_descs):
   """Nehmen Sie die Eingabeelementbeschreibungen und finden Sie die ähnlichsten Elemente basierend auf der Cosinus-Ähnlichkeit für jede Beschreibung."""
   
   # Wählen Sie die Einbettungen aus dem DataFrame aus.
   embeddings = df_items['embeddings'].tolist()
 
   
   similar_items = []
   for desc in item_descs:
      
      # Generieren Sie die Einbettung für das Eingabeelement
      input_embedding = get_embeddings([desc])
    
      # Finden Sie die ähnlichsten Elemente basierend auf der Cosinus-Ähnlichkeit
      similar_indices = find_similar_items(input_embedding, embeddings, threshold=0.6)
      similar_items += [df_items.iloc[i] for i in similar_indices]
    
   return similar_items

Analysemodul

In diesem Modul nutzen wir gpt-4-vision-preview, um Eingabbilder zu analysieren und wichtige Merkmale wie detaillierte Beschreibungen, Stile und Typen zu extrahieren. Die Analyse erfolgt über einen einfachen API-Aufruf, bei dem wir die URL des Bildes für die Analyse bereitstellen und das Modell bitten, relevante Merkmale zu identifizieren.

Um sicherzustellen, dass das Modell genaue Ergebnisse liefert, verwenden wir spezifische Techniken in unserer Anforderung:

1. Ausgabeformatfestlegung: Wir weisen das Modell an, einen JSON-Block mit einer vordefinierten Struktur zurückzugeben, der aus folgenden Bestandteilen besteht:

   • items (str[]): Eine Liste von Zeichenketten, die jeweils einen prägnanten Titel für ein Kleidungsstück darstellen, einschließlich Stil, Farbe und Geschlecht. Diese Titel ähneln stark der Eigenschaft productDisplayName in unserer ursprünglichen Datenbank.
   • category (str): Die Kategorie, die das jeweilige Element am besten repräsentiert. Das Modell wählt aus einer Liste aller eindeutigen articleTypes, die in der ursprünglichen Styles-Datenbeschreibung vorhanden sind.
   • gender (str): Ein Label, das das beabsichtigte Geschlecht des Elements angibt. Das Modell wählt aus den Optionen [Men, Women, Boys, Girls, Unisex].

2. Klare und prägnante Anweisungen:

   • Wir geben klare Anweisungen, was die Elementtitel enthalten sollten und wie das Ausgabeformat aussehen sollte. Die Ausgabe sollte im JSON-Format erfolgen, jedoch ohne das json-Tag, das normalerweise in der Modellantwort enthalten ist.

3. One-Shot-Beispiel:

   • Um die erwartete Ausgabe weiter zu verdeutlichen, geben wir dem Modell eine Beispiel-Eingabebeschreibung und eine entsprechende Beispiel-Ausgabe. Obwohl dadurch die Anzahl der verwendeten Tokens (und somit die Kosten des Aufrufs) steigen kann, hilft es dem Modell, besser zu arbeiten und liefert insgesamt bessere Ergebnisse.

Durch die Einhaltung dieses strukturierten Ansatzes möchten wir präzise und nützliche Informationen aus dem gpt-4-vision-preview-Modell erhalten, die wir anschließend für weitere Analysen und Integrationen in unsere Datenbank verwenden können.

def analyze_image(image_base64, subcategories):
    response = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """Gegeben ein Bild von einem Kleidungsstück, analysieren Sie das Kleidungsstück und generieren Sie eine JSON-Ausgabe mit den folgenden Feldern: "items", "category" und "gender". 
                           Verwenden Sie Ihr Verständnis für Modetrends, Stile und Geschlechtspräferenzen, um genaue und relevante Vorschläge dafür zu machen, wie das Outfit vervollständigt werden kann.
                           Das Feld "items" sollte eine Liste von Artikeln enthalten, die gut zu dem Artikel auf dem Bild passen würden. Jeder Artikel sollte einen Titel eines Kleidungsstücks enthalten, der den Stil, die Farbe und das Geschlecht des Artikels enthält.
```markdown
## Übersetzen des Markdown-Files
 
Das Feld 'language' muss auf 'de' gesetzt werden.
 
Das Beispiel zeigt, wie man das Model verwendet, um relevante Merkmale eines Kleidungsstücks aus einem Bild zu extrahieren.
 
```python
def analyze_image(image_base64, subcategories):
    import openai
    import json
 
    # Send the API request
    response = openai.ChatCompletion.create(
        model="gpt-4.0-turbo",
        messages=[
            {"role": "system", "content": "You are a helpful assistant that analyzes images of clothing items."},
            {"role": "user", "content": f"Please analyze the image and extract the relevant features."},
            {"role": "assistant", "content": f"The category needs to be chosen between the types in this list: {subcategories}."},
            {"role": "assistant", "content": "You have to choose between the genders in this list: [Men, Women, Boys, Girls, Unisex]"},
            {"role": "user", "content": "An image representing a black leather jacket."},
            {"role": "assistant", "content": "{\"items\": [\"Fitted White\n\n Women's T-shirt\", \"White Canvas Sneakers\", \"Women's Black Skinny Jeans\"], \"category\": \"Jackets\", \"gender\": \"Women\"}"},
            {"role": "user", "content": ""},
            {"role": "assistant", "content": ""},
            {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{image_base64}",
                },
            },
        ],
        max_tokens=300,
    )
    # Extract relevant features from the response
    features = response.choices[0].message.content
    return features

Testen des Prompts mit Beispielfotos

Um die Effektivität unseres Prompts zu bewerten, laden wir eine Auswahl von Bildern aus unserem Datensatz und testen diese. Wir verwenden Bilder aus dem Ordner "data/sample_clothes/sample_images", um eine Vielzahl von Stilen, Geschlechtern und Typen sicherzustellen. Hier sind die ausgewählten Beispiele:

• 2133.jpg: Herrenhemd
• 7143.jpg: Damenhemd
• 4226.jpg: Legeres Herren-T-Shirt mit Aufdruck

Durch das Testen des Prompts mit diesen verschiedenen Bildern können wir seine Fähigkeit einschätzen, relevante Merkmale verschiedener Arten von Kleidungsstücken und Accessoires genau zu analysieren und zu extrahieren.

Wir benötigen eine Hilfsfunktion, um die .jpg-Bilder in Base64 zu kodieren.

import base64
 
def encode_image_to_base64(image_path):
    with open(image_path, 'rb') as image_file:
        encoded_image = base64.b64encode(image_file.read())
        return encoded_image.decode('utf-8')

# Setze den Pfad zu den Bildern und wähle ein Testbild aus
image_path = "data/sample_clothes/sample_images/"
test_images = ["2133.jpg", "7143.jpg", "4226.jpg"]
 
# Kodiere das Testbild in Base64
reference_image = image_path + test_images[0]
encoded_image = encode_image_to_base64(reference_image)

# Wähle die eindeutigen Unterkategorien aus dem DataFrame aus
unique_subcategories = styles_df['articleType'].unique()
 
# Analysiere das Bild und gib die Ergebnisse zurück
analysis = analyze_image(encoded_image, unique_subcategories)
image_analysis = json.loads(analysis)
 
# Zeige das Bild und die Analyseergebnisse an
display(Image(filename=reference_image))
print(image_analysis)

Anschließend verarbeiten wir die Ausgabe der Bildanalyse und verwenden sie, um übereinstimmende Elemente aus unserem Datensatz herauszufiltern und anzuzeigen. Hier ist eine Erläuterung des Codes:

1. Extrahieren der Ergebnisse der Bildanalyse: Wir extrahieren die Artikelbeschreibungen, die Kategorie und das Geschlecht aus dem Wörterbuch image_analysis.

2. Filtern des Datensatzes: Wir filtern den DataFrame styles_df, um nur Artikel einzuschließen, die mit dem Geschlecht aus der Bildanalyse übereinstimmen (oder unisex sind) und Artikel derselben Kategorie wie das analysierte Bild ausschließen.

3. Suchen nach übereinstimmenden Elementen: Wir verwenden die Funktion find_matching_items_with_rag, um Elemente im gefilterten Datensatz zu finden, die mit den extrahierten Beschreibungen aus dem analysierten Bild übereinstimmen.

4. Anzeigen der übereinstimmenden Elemente: Wir erstellen einen HTML-String, um Bilder der übereinstimmenden Elemente anzuzeigen. Wir konstruieren die Bildpfade unter Verwendung der Artikel-IDs und fügen jedes Bild dem HTML-String hinzu. Schließlich verwenden wir display(HTML(html)), um die Bilder im Notebook anzuzeigen.

Diese Zelle demonstriert effektiv, wie man die Ergebnisse der Bildanalyse verwendet, um einen Datensatz zu filtern und visuell Elemente anzuzeigen, die den Merkmalen des analysierten Bildes entsprechen.

# Extrahiere die relevanten Merkmale aus der Analyse
item_descs = image_analysis['items']
item_category = image_analysis['category']
item_gender = image_analysis['gender']
 
 
# Filtere die Daten, so dass wir nur die Elemente mit demselben Geschlecht (oder Unisex) und einer anderen Kategorie betrachten
filtered_items = styles_df.loc[styles_df['gender'].isin([item_gender, 'Unisex'])]
filtered_items = filtered_items[filtered_items['articleType'] != item_category]
print(str(len(filtered_items)) + " verbleibende Elemente")
 
# Finde die ähnlichsten Elemente basierend auf den Artikelbeschreibungen
matching_items = find_matching_items_with_rag(filtered_items, item_descs)
 
# Zeige die übereinstimmenden Elemente an (für jede Beschreibung in der Bildanalyse werden 2 Elemente angezeigt)
html = ""
paths = []
for i, item in enumerate(matching_items):
    item_id = item['id']
        
    # Pfad zur Bilddatei
    image_path = f'data/sample_clothes/sample_images/{item_id}.jpg'
    paths.append(image_path)
    html += f'<img src="{image_path}" style="display:inline;margin:1px"/>'
 
# Drucke die Beschreibung des übereinstimmenden Elements zur Erinnerung an das gesuchte Element
print(item_descs)
# Zeige das Bild an
display(HTML(html))

Einhaltung von Grenzwerten

Im Zusammenhang mit der Verwendung von Large Language Models (LLMs) wie GPT-4V bezieht sich "Einhaltung von Grenzwerten" auf Mechanismen oder Überprüfungen, die sicherstellen, dass die Ausgabe des Modells innerhalb gewünschter Parameter oder Grenzen bleibt. Diese Grenzwerte sind entscheidend für die Qualität und Relevanz der Antworten des Modells, insbesondere bei komplexen oder nuancierten Aufgaben.

Grenzwerte sind aus mehreren Gründen nützlich:

1. Genauigkeit: Sie helfen sicherzustellen, dass die Ausgabe des Modells genau und relevant für die bereitgestellte Eingabe ist.
2. Konsistenz: Sie gewährleisten Konsistenz in den Antworten des Modells, insbesondere bei ähnlichen oder verwandten Eingaben.
3. Sicherheit: Sie verhindern, dass das Modell schädliche, anstößige oder unangemessene Inhalte generiert.
4. Kontextuelle Relevanz: Sie stellen sicher, dass die Ausgabe des Modells kontextuell relevant für die spezifische Aufgabe oder das spezifische Anwendungsfeld ist.

In unserem Fall verwenden wir GPT-4V, um Modenbilder zu analysieren und Artikel vorzuschlagen, die zu einem Original-Outfit passen würden. Um Leitplanken zu implementieren, können wir **Ergebnisse verfeinern**: Nachdem wir anfängliche Vorschläge von GPT-4V erhalten haben, können wir das Originalbild und die vorgeschlagenen Artikel an das Modell zurückschicken. Wir können dann GPT-4V bitten, zu bewerten, ob jeder vorgeschlagene Artikel tatsächlich gut zu dem Original-Outfit passt.

Dies gibt dem Modell die Möglichkeit, selbstkorrigierend zu sein und seine Ausgabe basierend auf Feedback oder zusätzlichen Informationen anzupassen. Durch die Implementierung dieser Leitplanken und die Aktivierung der Selbstkorrektur können wir die Zuverlässigkeit und Nützlichkeit der Ausgabe des Modells im Kontext der Modeanalyse und -empfehlung verbessern.

Um dies zu erleichtern, schreiben wir eine Anweisung, die den LLM nach einer einfachen "Ja" oder "Nein" Antwort auf die Frage fragt, ob die vorgeschlagenen Artikel zum Original-Outfit passen oder nicht. Diese binäre Antwort hilft dabei, den Verfeinerungsprozess zu optimieren und klare und umsetzbare Rückmeldungen vom Modell zu erhalten.

```python
def check_match(referenzbild_base64, vorgeschlagenes_bild_base64):
    antwort = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """ Ihnen werden zwei Bilder von zwei verschiedenen Kleidungsstücken gezeigt.
                            Ihr Ziel ist es zu entscheiden, ob die Gegenstände auf den Bildern zusammen in einem Outfit funktionieren würden.
                            Das erste Bild ist das Referenzobjekt (das Objekt, das der Benutzer mit einem anderen Objekt kombinieren möchte).
                            Sie müssen entscheiden, ob das zweite Objekt gut mit dem Referenzobjekt zusammenpassen würde.
                            Ihre Antwort muss eine JSON-Ausgabe mit den folgenden Feldern enthalten: "Antwort", "Begründung".
                            Das Feld "Antwort" muss entweder "Ja" oder "Nein" sein, abhängig davon, ob Sie denken, dass die Objekte gut zusammenpassen würden.
                            Das Feld "Begründung" muss eine kurze Erklärung Ihrer Entscheidungsgrundlage sein. Schließen Sie die Beschreibungen der beiden Bilder nicht ein.
                            Schließen Sie in der Ausgabe das ```json```-Tag nicht ein.
                           """,
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{referenzbild_base64}",
                },
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{vorgeschlagenes_bild_base64}",
                },
                }
            ],
            }
        ],
        max_tokens=300,
    )
    # Extrahieren relevanter Eigenschaften aus der Antwort
    eigenschaften = antwort.choices[0].message.content
    return eigenschaften

Schließlich bestimmen wir, welche der oben identifizierten Artikel tatsächlich zu dem Outfit passen.

# Wählen Sie die eindeutigen Pfade für die generierten Bilder aus
pfade = list(set(pfade))
 
for pfad in pfade:
    # Kodieren Sie das Testbild in Base64
    vorgeschlagenes_bild = bild_in_base64_kodieren(pfad)
    
    # Überprüfen, ob die Artikel übereinstimmen
    übereinstimmung = json.loads(check_match(kodiertes_bild, vorgeschlagenes_bild))
    
    # Zeigen Sie das Bild und die Analyseergebnisse an
    if übereinstimmung["Antwort"] == 'Ja':
        display(Image(filename=pfad))
        print("Die Artikel passen zusammen!")
        print(übereinstimmung["Begründung"])

Wir können beobachten, dass die anfängliche Liste potenzieller Artikel weiter verfeinert wurde und zu einer sorgfältig ausgewählten Auswahl führt, die gut zum Outfit passt. Darüber hinaus liefert das Modell Erklärungen dafür, warum jeder Artikel als gute Übereinstimmung betrachtet wird und bietet wertvolle Einblicke in den Entscheidungsprozess.

Bewertung

In diesem Tutorial haben wir die Anwendung von GPT-4 mit Vision und anderen maschinellen Lernmethoden im Bereich der Mode untersucht. Wir haben gezeigt, wie man Bilder von Kleidungsstücken analysiert, relevante Eigenschaften extrahiert und diese Informationen verwendet, um passende Artikel zu finden, die zu einem Original-Outfit passen. Durch die Implementierung von Leitplanken und Selbstkorrekturmechanismen haben wir die Vorschläge des Modells verfeinert, um sicherzustellen, dass sie korrekt und kontextuell relevant sind.

Diese Herangehensweise hat mehrere praktische Anwendungen in der realen Welt, einschließlich:

1. Personalisierte Einkaufsassistenten: Einzelhändler können diese Technologie nutzen, um personalisierte Outfit-Empfehlungen für Kunden anzubieten, um das Einkaufserlebnis zu verbessern und die Kundenzufriedenheit zu steigern.
2. Virtuelle Kleiderschrank-Anwendungen: Benutzer können Bilder ihrer eigenen Kleidungsstücke hochladen, um einen virtuellen Kleiderschrank zu erstellen und Vorschläge für neue Artikel zu erhalten, die zu ihren vorhandenen Stücken passen.
3. Mode-Design und Styling: Modedesigner und Stylisten können dieses Tool verwenden, um mit verschiedenen Kombinationen und Stilen zu experimentieren und den kreativen Prozess zu optimieren.

Allerdings ist einer der zu beachtenden Aspekte die Kosten. Der Einsatz von LLMs und Bildanalysemodellen kann Kosten verursachen, insbesondere bei umfangreicher Nutzung. Es ist wichtig, die Kostenwirksamkeit der Implementierung dieser Technologien zu berücksichtigen. gpt-4-vision-preview kostet $0.01 pro 1000 Tokens. Dies ergibt $0.00255 für ein Bild mit 256px x 256px.

Insgesamt dient dieser Leitfaden als Grundlage für weitere Erkundungen und Entwicklungen im Bereich der Mode und KI und eröffnet Möglichkeiten für personalisiertere und intelligentere Modeempfehlungssysteme.

Fazit

Die Erweiterung von GPT-4 in die Bildverarbeitung und -generierung markiert einen bedeutenden Meilenstein in der KI-Entwicklung. Indem man lernt, wie man GPT-4s Vision-Fähigkeiten nutzt, können Benutzer die Kraft der KI nutzen, um Bilder auf eine Art und Weise zu erstellen und zu analysieren, die zuvor für unmöglich gehalten wurde. Ob für kreative, Bildungs- oder analytische Zwecke, GPT-4 eröffnet neue Möglichkeiten, visuelle Elemente in die digitale Welt zu integrieren und sowohl die Erstellung als auch das Verständnis von Inhalten in verschiedenen Bereichen zu verbessern.