Stabiles Diffusions-Tutorial: Erstellen Sie eine Generierungsgalerie-App mit Chroma Semantischer Suche

Was ist Stable Diffusion?

In den letzten Jahren hat ein bedeutender Fortschritt im Bereich der Künstlichen Intelligenz die Landschaft der digitalen Kunst neu gestaltet: KI-generierte Bilder. Seit dieser Entwicklung sind verschiedene Technologien zur Bildgenerierung entstanden, die das Publikum fesseln und weltweit Schlagzeilen machen. Unter diesen bahnbrechenden Technologien sticht ein quelloffenes Bildgenerierungsmodell hervor - Stable Diffusion.

Stable Diffusion gewann schnell an Bedeutung aufgrund seiner beeindruckenden Fähigkeiten und Offenheit und inspirierte eine neue Generation von Modellen. Mit seiner Fähigkeit, eine Vielzahl von Stilen aus kurzen, für Menschen lesbaren Eingabeaufforderungen zu generieren, hat Stable Diffusion die Hürden für die Erstellung von KI-Kunst erheblich gesenkt.

Aber was unterscheidet Stable Diffusion von anderen? Es bietet einzigartige Funktionen wie Inpainting und Outpainting. Inpainting ermöglicht es Benutzern, innerhalb des Bildes zu bearbeiten, was präzise Veränderungen und Anpassungen ermöglicht. Outpainting hingegen ermöglicht es Benutzern, das Bild über seine ursprünglichen Grenzen hinaus zu erweitern, was perfekt ist, um panoramatische Ansichten oder umfangreiche Szenen zu erstellen. Stable Diffusion unterstützt auch Bild-zu-Bild-Eingabeaufforderungen, eine Funktion, die es Benutzern ermöglicht, ein neues Bild basierend auf einem Ausgangsbild zu erstellen. Es ist, als würde man mit seiner KI sprechen, wobei das Ausgangsbild die Eingabeaufforderung ist und die KI mit einem völlig neuen Bild reagiert.

Was sind Chroma und Embeddings?

Nun wollen wir in ein spannendes Stück Technologie namens Chroma eintauchen. Chroma ist eine quelloffene Datenbank, die speziell für die Verarbeitung von Embeddings entwickelt wurde – einer Art der Datenrepräsentation, die häufig in der KI verwendet wird, insbesondere im Zusammenhang mit großen Sprachmodellen (LLMs). Ein LLM ist ein KI-Modell, das menschliche Texte basierend auf den eingegebenen Daten versteht und generiert.

Chroma funktioniert wie ein Spielplatz für diese KI-Modelle. Es erleichtert die Entwicklung von KI-Anwendungen, indem es eine Plattform zum Speichern, Abfragen und Analysieren von Medien-Embeddings bereitstellt. Medien können von Texten bis zu Bildern reichen, und in zukünftigen Versionen sind auch Audio und Video geplant.

In Chroma wird jedes Medium (z.B. ein Textdokument oder ein Bild) in eine mathematische Repräsentation umgewandelt, die als Embedding bekannt ist. Chroma kann diese Embeddings zusammen mit ihren zugehörigen Metadaten speichern, wodurch Medien in ein Format umgewandelt werden, das KI-Modelle leicht verstehen und damit interagieren können. Durch das Speichern der Embeddings ermöglicht Chroma eine einfache Identifizierung ähnlicher Medienobjekte, die Analyse von Medienkollektionen und vieles mehr.

Was sind also genau Embeddings? Einfach gesagt, Embeddings wandeln Wörter oder Bilder in Zahlen um, konkret in Vektoren in einem mehrdimensionalen Raum. Diese Technik ist mächtig, da sie "ähnliche" Elemente in diesem Raum nahe beieinander positioniert. Zum Beispiel positionieren Wort-Embeddings Wörter mit ähnlichen Bedeutungen nah beieinander. Dieses Konzept ist nicht auf Wörter beschränkt; man kann Embeddings für Sätze, Absätze, Dokumente oder sogar Bilder haben.

Im Zusammenhang mit Bild-Embeddings haben ähnliche Bilder (wie Katzenbilder) eng beieinanderliegende Embeddings und sind daher im mehrdimensionalen Embedding-Raum zusammen positioniert. Diese Eigenschaft macht Embeddings zu einem robusten Werkzeug für Aufgaben wie Bilderkennung oder Empfehlungssysteme. Kombiniere diese Kraft mit den Bildgenerierungsfähigkeiten von Stable Diffusion, und die Möglichkeiten sind endlos!

Was ist das Flask HTTP-Framework?

In der sich schnell entwickelnden Landschaft der Webentwicklung ist ein Framework, das stets heraussticht, Flask. Dieses auf Python basierende Webframework wird für seine Einfachheit und Leichtigkeit geschätzt, während seine Stärke und Flexibilität es zur bevorzugten Wahl für erfahrene Entwickler und Anfänger gleichermaßen machen.

Flask ist bekannt für seinen minimalistischen, pragmatischen Ansatz. Es schreibt keine strengen Bibliotheken oder Muster vor, sondern bietet ein schlankes Framework, das Entwicklern die Wahl lässt, was am besten zu ihrem Projekt passt. Diese Offenheit mindert nicht seine Funktionalität; tatsächlich kommt Flask direkt „out of the box“ mit einer robusten Reihe von Funktionen.

Zum Beispiel unterstützt Flask das Routing, um URLs elegant zu handhaben, sodass Benutzer durch Websites geleitet werden können. Es bietet Vorlagen für die einfache Erstellung dynamischer HTML-Seiten und erweckt Webanwendungen zum Leben. Darüber hinaus verwaltet Flask mit seiner Unterstützung für Cookies und Sitzungen die Benutzerdaten effektiv.

Das wahre Wunder liegt darin, wie Flask diese leistungsstarken Funktionen mit einem klaren, einfachen Design kombiniert. Mit nur einem grundlegenden Verständnis von Python können Entwickler schnell einen Flask-Webserver einrichten. Die Kombination aus Leistung, Flexibilität und Benutzerfreundlichkeit macht Flask zur erstklassigen Wahl unter den Webentwicklungs-Frameworks.

Voraussetzungen

• Grundkenntnisse in Python und Flask
• Zugriff auf die Stability.ai API
• Eine eingerichtete Chroma-Datenbank

Gliederung

1. Initialisierung des Projekts
2. Einrichten der erforderlichen Bibliotheken
3. Schreiben der Hauptdatei
4. Testen des grundlegenden Chatbots
5. Einrichten der Chroma-Datenbank
6. Testen des verbesserten Chatbots
7. Diskussion

Initialisierung des Projekts

Lass uns in den Code eintauchen! Unser erster Schritt ist, unser Projektverzeichnis einzurichten, das wir chroma-sd nennen werden. Öffne dein bevorzugtes Terminal und navigiere zu deinem Projektverzeichnis. Erstelle dann das Projektverzeichnis und gehe mit den folgenden Befehlen hinein:

mkdir chroma-sd
cd chroma-sd

Als verantwortungsbewusste Python-Entwickler erstellen wir eine neue virtuelle Umgebung für dieses Projekt. Diese Praxis stellt sicher, dass die Projektabhängigkeiten von der globalen Python-Umgebung getrennt sind, was ein wesentlicher Schritt ist, wenn man an mehreren Projekten mit unterschiedlichen Abhängigkeiten arbeitet. Eine virtuelle Umgebung ermöglicht es uns auch, die Abhängigkeiten in eine requirements.txt-Datei zu „einfrieren“, die sie für zukünftige Referenzen dokumentiert.

Um unsere virtuelle Umgebung zu erstellen, führe aus:

python -m venv env

Aktiviere nun die virtuelle Umgebung. Der Befehl variiert je nach deinem Betriebssystem:

• Windows: . envin ehmen
• Linux/MacOS: source env/bin/aktivieren

Nach der Aktivierung sollte der Name deiner Umgebung zu Beginn deiner Terminalaufforderung angezeigt werden.

Einrichten der erforderlichen Bibliotheken

Bevor wir mit dem Codieren beginnen, stelle sicher, dass alle notwendigen Bibliotheken installiert sind. Unsere Anwendung wird hauptsächlich Flask und ChromaDB verwenden:

• Flask: Ein leichtgewichtiges, flexibles Python-Webframework.
• ChromaDB: Eine robuste Datenbank für das Speichern und Abfragen von Embeddings.

Stelle sicher, dass du Python 3 verwendest, da Python 2 sein Ende erreicht hat. Überprüfe deine Python-Version, indem du python --version in dein Terminal eingibst.

Um die Bibliotheken zu installieren, verwende den Paketmanager „pip“ von Python. Diese Bibliotheken werden innerhalb der virtuellen Umgebung installiert:

pip install flask chromadb

Mit den installierten erforderlichen Bibliotheken sind wir bereit, unsere Anwendung zu erstellen.

Schreiben der Projektdateien

Jetzt lass uns wieder ins Programmieren eintauchen! Bevor wir beginnen, stelle sicher, dass du im Hauptprojektverzeichnis bist.

Öffne deine bevorzugte IDE oder deinen Code-Editor und erstelle eine neue Datei. Da wir mit Flask arbeiten, ist es konventionell, die Hauptdatei app.py zu nennen. Der flask run-Befehl sucht nach einer Anwendung in einer Datei mit dem Namen app.py im aktuellen Verzeichnis.

Denke daran, wenn deine Hauptanwendungsdatei anders benannt ist, kann der Speicherort mithilfe der Umgebungsvariablen FLASK_APP angegeben werden.

app.py

Importieren der notwendigen Module

Beginne damit, die notwendigen Module zu importieren:

• logging: Für Fehlerprotokollierung und Debugging.
• os: Für die Interaktion mit dem Betriebssystem.
• flask: Um die Webanwendung zu erstellen und zu verwalten.
• requests: Für das Durchführen von HTTP-Anfragen an die Bildgenerierungs-API.
• dotenv: Zum Laden von Umgebungsvariablen aus unserer .env-Datei.

Einrichten von Logging und Flask-App

Richte das Logging mit einem DEBUG-Level ein, um alle Nachrichten zu erfassen und auszugeben:

logging.basicConfig(level=logging.DEBUG)
app = Flask(__name__)

Laden von Umgebungsvariablen

Verwende load_dotenv(), um Umgebungsvariablen aus einer .env-Datei zu laden, die sensible Daten wie API-Schlüssel speichert:

load_dotenv()

Definieren von API-Endpunkten

Definiere mehrere API-Endpunkte, die verschiedene Aufgaben bearbeiten. Jede mit @app.route dekorierte Funktion entspricht einem bestimmten URL-Pfad:

• search_images: Bearbeitet Suchanfragen und gibt eine Liste von Bildgenerierungsanfragen zurück.
• generate: Verwalten von Anfragen zur Bildgenerierung.
• home: Rendert die Startseite.

Ausführen der Flask-App

Stelle sicher, dass die Flask-App nur ausgeführt wird, wenn das Skript direkt ausgeführt wird:

if __name__ == '__main__':
    app.run(debug=True)

index.html

Erstelle die Benutzeroberfläche, indem du eine grundlegende HTML-Datei mit einigen JavaScript-Funktionen schreibst. Verwende Tailwind CSS für das Styling:

<link href="https://cdn.jsdelivr.net/npm/tailwindcss@2.2.19/dist/tailwind.min.css" rel="stylesheet">

Die Funktion url_for() von Flask generiert URLs für statische Dateien wie JavaScript und Bilder. Weise einzigartige IDs für die Interaktion in JavaScript zu.

script.js

Diese JavaScript-Datei fügt Interaktivität zur Flask-App hinzu, sodass Bilder dynamisch geladen werden können, ohne die Seite zu aktualisieren:

window.onload = function() {
    const searchBtn = document.getElementById("searchBtn");
    const generateBtn = document.getElementById("generateBtn");
}
searchBtn.addEventListener("click", sendInput);
generateBtn.addEventListener("click", generateImages); 

.env

Diese Datei dient dazu, API-Schlüssel und andere Einstellungen als Umgebungsvariablen für Sicherheit und Flexibilität zu speichern:

STABILITY_API_KEY=your_stability_api_key

requirements.txt

Um Abhängigkeiten zu verwalten, erstelle eine requirements.txt-Datei. Aktiviere deine Umgebung und führe aus:

pip freeze > requirements.txt

Benutzer können Abhängigkeiten mit:

pip install -r requirements.txt

Die Projektstruktur

Nachdem du die oben genannten Schritte befolgt hast, sollte deine Projektstruktur wie folgt aussehen:

• app.py
• .env
• requirements.txt
• static/
• templates/
• .gitignore

Diese Struktur sorgt für Klarheit beim Navigieren und Verstehen des Projekts.

Abschließen der Endpunktfunktionen

Besuche app.py, um Endpunktfunktionen wie images() abzuschließen, die Bildgenerierungsanfragen zurückgeben, und generate(), um Anfragen zur Bildgenerierung zu bearbeiten.

Testen der Image Generation App

Um unsere App zu testen, führe den folgenden Befehl aus:

flask run

Wenn alles korrekt konfiguriert ist, siehst du die Ausgabe, die es dir ermöglicht, in deinem Browser zu localhost:5000 zu navigieren.

Generiere Bilder, indem du einen Texteingabeaufruf eingibst und auf die Schaltfläche "Generieren" klickst, und betrachte dann das generierte Bild unter dem Eingabefeld.

Hinzufügen der Funktion "Suche nach ähnlichem Begriff"

Als nächstes werden wir eine Suchfunktion implementieren, die ChromaDB verwendet, um ähnliche Begriffe anstelle von genauen Übereinstimmungen zu finden. Diese Funktion kann überraschende Ergebnisse liefern und ermöglicht nuancierte Suchen.

Beginne mit der Initialisierung von ChromaDB und der Einbettungsfunktion, und integriere dann ChromaDB in die Funktion images():

result_list = collection.query(search_term)

Aktualisiere zusätzlich die Funktion generate(), um Bildgenerierungsaufforderungen und Bildpfade als Metadaten in ChromaDB zu speichern:

collection.add(prompts)

Testen der Suchfähigkeiten der Image Gallery App

Teste die Suchfunktion, indem du verschiedene Bilder generierst und nach verwandten Begriffen suchst, und beobachte, wie Embeddings nuancierte Ergebnisse ermöglichen.

Fazit

Wir sind am Ende unseres Tutorials angekommen, bei dem wir eine Bildgenerierungsgalerie unter Verwendung von Stable Diffusion und der Chroma-Datenbank aufgebaut haben. Während die aktuelle App als grundlegende Demonstration dient, bleibt die Möglichkeit zur Erweiterung riesig, einschließlich der Speicherung von Embeddings und anspruchsvoller Suchfunktionen.

Mit Funktionen wie Inpainting für kreative Transformationen und verbesserten Suchfunktionen verspricht die Zukunft unserer Anwendung aufregende Entwicklungen!