Desarrollo de bots multifacéticos con Django, GPT-4, Whisper y DALL-E

Introducción

Las aplicaciones web modernas pueden alcanzar un nuevo nivel mediante la integración de inteligencia artificial. Este curso se centra en el desarrollo avanzado de bots multifacéticos que utilizan procesamiento de lenguaje natural, generación de imágenes y reconocimiento de voz. Estos bots ofrecen una experiencia de usuario única y los involucran mediante múltiples modos de interacción.

Este tutorial desarrolla un bot multifacético utilizando el Modelo de Lenguaje Grande de Django y OpenAI para IA conversacional, Whisper para la transcripción precisa del habla y DALL-E para la generación de imágenes. Describe la creación de una aplicación web que genera historias con imágenes. Los usuarios pueden especificar el tema de la historia con voz o texto, y la aplicación responde con una historia generada y decorada con elementos visuales.

Al finalizar este tutorial, habrá creado una aplicación capaz de comprender y responder a la entrada del usuario en diversos formatos, como texto, audio e imágenes. Esto aumenta significativamente la interacción del usuario con la aplicación, haciéndola más intuitiva y accesible.

Requisitos previos

• Conocimientos básicos de Python y Django
• Una clave API de OpenAI: este tutorial requiere que interactúe con los modelos GPT-4 y DALL-E de OpenAI, que requieren una clave API de OpenAI.
• Susurro
• Paquete Python de OpenAI

Una vez que su entorno esté activo, ejecute lo siguiente para instalar el paquete Python de OpenAI:

(env)sammy@ubuntu:$ pip install openai

Paso 1: Integrar OpenAI Whisper para el reconocimiento de voz

En este paso, configurará OpenAI Whisper en su aplicación Django para que pueda transcribir voz a texto. Whisper es un modelo robusto de reconocimiento de voz que proporciona transcripciones precisas, una característica importante para nuestro bot multifacético. Al integrar Whisper, nuestra aplicación podrá comprender la entrada de voz del usuario.

Primero, asegúrate de estar trabajando en el directorio del proyecto de Django. Después de los tutoriales de prerrequisitos, deberás preparar un proyecto de Django para esta integración. Abre tu terminal, navega al directorio del proyecto de Django y asegúrate de que tu entorno virtual esté activo:

sammy@ubuntu:$ cd path_to_your_django_project
sammy@ubuntu:$ source env/bin/activate

Configurando Whisper en tu aplicación Django

Ahora es necesario crear una función que use Whisper para transcribir archivos de audio a texto. Cree un nuevo archivo de Python llamado whisper_transcribe.py.

(env)sammy@ubuntu:$ touch whisper_transcribe.py

Abra whisper_transcribe.py en su editor de texto y escriba Whisper. A continuación, definamos una función que tome la ruta de un archivo de audio como entrada, use Whisper para procesarlo y luego devuelva la transcripción:

import whisper
model = whisper.load_model("base")


def transcribe_audio(audio_path):
result = model.transcribe(audio_path)
return result["text"]

En este fragmento de código, se utiliza el modelo "base" para la transcripción. Whisper ofrece diferentes modelos que se adaptan a diferentes necesidades de precisión y rendimiento. Puede experimentar fácilmente con otros modelos según sus necesidades.

Prueba de transcripción

Para probar la transcripción, guarda un archivo de audio en el directorio de tu proyecto de Django. Asegúrate de que el archivo esté en un formato compatible con Whisper (como MP3 o WAV). Ahora, modifica whisper_transcribe.py añadiendo las siguientes líneas al final:

# For testing purposes
if __name__ == "__main__":
print(transcribe_audio("path_to_your_audio_file"))

Ejecute whisper_transcribe.py con Python para ver la transcripción de su archivo de audio en su terminal:

(env)sammy@ubuntu:$ python whisper_transcribe.py

Si todo está configurado correctamente, debería ver la salida de texto transcrito en la terminal. Esta función sirve como base para las interacciones de voz en nuestro bot.

Paso 2: Crear respuestas de texto con GPT-4

En este paso, se utiliza GPT-4 LLM para generar respuestas de texto basadas en la entrada del usuario o la transcripción de voz obtenida en el paso anterior. GPT-4, con su amplio modelo de lenguaje, puede generar respuestas coherentes y contextuales, lo que lo convierte en la opción ideal para nuestra aplicación de bot multimodal.

Antes de continuar, asegúrese de que el paquete Python de OpenAI esté instalado en su entorno virtual, como se describe en los prerrequisitos. El modelo GPT-4 requiere una clave API para acceder a él, así que asegúrese de tenerla lista. Puede agregar la clave API de OpenAI a sus variables de entorno en lugar de agregarla directamente al archivo Python:

(env)sammy@ubuntu:$ export OPENAI_KEY="your-api-key"

Configurar la finalización del chat

Ve al directorio de tu aplicación Django y crea un nuevo archivo Python llamado chat_completion.py. Este script se comunicará con el modelo GPT-4 para generar respuestas basadas en el texto de entrada.

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)

Este fragmento de código configura primero la clave de API necesaria para la autenticación con los servicios de OpenAI. A continuación, llama a una función independiente, get_story, para llamar a la API con OpenAI para la historia, y a otra función, format_response, para dar formato a la respuesta de la API.

Ahora centrémonos en la función get_story. Agrega lo siguiente al final del archivo chat_completion.py:

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 response

En esta función, primero configura el comando del sistema, que informa al modelo sobre la tarea que debe realizar, y luego solicita a la API ChatCompletion que genere una historia utilizando el texto de entrada del usuario.

Finalmente, puedes implementar la función format_response. Agrega lo siguiente al final del archivo chat_completion.py:

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 story

Pruebe las respuestas generadas

Para probar la generación de texto, modifique chat_completion.py agregando algunas líneas en la parte inferior:

# For testing purposes
if __name__ == "__main__":
user_input = "Tell me a story about a dragon"
print(generate_story(user_input))

Para ver la respuesta generada en su terminal, ejecute chat_completion.py con Python:

(env)sammy@ubuntu:$ python chat_completion.py

Según la indicación, deberías ver una respuesta creativa de GPT-4. Experimenta con diferentes entradas para ver diferentes respuestas.

En el siguiente paso, agrega imágenes a las historias generadas.

Paso 3 – Generar imágenes con DALL-E

DALL-E está diseñado para crear imágenes precisas a partir de mensajes de texto, y el bot multifacético le permite mejorar historias con creatividad visual.

Crea un nuevo archivo Python llamado image_generation.py en tu aplicación Django. Este script utiliza el modelo DALL-E para generar la imagen:

(env)sammy@ubuntu:$ touch image_generation.py

Creemos una función en image_generation.py que envíe una notificación a DALL-E y recupere la imagen generada:

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_url

Esta función envía una solicitud al modelo DALL-E especificando el comando de texto, el número de imágenes a generar (n=1) y su tamaño. A continuación, extrae y devuelve la URL de la imagen generada.

Prueba de guión

Para demostrar el uso de esta función en un proyecto Django, puede agregar el siguiente ejemplo al final de su archivo image_generation.py:

# For testing purposes
if __name__ == "__main__":
prompt = "Generate an image of a pet and a child playing in a yard."
print(generate_image(prompt))

Ejecute image_generation.py con Python para crear una imagen basada en el comando dado:

(env)sammy@ubuntu:$ python image_generation.py

Si el script se ejecuta correctamente, verá la URL de la imagen generada en la terminal. Podrá verla accediendo a esta URL en su navegador web.

En el siguiente paso, combinará el reconocimiento de voz con la generación de texto e imágenes para ofrecer una experiencia de usuario perfecta.

Paso 4: Combine métodos para una experiencia fluida

En esta fase, integrarás las capacidades desarrolladas en fases anteriores para brindar una experiencia de usuario perfecta.

Su aplicación web podrá procesar entradas de texto y voz de los usuarios, generar historias y complementarlas con imágenes relevantes.

Crear una vista unificada

Primero, asegúrate de que tu proyecto de Django esté organizado y de que tengas whisper_transcribe.py, chat_completion.py e image_generation.py en el directorio de tu aplicación de Django. Ahora crearás una vista que combine estos componentes.

Abra el archivo views.py e importe los módulos y funciones necesarios. Luego, cree una nueva vista llamada 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)

Esta vista recupera la entrada de texto o audio del usuario. Si existe un archivo de audio, lo guarda con un nombre único (usando la biblioteca uuid) y utiliza la función transcripte_audio para convertir la voz a texto. Posteriormente, utiliza la función gene_story para generar una respuesta de texto y la función gene_image para generar una imagen asociada. Estas salidas se envían al diccionario de texto, que se renderiza con story_template.html.

Crear una plantilla

Luego crea un archivo llamado story_template.html y agrega lo siguiente:

<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>

Este sencillo formulario permite a los usuarios enviar sus solicitudes por mensaje de texto o subiendo un archivo de audio. A continuación, muestra el texto y la imagen generados por la aplicación.

Crear URL para ver

Ahora que tiene la vista get_story_from_description lista, debe hacerla disponible creando una configuración de URL.

Abra su archivo urls.py en su aplicación Django y agregue una plantilla para la vista get_story_from_description:

from django.urls import path
from . import views

urlpatterns = [
# other patterns
path('generate-story/', views.get_story_from_description, name='get_story_from_description'),
]

Pruebas de experiencia unificada

Ahora puede visitar http://your_domain/generate-story/ en su navegador web. Debería ver el formulario definido en story_template.html. Intente enviar una solicitud de texto mediante el campo de entrada de texto o cargar un archivo de audio mediante la entrada de archivos. Una vez enviada, su solicitud procesará la(s) entrada(s), generará una historia y una imagen complementaria, y las mostrará en la página.

Por ejemplo, aquí hay un ejemplo de una historia: “Cuéntame una historia sobre una mascota y un niño que juegan en el jardín”.”

Al completar este paso, habrá creado una aplicación que procesa y responde a la entrada del usuario en diversas formas.

Resultado

En este tutorial, has desarrollado con éxito un bot multifacético con Django, con las capacidades de integración de Whisper para el reconocimiento de voz, GPT-4 para la generación de texto y DALL-E para la generación de imágenes. Tu programa ahora puede comprender y reaccionar a la entrada del usuario en varios formatos.

Para un mayor desarrollo, se recomienda explorar versiones alternativas de los modelos Whisper, GPT y DALL-E, mejorar el diseño UI/UX de su aplicación o ampliar la funcionalidad del bot para incluir funciones interactivas adicionales.