Megosztás a következőn keresztül:

Oktatóanyag: AI-hirdetések létrehozása az Azure DocumentDB és az Azure OpenAI használatával

Ebben az oktatóanyagban egy AI-alapú hirdetésgenerátort hoz létre az Azure DocumentDB és az OpenAI használatával dinamikus, személyre szabott hirdetési tartalmak létrehozásához. Az alkalmazás vektoros hasonlósági keresést használ a leltárelemek és a hirdetés tárgyainak egyeztetéséhez, majd a GPT-4 és a DALL-E 3 használatával lenyűgöző hirdetésmásolatokat és képeket hoz létre egy Heelie nevű AI-asszisztensen keresztül.

Az alkalmazás úgy működik, hogy vektoros beágyazásokat hoz létre a készletleírásokhoz OpenAI-beágyazások használatával, amelyek rögzítik a termékleírások szemantikai jelentését. Ezeket a vektorokat az Azure DocumentDB tárolja és indexeli, így hatékony vektor-hasonlósági kereséseket tesz lehetővé. Amikor létre kell hoznia egy hirdetést, az alkalmazás vektorizálja a hirdetés tárgyát, hogy a vektorkereséssel megkeresse a legjobban megfelelő leltárelemeket. Ezt követően egy lekéréses-bővített generációs (RAG) eljárással küldi el a legfontosabb találatokat az OpenAI-nak, amely lenyűgöző reklámtartalmakat készít, beleértve a fülbemászó címkevonalakat és a valósághű képeket.

Ebben az útmutatóban Ön:

  • Python-környezet beállítása szükséges csomagokkal
  • Azure OpenAI- és Azure DocumentDB-ügyfelek konfigurálása
  • Vektoros beágyazások létrehozása termékleírásokból
  • Azure DocumentDB-adatbázis beállítása vektorindexeléssel
  • Vektoros hasonlósági keresés implementálása releváns termékek megkereséséhez
  • Hirdetéstartalom létrehozása a GPT-4 és DALL-E 3 használatával
  • Interaktív webes felület létrehozása a Gradioval

Ha nincs Azure-előfizetésed, hozz létre egy ingyenes fiókot mielőtt elkezdenéd.

Előfeltételek

  • Azure-előfizetés

  • Meglévő Azure DocumentDB-fürt

Mintaadatok lekérése

Ebben az oktatóanyagban egy olyan cipőtermékekből álló adatkészlettel dolgozik, amely termékleírásokat és előre konfigurált vektoros beágyazásokat tartalmaz. A mintaadatok készletinformációkat tartalmaznak, amelyeket az alkalmazás a vektorok hasonlósági keresésének és hirdetésgenerálásának bemutatására használ.

  1. Töltse le a mintaadatfájlt a GitHub-adattárból:

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

  2. Hozzon létre egy data mappát a projektkönyvtárban, és mentse a shoes_with_vectors.json fájlt benne. A fájl termékinformációkat tartalmaz, beleértve a neveket, leírásokat, árakat és vektoros beágyazásokat, amelyek lehetővé teszik a szemantikai keresési funkciókat.

A Python-környezet beállítása

Állítsa be a Python-környezetet a szükséges csomagokkal, és konfigurálja az Azure-ügyfeleket az OpenAI API-ra és az Azure-szolgáltatásokra irányuló kérelmek hitelesítésére.

  1. Nyissa meg a terminált, és telepítse a szükséges Python-csomagokat:

    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. Ellenőrizze az OpenAI-csomag telepítését:

    pip show openai

  3. Hozzon létre egy új Python-fájlt a projekthez (például ad_generator.py).

  4. Adja hozzá a következő kódot a szükséges kódtárak importálásához és az Azure OpenAI-ügyfél konfigurálásához:

    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. Cserélje le a helyőrző értékeket a tényleges Azure OpenAI-hitelesítő adatokra:

    • <AZURE_OPENAI_API_KEY>: Az Azure OpenAI API-kulcs az előfeltételekből
    • <OPENAI_ACCOUNT_NAME>: Az Azure OpenAI-fiók neve

Vektoros beágyazások létrehozása

Vektorbeágyazások létrehozása a termékleírásokból a szemantikai jelentésük olyan formában való rögzítéséhez, amelyet a gépek képesek megérteni és feldolgozni. Az alábbi ábra a megoldásarchitektúrát szemlélteti:

Képernyőkép a megoldásarchitektúráról, amelyen az Azure DocumentDB vektorkeresési integrációja látható az OpenAI-val a hirdetésgeneráláshoz.

  1. Vektoros beágyazások létrehozása az Azure OpenAI használatával az alábbi függvény Python-fájlhoz való hozzáadásával:

    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

    Ez a függvény egy szöveges bemenetet használ, és a client.embeddings.create metódus használatával generál egy vektoros beágyazást. A text-embedding-ada-002 modell a szöveget egy magas dimenziójú vektorsá alakítja, amely szemantikai jelentést rögzít.

  2. Tesztelje a beágyazási függvényt egy minta termékleírással:

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

if embeddings is not None:
    print(embeddings)

    Ha sikeres, a függvény kinyomtatja a létrehozott beágyazásokat; ellenkező esetben hibaüzenet nyomtatásával kezeli a kivételeket.

Csatlakozás az Azure DocumentDB-hez

Hozzon létre egy kapcsolatot az Azure DocumentDB-vel a beágyazások tárolásához és indexeléséhez egy olyan adatbázisban, amely támogatja a vektoros hasonlóság keresését.

  1. Adja hozzá a következő kódot az Azure DocumentDB-fürttel való kapcsolat létrehozásához:

    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. Cserélje le a helyőrző értékeket az előfeltételekből származó tényleges MongoDB-hitelesítő adatokra:

    • <username>: Az Ön MongoDB-felhasználóneve
    • <password>: MongoDB-jelszava
    • <cluster-name>: A virtuális magfürt neve

Adatbázis és gyűjtemény létrehozása

A hirdetési adatok és a termékleltár tárolásához hozzon létre egy adatbázist és gyűjteményt az Azure DocumentDB-példányban.

  1. Adja hozzá a következő kódot egy adatbázis és gyűjtemény létrehozásához:

    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. Ez a kód definiálja az adatbázis- és gyűjteményneveket, elveti az azonos nevű meglévő adatbázisokat egy tiszta beállításhoz, létrehoz egy új adatbázist és gyűjteményt, és visszaigazoló üzeneteket nyomtat ki.

Vektorindex létrehozása

Hozzon létre egy vektorindexet a gyűjtemény hatékony vektor-hasonlósági kereséseinek engedélyezéséhez. Az Azure DocumentDB különböző típusú vektorindexeket támogat: invertált fájlindexet (IVF) és hierarchikus navigálható kisvilágot (HNSW).

  1. Válassza ki az indexelési algoritmust a fürtszint alapján:

    • IVF: Az összes fürtszinten működő alapértelmezett algoritmus a legközelebbi szomszédok (ANN) megközelítését használja
    • HNSW: Gráfalapú struktúra, gyorsabb, nagyobb pontossággal, csak M40-fürtszinteken és magasabb szinten érhető el

  2. IVF-index létrehozásához futtassa a következő parancsot:

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

  3. (Nem kötelező) Ha M40 klaszterszintet vagy annál magasabb szintet használ, létrehozhat helyette egy HNSW-indexet:

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

Fontos

Vektortulajdonságonként csak egy index hozható létre. Ha módosítani szeretné az index típusát (például IVF-ről HNSW-ra), először el kell vetnie az indexet, mielőtt létrehozna egy új indexet.

Leltáradatok betöltése

Szúrja be a készletadatokat, amelyek termékleírásokat és azok megfelelő vektorbeágyazását tartalmazzák, a gyűjteménybe.

  1. Adja hozzá az alábbi kódot az adatok betöltéséhez és a gyűjteménybe való beszúrásához:

    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. Ez a kód megnyitja a JSON-fájlt, betölti az adatokat, beszúrja az összes dokumentumot a gyűjteménybe a használatával insert_many(), és kinyomtatja a hozzáadott dokumentumok számát.

A vektoros kereséssel megkeresheti a lekérdezésen alapuló legrelevánsabb elemeket. A létrehozott vektorindex lehetővé teszi a szemantikai keresést az adathalmazon belül.

  1. Adja hozzá a következő függvényt a vektoros hasonlósági keresésekhez:

    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

    Ez a függvény létrehoz egy vektor beágyazást a keresési lekérdezéshez, létrehoz egy összesítő folyamatot, amely az Azure DocumentDB $search funkcióit használja, megkeresi a legközelebbi egyező elemeket a vektorok hasonlósága alapján, és hasonlósági pontszámokkal adja vissza az eredményeket.

  2. A vektorkeresési függvény tesztelése minta lekérdezéssel:

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

    Ez a kód egy vektorkeresést hajt végre, és megjeleníti az első három egyező terméket a hasonlósági pontszámokkal és részletekkel.

Reklámtartalom létrehozása

Az összes eszközt kombinálva megalkothat látványos hirdetéseket az OpenAI GPT-4 használva szövegekhez és a DALL-E 3-at a képekhez.

  1. Adja hozzá a következő függvényt, hogy a GPT-4 használatával hozzon létre figyelemfelkeltő hirdetési címeket:

    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. Adja hozzá a következő függvényt a hirdetési képek létrehozásához a DALL-E 3 használatával:

    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. Cserélje le <DALI_API_KEY> az OpenAI API-kulcsot.

  4. Adja hozzá a következő függvényt, hogy az összes elemet egy teljes HTML-hirdetésbe egyesítse:

    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

    Ez a függvény vektorkeresést hajt végre az egyező termékek megkereséséhez, a GPT-4 használatával létrehoz egy hirdetéscímet, létrehoz egy hirdetésképet a DALL-E 3 használatával, és mindent egy HTML-lapba egyesít terméklistával.

Interaktív felület létrehozása

Hozzon létre egy interaktív webes felületet, amellyel a felhasználók beírhatják a hirdetés tárgyait, és dinamikusan generálhatják és megjeleníthetik az eredményül kapott hirdetéseket.

  1. Adja hozzá a következő kódot a webes felület létrehozásához:

    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. Mentsd a Python fájlt (például ad_generator.py).

  3. Futtassa az alkalmazást a terminálról:

    python ad_generator.py

  4. Nyissa meg a webböngészőt, és keresse meg a terminálban (általában) megjelenő URL-címet http://localhost:7860.

  5. Adja meg a hirdetési kulcsszavakat, és válassza az Ad létrehozása lehetőséget az AI által létrehozott hirdetés megtekintéséhez.

  6. Figyelje meg a létrehozott hirdetést. A létrehozott hirdetés a vektorkeresési eredményeket az AI által létrehozott tartalommal kombinálva lenyűgöző, személyre szabott hirdetést hoz létre. Az alkalmazás több dolgot is létrehoz Önnek. Először is egy fülbemászó címkét hoz létre a mesterséges intelligencia használatával. Ezután egy valósághű hirdetésképet hoz létre a DALL-E 3 használatával. A vektoros kereséssel megkeresi a tárgynak megfelelő termékeket is. Végül teljes termékadatokat jelenít meg képekkel, leírásokkal és a vásárlásukra mutató hivatkozásokkal.

    Képernyőkép egy példa által generált hirdetés eredményéről.

Erőforrások tisztítása

Ha kifejezetten ehhez az oktatóanyaghoz hozott létre erőforrásokat, és már nincs rájuk szüksége, törölje őket a költségek elkerülése érdekében.

  1. Az Azure DocumentDB-adatbázis törléséhez navigáljon az Azure DocumentDB-erőforrásra az Azure Portalon, válassza az Adatkezelőt, kattintson a jobb gombbal az adatbázisra, és válassza az AdgenDatabaseAdatbázis törlése parancsot.

  2. (Nem kötelező) Törölje az Azure OpenAI-telepítéseket úgy, hogy az Azure Portalon navigál az Azure OpenAI-erőforrásra, kiválasztja a modelltelepítéseket, és törli a GPT-4 és a text-embedding-ada-002 példányokat, ha csak ehhez az oktatóanyaghoz hozta létre őket.

  3. (Nem kötelező) Ha dedikált erőforráscsoportot hozott létre ehhez az oktatóanyaghoz, törölje a teljes erőforráscsoportot az összes társított erőforrás eltávolításához.

Kapcsolódó tartalom

  • Last updated on