Einführung
Moderne Webanwendungen lassen sich durch die Integration künstlicher Intelligenz (KI) deutlich verbessern. Dieser Kurs konzentriert sich auf die fortgeschrittene Entwicklung vielseitiger Bots, die natürliche Sprachverarbeitung, Bildgenerierung und Spracherkennung nutzen. Diese Bots bieten ein einzigartiges Nutzererlebnis und binden Nutzer über verschiedene Interaktionswege ein.
Dieses Tutorial entwickelt einen vielseitigen Bot mithilfe des Django Big Language Model und OpenAI für Konversations-KI, Whisper für präzise Spracherkennung und DALL-E für die Bildgenerierung. Es beschreibt die Erstellung einer Webanwendung, die Geschichten mit passenden Bildern generiert. Nutzer können das Thema der Geschichte per Sprach- oder Texteingabe festlegen, woraufhin die Anwendung eine mit Bildern angereicherte Geschichte generiert.
Am Ende dieses Tutorials haben Sie eine Anwendung erstellt, die Benutzereingaben in verschiedenen Formen, darunter Text, Audio und Bilder, verstehen und darauf reagieren kann. Dies erhöht die Benutzerinteraktion mit der Anwendung erheblich und macht sie intuitiver und zugänglicher.
Voraussetzungen
- Grundkenntnisse in Python und Django
- Ein OpenAI-API-Schlüssel: Für dieses Tutorial müssen Sie mit den OpenAI-Modellen GPT-4 und DALL-E interagieren, wofür ein API-Schlüssel von OpenAI erforderlich ist.
- Flüstern
- OpenAI Python-Paket
Sobald Ihre Umgebung aktiv ist, führen Sie Folgendes aus, um das OpenAI Python-Paket zu installieren:
(env)sammy@ubuntu:$ pip install openaiSchritt 1 – OpenAI Whisper für die Spracherkennung integrieren
In diesem Schritt richten Sie OpenAI Whisper in Ihrer Django-Anwendung ein, um die Transkription von Sprache in Text zu ermöglichen. Whisper ist ein leistungsstarkes Spracherkennungsmodell, das präzise Transkriptionen liefert – eine wichtige Funktion für unseren vielseitigen Bot. Durch die Integration von Whisper kann unsere Anwendung Benutzereingaben per Sprache verstehen.
Stellen Sie zunächst sicher, dass Sie sich im Django-Projektverzeichnis befinden. Nach den vorbereitenden Tutorials müssen Sie ein Django-Projekt für diese Integration vorbereiten. Öffnen Sie Ihr Terminal, navigieren Sie zum Django-Projektverzeichnis und vergewissern Sie sich, dass Ihre virtuelle Umgebung aktiv ist.
sammy@ubuntu:$ cd path_to_your_django_project
sammy@ubuntu:$ source env/bin/activateWhisper in Ihrer Django-Anwendung einrichten
Nun muss eine Funktion erstellt werden, die mithilfe von Whisper Audiodateien in Text transkribiert. Erstellen Sie dazu eine neue Python-Datei namens whisper_transcribe.py.
(env)sammy@ubuntu:$ touch whisper_transcribe.pyÖffnen Sie whisper_transcribe.py in Ihrem Texteditor und geben Sie Whisper ein. Definieren wir nun eine Funktion, die den Pfad zu einer Audiodatei als Eingabe entgegennimmt, die Datei mit Whisper verarbeitet und anschließend die Transkription zurückgibt:
import whisper
model = whisper.load_model("base")
def transcribe_audio(audio_path):
result = model.transcribe(audio_path)
return result["text"]In diesem Codebeispiel verwenden Sie das “Basis”-Modell für die Transkription. Whisper bietet verschiedene Modelle für unterschiedliche Genauigkeits- und Leistungsanforderungen. Sie können ganz einfach mit anderen Modellen experimentieren, je nach Ihren Bedürfnissen.
Transkriptionstest
Um die Transkription zu testen, speichern Sie eine Audiodatei in Ihrem Django-Projektverzeichnis. Stellen Sie sicher, dass die Datei in einem von Whisper unterstützten Format vorliegt (z. B. MP3, WAV). Bearbeiten Sie nun die Datei whisper_transcribe.py, indem Sie die folgenden Zeilen am Ende hinzufügen:
# For testing purposes
if __name__ == "__main__":
print(transcribe_audio("path_to_your_audio_file"))Führen Sie whisper_transcribe.py mit Python aus, um die Transkription Ihrer Audiodatei in Ihrem Terminal anzuzeigen:
(env)sammy@ubuntu:$ python whisper_transcribe.pyWenn alles korrekt eingerichtet ist, sollte die transkribierte Textausgabe im Terminal angezeigt werden. Diese Funktion bildet die Grundlage für sprachbasierte Interaktionen in unserem Bot.
Schritt 2 – Textantworten mit GPT-4 erstellen
In diesem Schritt verwenden Sie GPT-4 LLM, um Textantworten basierend auf Benutzereingaben oder der im vorherigen Schritt erstellten Sprachtranskription zu generieren. Dank seines großen Sprachmodells kann GPT-4 kohärente und kontextrelevante Antworten erzeugen und ist daher ideal für unsere multimodale Bot-Anwendung geeignet.
Bevor Sie fortfahren, stellen Sie sicher, dass das OpenAI-Python-Paket wie in den Voraussetzungen beschrieben in Ihrer virtuellen Umgebung installiert ist. Für den Zugriff auf das GPT-4-Modell wird ein API-Schlüssel benötigt. Halten Sie diesen daher bereit. Sie können den OpenAI-API-Schlüssel Ihren Umgebungsvariablen hinzufügen, anstatt ihn direkt in die Python-Datei einzufügen.
(env)sammy@ubuntu:$ export OPENAI_KEY="your-api-key"Einrichtung des Chat-Abschlusses
Wechseln Sie in Ihr Django-Anwendungsverzeichnis und erstellen Sie eine neue Python-Datei namens chat_completion.py. Dieses Skript kommuniziert mit dem GPT-4-Modell, um basierend auf dem eingegebenen Text Antworten zu generieren.
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(input_text):
# Call the OpenAI API to generate the story
response = get_story(input_text)
# Format and return the response
return format_response(response)Dieser Codeabschnitt richtet zunächst den API-Schlüssel ein, der für die Authentifizierung bei OpenAI-Diensten erforderlich ist. Anschließend wird die separate Funktion `get_story` aufgerufen, um die OpenAI-API für die Geschichte abzurufen, und danach die Funktion `format_response`, um die API-Antwort zu formatieren.
Konzentrieren wir uns nun auf die Funktion get_story. Fügen Sie Folgendes am Ende Ihrer Datei chat_completion.py hinzu:
def get_story(input_text):
# Construct the system prompt. Feel free to experiment with different prompts.
system_prompt = f"""You are a story generator.
You will be provided with a description of the story the user wants.
Write a story using the description provided."""
# Make the API call
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": input_text},
],
temperature=0.8
)
# Return the API response
return responseIn dieser Funktion legen Sie zunächst den Systembefehl fest, der das Modell über die auszuführende Aufgabe informiert, und fordern dann die ChatCompletion-API auf, anhand des vom Benutzer eingegebenen Textes eine Geschichte zu generieren.
Abschließend können Sie die Funktion `format_response` implementieren. Fügen Sie dazu Folgendes am Ende Ihrer Datei `chat_completion.py` hinzu:
def format_response(response):
# Extract the generated story from the response
story = response.choices[0].message.content
# Remove any unwanted text or formatting
story = story.strip()
# Return the formatted story
return storyTesten Sie die generierten Antworten
Um die Textgenerierung zu testen, modifizieren Sie chat_completion.py, indem Sie am Ende einige Zeilen hinzufügen:
# For testing purposes
if __name__ == "__main__":
user_input = "Tell me a story about a dragon"
print(generate_story(user_input))Um die generierte Antwort in Ihrem Terminal anzuzeigen, führen Sie chat_completion.py mit Python aus:
(env)sammy@ubuntu:$ python chat_completion.pyAnhand der Aufgabenstellung sollten Sie eine kreative Antwort von GPT-4 sehen. Experimentieren Sie mit verschiedenen Eingaben, um unterschiedliche Antworten zu erhalten.
Im nächsten Schritt fügen Sie den generierten Geschichten Bilder hinzu.
Schritt 3 – Bilder mit DALL-E generieren
DALL-E wurde entwickelt, um aus Textnachrichten präzise Bilder zu erstellen, und der vielseitige Bot ermöglicht es Ihnen, Geschichten mit visueller Kreativität anzureichern.
Erstellen Sie in Ihrer Django-Anwendung eine neue Python-Datei namens image_generation.py. Dieses Skript verwendet das DALL-E-Modell, um das Bild zu generieren:
(env)sammy@ubuntu:$ touch image_generation.pyLasst uns in image_generation.py eine Funktion erstellen, die eine Benachrichtigung an DALL-E sendet und das generierte Bild abruft:
import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_image(text_prompt):
response = client.images.generate(
model="dall-e-3",
prompt=text_prompt,
size="1024x1024",
quality="standard",
n=1,
)
image_url = response.data[0].url
return image_urlDiese Funktion sendet eine Anfrage an das DALL-E-Modell, in der der Textbefehl, die Anzahl der zu generierenden Bilder (n=1) und die Bildgröße angegeben werden. Anschließend extrahiert sie die URL des generierten Bildes und gibt diese zurück.
Skripttest
Um die Verwendung dieser Funktion in einem Django-Projekt zu demonstrieren, können Sie das folgende Beispiel am Ende Ihrer image_generation.py-Datei hinzufügen:
# For testing purposes
if __name__ == "__main__":
prompt = "Generate an image of a pet and a child playing in a yard."
print(generate_image(prompt))Führen Sie image_generation.py mit Python aus, um ein Bild basierend auf dem angegebenen Befehl zu erstellen:
(env)sammy@ubuntu:$ python image_generation.pyWenn das Skript erfolgreich ausgeführt wird, wird die generierte Bild-URL im Terminal angezeigt. Sie können das Bild dann über diese URL in Ihrem Webbrowser anzeigen.
Im nächsten Schritt werden Sie die Spracherkennung mit der Text- und Bildgenerierung verbinden, um ein nahtloses Benutzererlebnis zu schaffen.
Schritt 4 – Methoden für ein nahtloses Erlebnis kombinieren
In dieser Phase werden Sie die in den vorherigen Phasen entwickelten Funktionen integrieren, um ein nahtloses Benutzererlebnis zu gewährleisten.
Ihre Webanwendung wird in der Lage sein, Text- und Spracheingaben von Benutzern zu verarbeiten, Geschichten zu generieren und diese mit passenden Bildern zu ergänzen.
Eine einheitliche Ansicht erstellen
Stellen Sie zunächst sicher, dass Ihr Django-Projekt gut organisiert ist und dass sich die Dateien whisper_transcribe.py, chat_completion.py und image_generation.py im Django-App-Verzeichnis befinden. Anschließend erstellen Sie eine Ansicht, die diese Komponenten kombiniert.
Öffnen Sie Ihre views.py-Datei und importieren Sie die benötigten Module und Funktionen. Erstellen Sie anschließend eine neue Ansicht namens get_story_from_description:
import uuid
from django.core.files.storage import FileSystemStorage
from django.shortcuts import render
from .whisper_transcribe import transcribe_audio
from .chat_completion import generate_story
from .image_generation import generate_image
# other views
def get_story_from_description(request):
context = {}
user_input = ""
if request.method == "GET":
return render(request, "story_template.html")
else:
if "text_input" in request.POST:
user_input += request.POST.get("text_input") + "\n"
if "voice_input" in request.FILES:
audio_file = request.FILES["voice_input"]
file_name = str(uuid.uuid4()) + (audio_file.name or "")
FileSystemStorage(location="/tmp").save(file_name, audio_file)
user_input += transcribe_audio(f"/tmp/{file_name}")
generated_story = generate_story(user_input)
image_prompt = (
f"Generate an image that visually illustrates the essence of the following story: {generated_story}"
)
image_url = generate_image(image_prompt)
context = {
"user_input": user_input,
"generated_story": generated_story.replace("\n", "<br/>"),
"image_url": image_url,
}
return render(request, "story_template.html", context)Diese Ansicht liest Text- und/oder Audioeingaben vom Benutzer ein. Falls eine Audiodatei vorhanden ist, wird diese unter einem eindeutigen Namen (mithilfe der UUID-Bibliothek) gespeichert und die Sprachausgabe mithilfe der Funktion `transcribe_audio` in Text umgewandelt. Anschließend werden mit der Funktion `gene_story` eine Textantwort und mit der Funktion `gene_image` ein zugehöriges Bild generiert. Diese Ausgaben werden an das Textwörterbuch übergeben, das dann mit `story_template.html` gerendert wird.
Erstellen Sie eine Vorlage
Erstellen Sie anschließend eine Datei namens story_template.html und fügen Sie Folgendes hinzu:
<div style="padding:3em; font-size:14pt;">
<form method="post" enctype="multipart/form-data">
{% csrf_token %}
<textarea name="text_input" placeholder=" Describe the story you would like" style="width:30em;"></textarea>
<br/><br/>
<input type="file" name="voice_input" accept="audio/*" style="width:30em;">
<br/><br/>
<input type="submit" value="Submit" style="width:8em; height:3em;">
</form>
<p>
<strong>{{ user_input }}</strong>
</p>
{% if image_url %}
<p>
<img src="{{ image_url }}" alt="Generated Image" style="max-width:80vw; width:30em; height:30em;">
</p>
{% endif %}
{% if generated_story %}
<p>{{ generated_story | safe }}</p>
{% endif %}
</div>Dieses einfache Formular ermöglicht es Nutzern, ihre Anfragen per Text oder durch Hochladen einer Audiodatei einzureichen. Anschließend werden der von der App generierte Text und das Bild angezeigt.
URL für Ansicht erstellen
Nachdem Sie die get_story_from_description-Ansicht erstellt haben, müssen Sie sie über eine URL-Konfiguration verfügbar machen.
Öffnen Sie die Datei urls.py in Ihrer Django-Anwendung und fügen Sie eine Vorlage für die Ansicht get_story_from_description hinzu:
from django.urls import path
from . import views
urlpatterns = [
# other patterns
path('generate-story/', views.get_story_from_description, name='get_story_from_description'),
]Unified Experience Testing
Sie können nun http://your_domain/generate-story/ in Ihrem Webbrowser aufrufen. Dort sollte das in story_template.html definierte Formular angezeigt werden. Versuchen Sie, eine Textanfrage über das Texteingabefeld abzusenden oder eine Audiodatei über das Dateiauswahlfeld hochzuladen. Nach dem Absenden werden Ihre Eingaben verarbeitet, eine Geschichte und ein zugehöriges Bild generiert und auf der Seite angezeigt.
Hier ist beispielsweise eine Beispiel-Erzählanregung: “Erzähl mir eine Geschichte über ein Haustier und ein Kind, die im Garten spielen.”
Mit diesem Schritt haben Sie eine Anwendung erstellt, die Benutzereingaben in verschiedenen Formen verarbeitet und darauf reagiert.
Ergebnis
In diesem Tutorial haben Sie erfolgreich einen vielseitigen Bot mit Django entwickelt, der die Integrationsfunktionen von Whisper für Spracherkennung, GPT-4 für Textgenerierung und DALL-E für Bildgenerierung nutzt. Ihr Programm kann nun Benutzereingaben in verschiedenen Formaten verstehen und darauf reagieren.
Für die Weiterentwicklung empfiehlt es sich, alternative Versionen der Modelle Whisper, GPT und DALL-E zu untersuchen, das UI/UX-Design Ihrer App zu verbessern oder die Funktionalität des Bots um zusätzliche interaktive Funktionen zu erweitern.
