Cómo integrar modelos de OpenAI GPT en tu proyecto Django

El autor seleccionó el Programa de Socorro Directo para recibir una donación como parte del programa Escribir para Donaciones.

Introducción

Los modelos GPT de OpenAI han ganado popularidad debido a su amplio uso en la generación de contenido de texto para diversas tareas como redacción de correos electrónicos, respuestas a preguntas frecuentes de servicio al cliente y traducción de idiomas, entre otras.

Estos modelos GPT generalmente se utilizan a través de ChatGPT, un chatbot lanzado por OpenAI, o mediante APIs y bibliotecas que proporcionan un mayor control. Este tutorial te guiará sobre cómo aprovechar estos modelos utilizando la API de OpenAI dentro de tu proyecto web Django. Aprenderás cómo llamar a la API de Completado de Chat usando diferentes parámetros y cómo formatear y utilizar sus respuestas.

Al final de este tutorial, habrás creado un punto final de Django que, al ser llamado, envía una solicitud a OpenAI para construir una historia corta utilizando las palabras proporcionadas y devuelve su respuesta.

Prerrequisitos

Para completar este tutorial, necesitarás:

1. Un proyecto Django existente. Si estás empezando desde cero, puedes configurar un proyecto Django siguiendo el tutorial cómo configurar un entorno de desarrollo Django.

2. Una cuenta de OpenAI: Ve al sitio web de la plataforma de OpenAI y busca el botón ‘Registrarse’. Después de registrarte, debes verificar tu dirección de correo electrónico e ingresar información personal.

3. Una clave de API de OpenAI: Una vez que tu cuenta esté configurada, inicia sesión y ve a la sección de Claves de API desde tu panel de control. Haz clic en ‘Crear nueva clave secreta’. Tu clave de API se generará y se verá algo así como sk-abcdefghijklmnop. Asegúrate de guardar esta clave en un lugar seguro, ya que no podrás verla nuevamente.

4. El paquete de Python de OpenAI: Si siguió el tutorial en el primer requisito previo, ya debería tener un entorno virtual llamado env activo dentro de un directorio llamado django-apps. Asegúrese de que su entorno virtual esté activo al confirmar que su nombre aparece entre paréntesis al inicio de su indicador de terminal. Si no está activo, puede activarlo manualmente ejecutando el siguiente comando:

sammy@ubuntu:$ .env/bin/activate

En su terminal desde el directorio django-apps. Una vez que su entorno esté activo, ejecute lo siguiente para instalar el paquete de Python de OpenAI:

(env)sammy@ubuntu:$ pip install openai

Paso 1 — Realizar llamadas a OpenAI

En este paso, agregarás tu clave de API de OpenAI al cliente de OpenAI y realizarás una llamada de API simple a la API de ChatCompletion. También examinarás la respuesta que recibes de la API.

Para comenzar, abre tu intérprete de Python:

(env)sammy@ubuntu:$ python

Primero, importa el cliente de OpenAI y agrega tu clave de API al cliente:

from openai import OpenAI
client = OpenAI(api_key="your-api-key")

Reemplaza "tu-clave-de-api" con la clave de API real que obtuviste de la plataforma de OpenAI.

Ahora, hagamos una llamada de API a la API de ChatCompletion. Utiliza el método chat.completions.create():

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "count 1 to 10"}])

En el código anterior, especificamos el modelo a utilizar como gpt-3.5-turbo, agregamos un único objeto mensaje que contiene el rol usuario (otras opciones son sistema y asistente) y el contenido / indicación contar del 1 al 10.

Para ver la respuesta de la llamada de API, puedes imprimir el mensaje de respuesta, que debería contener los números del 1 al 10 en una pequeña lista agradable:

print(response.choices[0].message.content)

Salida:

Output
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

¡Felicidades! Has realizado con éxito una llamada de API simple a OpenAI y has recuperado una respuesta. Formatearemos y utilizaremos la respuesta de la API para crear una historia corta en los próximos pasos.

Paso 2 — Trabajar con parámetros

Ahora que has realizado con éxito una llamada de API simple al API de ChatCompletion, exploremos cómo trabajar con parámetros para personalizar el comportamiento del modelo. Hay varios parámetros disponibles que te permiten controlar la generación de texto. Echaremos un vistazo a los tres siguientes.

1. Temperatura: El parámetro de temperatura determina qué tan aleatorio es el contenido generado. Un valor de temperatura más alto, como 0.8, dará respuestas más diversas y creativas, mientras que un valor de temperatura más bajo, como 0.1, producirá respuestas más similares. Por ejemplo:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

Intentemos nuevamente temperature=0.1 para ver el texto recién generado:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.1)
print(response.choices[0].message.content)

Output
1. Apple
2. Elephant
3. Sunshine
4. Adventure
5. Serenity

El texto resultó ser el mismo. Ahora, intentemos temperature=0.8 dos veces:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)
cat, apple, guitar, sky, book
response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], temperature=0.8)
print(response.choices[0].message.content)

Output
1. Apple
2. Sunshine
3. Happiness
4. Love
5. Technology

2. Máximo de tokens: Esto te permite limitar la longitud del texto generado. Establecer un valor específico garantiza que la respuesta no exceda un cierto número de tokens. Los tokens son proporcionales al número de palabras en la respuesta. Por ejemplo:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=10)
print(response.choices[0].message.content)

Output
1. Apple
2. Car

Cambiando el valor a 20:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], max_tokens=20)
print(response.choices[0].message.content)

Output
1. Apple
2. Car
3. Music
4. Ocean
5. Love

3. Transmisión: Esto determina si las respuestas deben ser transmitidas o devueltas. Cuando se establece en True, la respuesta de la API se transmitirá, lo que significa que recibirás la salida en fragmentos a medida que se genere. Esto es útil para conversaciones largas o aplicaciones en tiempo real. Para habilitar la transmisión, agrega el parámetro stream con un valor de True a la llamada de API. Por ejemplo:

response = client.chat.completions.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": "mention five words"}], stream=True)
collected_messages = []
for chunk in response:
...   chunk_message = chunk.choices[0].delta.content
...   if chunk_message is not None:
...     collected_messages.append(chunk_message)
print(collected_messages)

Output
['', 'cat', '\n', 'book', '\n', 'computer', '\n', 'sun', '\n', 'water']

En el código anterior, la variable chunk_message contiene el contenido del mensaje en cada fragmento devuelto por la API. Antes de agregar cada uno a la lista collected_messages, verificamos si el fragmento es None, ya que el contenido del último fragmento suele ser None.

Utilizando estos parámetros, puedes personalizar el comportamiento del modelo y controlar las respuestas generadas para que se ajusten mejor a tu aplicación o proyecto. Experimenta con diferentes valores para obtener los resultados deseados.

En el siguiente paso, proporcionaremos algo de contexto al modelo en forma de un indicador de sistema.

Paso 3 — Creación de un indicador de sistema

En este paso, combinaremos toda la información que hemos aprendido y crearemos un indicador de sistema que proporcione contexto al modelo GPT, indicándole su propósito y especificando sus reglas.

Primero, creemos un módulo de Python que contenga una función para manejar esta tarea. Cierra el intérprete y crea un nuevo archivo llamado story_generator.py en el directorio de tu proyecto de Django.

(env)sammy@ubuntu:$ touch ~/my_blog_app/blog/blogsite/story_generator.py

A continuación, puedes agregar la clave de la API de OpenAI a tus variables de entorno para no tener que agregarla directamente al archivo Python:

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

Abre story_generator.py e dentro de él, crea un cliente de OpenAI y define una función llamada generate_story que tome una colección de palabras como entrada:

import os
from openai import OpenAI
client = OpenAI(api_key=os.environ["OPENAI_KEY"])
def generate_story(words):
    # Llamar a la API de OpenAI para generar la historia
    response = get_short_story(words)
    # Formatear y devolver la respuesta
    return format_response(response)

En esta función, llamamos a una función separada, get_short_story, para hacer la llamada a la API de OpenAI para obtener la historia y luego otra función, format_response,, para formatear la respuesta de la API.

Ahora, enfoquémonos en la función get_short_story. Agrega lo siguiente al final de tu archivo story_generator.py:

def get_short_story(words):
    # Construir la indicación del sistema
    system_prompt = f"""You are a short story generator.
    Write a short story using the following words: {words}.
    Do not go beyond one paragraph."""
    # Realizar la llamada a la API
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{
            "role": "user",
            "content": system_prompt
        }],
        temperature=0.8,
        max_tokens=1000
    )

    # Devolver la respuesta de la API
    return response

En esta función, primero configuramos la indicación del sistema, que informa al modelo sobre la tarea que debe realizar y especifica qué tan larga debe ser la historia. Luego pasamos esta indicación del sistema a la API de Completado de Chat y devolvemos su respuesta.

Finalmente, podemos implementar la función format_response. Agrega lo siguiente al final de tu archivo story_generator.py:

def format_response(response):
    # Extraer la historia generada de la respuesta
    story = response.choices[0].message.content
    # Eliminar cualquier texto o formato no deseado
    story = story.strip()
    # Devolver la historia formateada
    return story

Ahora puedes probar estas funciones llamando a la función generate_story, pasando una colección de palabras como argumento e imprimiendo su respuesta. Agrega lo siguiente al final de tu archivo story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

Ahora guarda y sale del archivo. Ejecuta el script para ver la historia generada:

(env) sammy@ubuntu:$ python ~/my_blog_app/blog/blogsite/story_generator.py

Salida:

In a cozy corner of a sunlit room, a fluffy cat named Whiskers lounged lazily next to a towering bookshelf. Amongst the rows of books, a curious computer hummed softly. As the sun streamed through the window, casting a warm glow, Whiskers noticed a small water stain on the shelf. Intrigued, the cat pawed at the book closest to the mark. As if guided by fate, the book opened to reveal a hidden compartment containing a glittering diamond necklace. With the secret now unveiled, Whiskers embarked on an unexpected adventure, where the sun, water, and the power of knowledge merged into a thrilling tale of mystery and discovery.

¡Bastante interesante! Vamos a eliminar la línea con la declaración print ya que llamaremos a la función generate_story desde una vista de Django. Elimina la línea resaltada de tu archivo story_generator.py:

print(generate_story("cat, book, computer, sun, water"))

Siéntete libre de experimentar con la solicitud del sistema y agregar más contexto y reglas para mejorar las historias generadas.

Continúa con el siguiente paso para integrar el módulo story_generator en tu proyecto de Django.

Paso 4 – Integración con una vista del backend:

Debes crear una vista de Django y una ruta de URL para integrar el módulo story_generator en tu proyecto de Django. En la vista, extraerás las palabras esperadas de la solicitud, llamarás a la función generate_story y devolverás la respuesta.

Primero, abre el archivo views.py en el directorio de tu aplicación de Django. Importa los módulos necesarios y agrega una función de vista llamada generate_story_from_words:

from django.http import JsonResponse
from .story_generator import generate_story

def generate_story_from_words(request):
    words = request.GET.get('words') # Extraer las palabras esperadas de la solicitud
    story = generate_story(words) # Llamar a la función generate_story con las palabras extraídas
    return JsonResponse({'story': story}) # Devolver la historia como una respuesta JSON

A continuación, abre el archivo urls.py y agrega un patrón de URL para la vista generate_story_from_words:

urlpatterns = [
    # Otros patrones de URL...
    path('generate-story/', views.generate_story_from_words, name='generate-story'),
]

Ahora, puedes solicitar el endpoint /generate-story/. Por ejemplo, para probar usando curl, puedes hacer una solicitud GET al endpoint con las palabras esperadas como parámetro de consulta. Abre tu terminal y ejecuta el siguiente comando:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words=cat,book,computer,sun,water"

Asegúrate de reemplazar "http://tu_dominio" con el dominio real donde se aloja tu proyecto de Django. Las palabras "gato,libro,computadora,sol,agua" representan las palabras esperadas con las que deseas generar una historia. Puedes cambiarlas por las palabras que prefieras.

Después de ejecutar el comando, deberías ver la respuesta del servidor, que contendrá la historia generada:

(env)sammy@ubuntu:$ curl "http://your_domain/generate-story/?words="cat,book,computer,sun,water"

Salida:

{"story": "Once upon a time, in a cozy little cottage nestled amidst a dense forest, a curious cat named Whiskers sat by the window, basking in the warm rays of the sun. As Whiskers lazily flicked his tail, his eyes caught sight of a dusty book lying on a nearby shelf. Intrigued, he carefully jumped onto the shelf, causing a cascade of books to tumble down, one opening up to reveal a hidden compartment. Inside, Whiskers discovered an ancient computer, its screen flickering to life as he brushed against the power button. Mesmerized by the glowing screen, Whiskers ventured into a world of virtual landscapes, where he roamed freely, chasing digital fish and pausing to admire breathtaking waterfalls. Lost in this newfound adventure, Whiskers discovered the wonders of both the tangible and virtual worlds, realizing that true exploration knows no bounds."}

Conclusión

Después de completar este tutorial, has aprendido cómo integrar modelos de OpenAI GPT en tu proyecto Django usando la API de OpenAI. Has realizado llamadas a la API de Completado de Chat, personalizado el comportamiento del modelo trabajando con parámetros como temperatura y máximo de tokens, y creado un prompt de sistema para proporcionar contexto al modelo. También has integrado el módulo story_generator en tu proyecto Django. Ahora, puedes generar cuentos cortos solicitando el endpoint /generate-story/ con las palabras esperadas como parámetro de consulta.

Para mejorar aún más tu proyecto Django, puedes explorar funcionalidades adicionales de la API de OpenAI y experimentar con diferentes prompts de sistema y parámetros para generar historias únicas y creativas.