Compartir a través de

Tutorial: Generación de anuncios de IA con Azure DocumentDB y Azure OpenAI

En este tutorial, creará un generador de anuncios con tecnología de inteligencia artificial mediante Azure DocumentDB y OpenAI para crear contenido publicitario dinámico y personalizado. La aplicación utiliza la búsqueda de similitud vectorial para hacer coincidir elementos de inventario con temas de anuncios. Luego, emplea GPT-4 y DALL-E 3 para generar textos publicitarios atractivos e imágenes a través de un asistente de IA llamado Heelie.

La aplicación funciona mediante la generación de incrustaciones de vectores para descripciones de inventario mediante incrustaciones de OpenAI, que capturan el significado semántico de las descripciones del producto. Estos vectores se almacenan e indexan en Azure DocumentDB, lo que permite búsquedas eficaces de similitud de vectores. Cuando necesite generar un anuncio, la aplicación vectoriza el anuncio sujeto para encontrar los elementos de inventario más coincidentes a través de la búsqueda de vectores. A continuación, utiliza un proceso de generación aumentada de recuperación (RAG) para enviar las mejores coincidencias a OpenAI, que crea contenido publicitario atractivo, incluidos slogans pegajosos e imágenes realistas.

En este tutorial, usted hará lo siguiente:

  • Configuración del entorno de Python con paquetes necesarios
  • Configuración de clientes de Azure OpenAI y Azure DocumentDB
  • Creación de incrustaciones de vectores a partir de descripciones de productos
  • Configuración de una base de datos de Azure DocumentDB con indexación de vectores
  • Implementación de la búsqueda de similitud vectorial para buscar productos relevantes
  • Generación de contenido de anuncios mediante GPT-4 y DALL-E 3
  • Creación de una interfaz web interactiva con Gradio

Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

Prerrequisitos

  • Una suscripción de Azure

  • Un clúster de Azure DocumentDB existente

Obtención de datos de ejemplo

En este tutorial, trabajará con un conjunto de datos de productos de calzado que incluye descripciones de producto e incrustaciones de vector precomputadas. Los datos de ejemplo contienen información de inventario que la aplicación usa para mostrar la búsqueda de similitud vectorial y la generación de anuncios.

  1. Descargue el archivo de datos de ejemplo del repositorio de GitHub:

    curl -o data/shoes_with_vectors.json https://raw.githubusercontent.com/jayanta-mondal/ignite-demo/main/data/shoes_with_vectors.json

  2. Cree una data carpeta en el directorio del proyecto y guarde el shoes_with_vectors.json archivo dentro de él. El archivo contiene información del producto, incluidos nombres, descripciones, precios e incrustaciones vectoriales que habilitan la funcionalidad de búsqueda semántica.

Configuración del entorno de Python

Configure el entorno de Python con los paquetes necesarios y configure los clientes de Azure para autenticar las solicitudes en la API de OpenAI y los servicios de Azure.

  1. Abra el terminal e instale los paquetes de Python necesarios:

    pip install numpy
pip install openai==1.2.3
pip install pymongo
pip install python-dotenv
pip install azure-core
pip install azure-cosmos
pip install tenacity
pip install gradio

  2. Compruebe la instalación del paquete openAI:

    pip show openai

  3. Cree un nuevo archivo de Python para el proyecto (por ejemplo, ad_generator.py).

  4. Agregue el código siguiente para importar las bibliotecas necesarias y configurar el cliente de Azure OpenAI:

    import json
import time
import openai

from dotenv import dotenv_values
from openai import AzureOpenAI

# Configure the API to use Azure as the provider
openai.api_type = "azure"
openai.api_key = "<AZURE_OPENAI_API_KEY>"  # Replace with your actual Azure OpenAI API key
openai.api_base = "https://<OPENAI_ACCOUNT_NAME>.openai.azure.com/"  # Replace with your OpenAI account name
openai.api_version = "2023-06-01-preview"

# Initialize the AzureOpenAI client with your API key, version, and endpoint
client = AzureOpenAI(
    api_key=openai.api_key,
    api_version=openai.api_version,
    azure_endpoint=openai.api_base
)

  5. Reemplace los valores de marcador de posición por las credenciales reales de Azure OpenAI:

    • <AZURE_OPENAI_API_KEY>: la clave de API de Azure OpenAI a partir de los requisitos previos
    • <OPENAI_ACCOUNT_NAME>: nombre de la cuenta de Azure OpenAI

Creación de incrustaciones de vectores

Cree incrustaciones de vectores a partir de descripciones de producto para capturar su significado semántico en una forma que las máquinas puedan comprender y procesar. En el diagrama siguiente se muestra la arquitectura de la solución:

Captura de pantalla de la arquitectura de la solución que muestra la integración de búsqueda vectorial de Azure DocumentDB con OpenAI para la generación de anuncios.

  1. Cree incrustaciones de vectores mediante Azure OpenAI mediante la adición de la siguiente función al archivo de Python:

    import openai

def generate_embeddings(text):
    try:
        response = client.embeddings.create(
            input=text, model="text-embedding-ada-002")
        embeddings = response.data[0].embedding
        return embeddings
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

    Esta función toma una entrada de texto y usa el client.embeddings.create método para generar una inserción de vectores. El text-embedding-ada-002 modelo convierte el texto en un vector de alta dimensión que captura el significado semántico.

  2. Pruebe la función de embeddings con una descripción de producto como ejemplo.

    embeddings = generate_embeddings("Shoes for San Francisco summer")

if embeddings is not None:
    print(embeddings)

    Si se ejecuta correctamente, la función imprime las inserciones generadas; De lo contrario, controla las excepciones imprimiendo un mensaje de error.

Conexión a Azure DocumentDB

Establezca una conexión a Azure DocumentDB para almacenar e indexar las incrustaciones en una base de datos que admita la búsqueda de similitud vectorial.

  1. Agregue el código siguiente para establecer una conexión con el clúster de Azure DocumentDB:

    import pymongo

# Replace <username>, <password>, and <cluster-name> with your actual credentials
mongo_conn = "mongodb+srv://<username>:<password>@<cluster-name>.mongocluster.cosmos.azure.com/?tls=true&authMechanism=SCRAM-SHA-256&retrywrites=false&maxIdleTimeMS=120000"
mongo_client = pymongo.MongoClient(mongo_conn)

  2. Reemplace los valores de marcador de posición por las credenciales reales de MongoDB de los requisitos previos:

    • <username>: nombre de usuario de MongoDB
    • <password>: contraseña de MongoDB
    • <cluster-name>: el nombre del clúster vCore

Creación de una base de datos y una colección

Almacene los datos de anuncios y el inventario de productos mediante la creación de una base de datos y una colección dentro de la instancia de Azure DocumentDB.

  1. Agregue el código siguiente para crear una base de datos y una colección:

    DATABASE_NAME = "AdgenDatabase"
COLLECTION_NAME = "AdgenCollection"

mongo_client.drop_database(DATABASE_NAME)
db = mongo_client[DATABASE_NAME]
collection = db[COLLECTION_NAME]

if COLLECTION_NAME not in db.list_collection_names():
    # Creates a unsharded collection that uses the database's shared throughput
    db.create_collection(COLLECTION_NAME)
    print("Created collection '{}'.\n".format(COLLECTION_NAME))
else:
    print("Using collection: '{}'.\n".format(COLLECTION_NAME))

  2. Este código define los nombres de base de datos y colecciones, quita cualquier base de datos existente con el mismo nombre para una configuración limpia, crea una nueva base de datos y una colección e imprime mensajes de confirmación.

Crear un índice vectorial

Cree un índice vectorial para habilitar búsquedas eficaces de similitud de vectores dentro de la colección. Azure DocumentDB admite diferentes tipos de índices vectoriales: Índice de archivos invertidos (IVF) y Mundo pequeño navegable jerárquico (HNSW).

  1. Elija el algoritmo de indexación en función del nivel de clúster:

    • IVF: Algoritmo predeterminado que funciona en todos los niveles de clúster, utiliza un enfoque de parientes más cercanos (ANN) aproximados
    • HNSW: estructura basada en grafos, más rápida con mayor precisión, solo disponible en los niveles de clúster M40 y superiores

  2. Para crear un índice IVF, ejecute el siguiente comando:

    db.runCommand({
  'createIndexes': 'AdgenCollection',
  'indexes': [
    {
      'name': 'vectorSearchIndex',
      'key': {
        "contentVector": "cosmosSearch"
      },
      'cosmosSearchOptions': {
        'kind': 'vector-ivf',
        'numLists': 1,
        'similarity': 'COS',
        'dimensions': 1536
      }
    }
  ]
});

  3. (Opcional) Si usa un nivel de clúster M40 o superior, puede crear un índice HNSW como alternativa.

    db.runCommand({
    "createIndexes": "AdgenCollection",
    "indexes": [
        {
            "name": "VectorSearchIndex",
            "key": {
                "contentVector": "cosmosSearch"
            },
            "cosmosSearchOptions": { 
                "kind": "vector-hnsw", 
                "m": 16,
                "efConstruction": 64,
                "similarity": "COS", 
                "dimensions": 1536
            } 
        } 
    ]
})

Importante

Solo puede crear un índice por propiedad vectorial. Si desea cambiar el tipo de índice (por ejemplo, de IVF a HNSW), primero debe quitar el índice antes de crear un nuevo índice.

Carga de datos de inventario

Inserte los datos de inventario, que incluyen descripciones del producto y sus incrustaciones vectoriales correspondientes, en la colección.

  1. Agregue el código siguiente para cargar e insertar los datos en la colección:

    data_file = open(file="./data/shoes_with_vectors.json", mode="r") 
data = json.load(data_file)
data_file.close()

result = collection.insert_many(data)

print(f"Number of data points added: {len(result.inserted_ids)}")

  2. Este código abre el archivo JSON, carga los datos, inserta todos los documentos en la colección mediante insert_many()e imprime el número de documentos agregados.

Use la búsqueda vectorial para buscar los elementos más relevantes en función de una consulta. El índice de vector que creó permite búsquedas semánticas dentro del conjunto de datos.

  1. Agregue la siguiente función para realizar búsquedas de similitud vectorial:

    def vector_search(query, num_results=3):

    query_vector = generate_embeddings(query)

    embeddings_list = []
    pipeline = [
        {
            '$search': {
                "cosmosSearch": {
                    "vector": query_vector,
                    "numLists": 1,
                    "path": "contentVector",
                    "k": num_results
                },
                "returnStoredSource": True }},
        {'$project': { 'similarityScore': { '$meta': 'searchScore' }, 'document' : '$$ROOT' } }
    ]
    results = collection.aggregate(pipeline)
    return results

    Esta función genera una inserción de vectores para la consulta de búsqueda, crea una canalización de agregación que usa la funcionalidad de $search Azure DocumentDB, busca los elementos coincidentes más cercanos en función de la similitud de vectores y devuelve resultados con puntuaciones de similitud.

  2. Pruebe la función de búsqueda vectorial con una consulta de ejemplo:

    query = "Shoes for Seattle sweater weather"
results = vector_search(query, 3)

print("\nResults:\n")
for result in results: 
    print(f"Similarity Score: {result['similarityScore']}")  
    print(f"Title: {result['document']['name']}")  
    print(f"Price: {result['document']['price']}")  
    print(f"Material: {result['document']['material']}") 
    print(f"Image: {result['document']['img_url']}") 
    print(f"Purchase: {result['document']['purchase_url']}\n")

    Este código ejecuta una búsqueda vectorial y muestra los tres primeros productos coincidentes con sus puntuaciones de similitud y detalles.

Generación de contenido de anuncio

Combine todos los componentes para crear anuncios atractivos mediante GPT-4 de OpenAI para texto y DALL-E 3 para imágenes.

  1. Agregue la siguiente función para generar títulos de anuncios catchy mediante GPT-4:

    from openai import OpenAI

def generate_ad_title(ad_topic):
    system_prompt = '''
    You are Heelie, an intelligent assistant for generating witty and captivating taglines for online advertisements.
        - The ad campaign taglines that you generate are short and typically under 100 characters.
    '''

    user_prompt = f'''Generate a catchy, witty, and short sentence (less than 100 characters) 
                    for an advertisement for selling shoes for {ad_topic}'''
    messages=[
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_prompt},
    ]

    response = client.chat.completions.create(
        model="gpt-4",
        messages=messages
    )

    return response.choices[0].message.content

  2. Agregue la siguiente función para generar imágenes de anuncios mediante DALL-E 3:

    def generate_ad_image(ad_topic):
    daliClient = OpenAI(
        api_key="<DALI_API_KEY>"
    )

    image_prompt = f'''
        Generate a photorealistic image of an ad campaign for selling {ad_topic}. 
        The image should be clean, with the item being sold in the foreground with an easily identifiable landmark of the city in the background.
        The image should also try to depict the weather of the location for the time of the year mentioned.
        The image should not have any generated text overlay.
    '''

    response = daliClient.images.generate(
        model="dall-e-3",
        prompt= image_prompt,
        size="1024x1024",
        quality="standard",
        n=1,
        )

    return response.data[0].url

  3. Reemplace por <DALI_API_KEY> la clave de API de OpenAI.

  4. Agregue la siguiente función para combinar todos los elementos en un anuncio HTML completo:

    def render_html_page(ad_topic):

    # Find the matching shoes from the inventory
    results = vector_search(ad_topic, 4)

    ad_header = generate_ad_title(ad_topic)
    ad_image_url = generate_ad_image(ad_topic)


    with open('./data/ad-start.html', 'r', encoding='utf-8') as html_file:
        html_content = html_file.read()

    html_content += f'''<header>
            <h1>{ad_header}</h1>
        </header>'''    

    html_content += f'''
            <section class="ad">
            <img src="{ad_image_url}" alt="Base Ad Image" class="ad-image">
        </section>'''

    for result in results: 
        html_content += f''' 
        <section class="product">
            <img src="{result['document']['img_url']}" alt="{result['document']['name']}" class="product-image">
            <div class="product-details">
                <h3 class="product-title" color="gray">{result['document']['name']}</h2>
                <p class="product-price">{"$"+str(result['document']['price'])}</p>
                <p class="product-description">{result['document']['description']}</p>
                <a href="{result['document']['purchase_url']}" class="buy-now-button">Buy Now</a>
            </div>
        </section>
        '''

    html_content += '''</article>
                    </body>
                    </html>'''

    return html_content

    Esta función realiza una búsqueda vectorial para buscar productos coincidentes, genera un título de anuncio mediante GPT-4, genera una imagen de anuncio con DALL-E 3 y combina todo en una página HTML con listados de productos.

Creación de una interfaz interactiva

Cree una interfaz web interactiva que permita a los usuarios introducir temas de anuncios y generar y mostrar dinámicamente los anuncios resultantes.

  1. Agregue el código siguiente para crear la interfaz web:

    import gradio as gr

css = """
    button { background-color: purple; color: red; }
    <style>
    </style>
"""

with gr.Blocks(css=css, theme=gr.themes.Default(spacing_size=gr.themes.sizes.spacing_sm, radius_size="none")) as demo:
    subject = gr.Textbox(placeholder="Ad Keywords", label="Prompt for Heelie!!")
    btn = gr.Button("Generate Ad")
    output_html = gr.HTML(label="Generated Ad HTML")

    btn.click(render_html_page, [subject], output_html)

    btn = gr.Button("Copy HTML")

if __name__ == "__main__":
    demo.launch()

  2. Guarde el archivo de Python (por ejemplo, ad_generator.py).

  3. Ejecute la aplicación desde el terminal:

    python ad_generator.py

  4. Abra el explorador web y vaya a la dirección URL que se muestra en el terminal (normalmente http://localhost:7860).

  5. Escriba las palabras clave del anuncio y seleccione Generar anuncio para ver el anuncio generado por IA.

  6. Observe el anuncio generado. El anuncio generado combina resultados de búsqueda vectorial con contenido generado por IA para crear un anuncio atractivo y personalizado. La aplicación crea varias cosas para usted. En primer lugar, crea un eslogan llamativo usando IA. A continuación, crea una imagen de anuncio realista con DALL-E 3. También encuentra productos que coinciden con el asunto mediante la búsqueda de vectores. Por último, muestra detalles completos del producto con imágenes, descripciones y vínculos para comprarlos.

    Captura de pantalla de un resultado de anuncio generado por ejemplo.

Limpieza de recursos

Si ha creado recursos específicamente para este tutorial y ya no los necesita, elimínelos para evitar incurrir en cargos.

  1. Para eliminar la base de datos de Azure DocumentDB, vaya al recurso de Azure DocumentDB en Azure Portal, seleccione Explorador de datos, haga clic con el AdgenDatabasebotón derecho en y seleccione Eliminar base de datos.

  2. (Opcional) Elimine las implementaciones de Azure OpenAI; para ello, vaya al recurso de Azure OpenAI en Azure Portal, seleccione Implementaciones de modelos y elimine las implementaciones GPT-4 y text-embeding-ada-002 si las creó solo para este tutorial.

  3. (Opcional) Si creó un grupo de recursos dedicado para este tutorial, elimine todo el grupo de recursos para quitar todos los recursos asociados.

Contenido relacionado

  • Last updated on