AI-továbbfejlesztett hirdetésgenerálás a MongoDB-hez készült Azure Cosmos DB virtuális mag használatával
Ebben az útmutatóban bemutatjuk, hogyan hozhat létre olyan dinamikus hirdetési tartalmakat, amelyek rezonálnak a közönségével, a személyre szabott AI-asszisztens, a Heelie használatával. A MongoDB-hez készült Azure Cosmos DB virtuális mag használatával kihasználjuk a vektor-hasonlóság keresési funkcióját, hogy szemantikailag elemezzük és egyeztetjük a leltár leírását a hirdetési témakörökkel. A folyamat úgy érhető el, hogy vektorokat hoz létre a leltár leírásához OpenAI-beágyazások használatával, amelyek jelentősen növelik a szemantikai mélységüket. Ezek a vektorok ezután a MongoDB virtuálismag-erőforrás Cosmos DB-ben vannak tárolva és indexelve. A hirdetések tartalmainak létrehozásakor vektorizáljuk a hirdetési témakört, hogy megtaláljuk a legjobban megfelelő leltárelemeket. Ezt egy lekéréses kiterjesztett generációs (RAG) folyamat követi, ahol a rendszer elküldi a legfontosabb találatokat az OpenAI-nak egy lenyűgöző hirdetés létrehozásához. Az alkalmazás teljes kódbázisa elérhető egy GitHub-adattárban a referencia számára.
Funkciók
- Vektor-hasonlóság keresése: Az Azure Cosmos DB-t használja a MongoDB virtuális mag hatékony vektoros hasonlósági kereséséhez a szemantikai keresési képességek javítása érdekében, így könnyebben megtalálhatja a releváns leltárelemeket a hirdetések tartalma alapján.
- OpenAI-beágyazások: Az OpenAI élvonalbeli beágyazásait használja a készletleírások vektorainak létrehozásához. Ez a megközelítés árnyaltabb és szemantikailag gazdagabb egyezéseket tesz lehetővé a leltár és a hirdetés tartalma között.
- Tartalomgenerálás: Az OpenAI fejlett nyelvi modelljeit használja vonzó, trendközpontú hirdetések létrehozásához. Ez a módszer biztosítja, hogy a tartalom ne csak releváns legyen, hanem magával ragadja a célközönséget is.
Előfeltételek
Azure OpenAI: Állítsuk be az Azure OpenAI-erőforrást. A szolgáltatáshoz való hozzáférés jelenleg csak alkalmazásonként érhető el. Az Azure OpenAI-hoz való hozzáférésre a következő https://aka.ms/oai/accessűrlap kitöltésével jelentkezhet: . Ha már rendelkezik hozzáféréssel, hajtsa végre a következő lépéseket:
- A rövid útmutatót követve hozzon létre egy Azure OpenAI-erőforrást.
- Egy és egy
completionsembeddingsmodell üzembe helyezése - Jegyezze fel a végpont, a kulcs és az üzembe helyezés nevét.
Cosmos DB for MongoDB vCore erőforrás: Első lépésként hozzunk létre egy Azure Cosmos DB for MongoDB virtuálismag-erőforrást ingyenesen, ezt a rövid útmutatót követve.
- Jegyezze fel a kapcsolat részleteit (kapcsolati sztring).
Python-környezet (>= 3.9 verzió) olyan csomagokkal, mint
numpya ,openai,pymongo,python-dotenv,azure-core,azure-cosmos,tenacityésgradio.Töltse le az adatfájlt , és mentse egy kijelölt adatmappába.
A szkript futtatása
Mielőtt belemerülnénk az AI által továbbfejlesztett hirdetések létrehozásának izgalmas részébe, létre kell hoznunk a környezetünket. Ez a beállítás magában foglalja a szükséges csomagok telepítését, hogy a szkript zökkenőmentesen fusson. Az alábbiakban egy részletes útmutatót talál, amely mindent előkészít.
1.1 A szükséges csomagok telepítése
Először is telepíteni kell néhány Python-csomagot. Nyissa meg a terminált, és futtassa a következő parancsokat:
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
pip show openai
1.2 Az OpenAI és az Azure-ügyfél beállítása
A szükséges csomagok telepítése után a következő lépés az OpenAI- és Azure-ügyfelek beállítása a szkripthez, ami elengedhetetlen az OpenAI API-ra és az Azure-szolgáltatásokra irányuló kérések hitelesítéséhez.
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
)
Megoldásarchitektúra
2. Beágyazások létrehozása és a Cosmos DB beállítása
A környezet és az OpenAI-ügyfél beállítása után áttérünk az AI által továbbfejlesztett hirdetésgenerálási projekt alapvető részére. Az alábbi kód vektoros beágyazásokat hoz létre a termékek szöveges leírásából, és beállítja adatbázisunkat az Azure Cosmos DB for MongoDB virtuális magban a beágyazások tárolásához és kereséséhez.
2.1 Beágyazások létrehozása
Ahhoz, hogy vonzó hirdetéseket generáljunk, először meg kell értenünk a készlet elemeit. Ezt úgy tesszük, hogy vektoros beágyazásokat hozunk létre az elemek leírásából, ami lehetővé teszi számunkra, hogy a szemantikai jelentésüket olyan formában rögzítsük, amelyet a gépek képesek megérteni és feldolgozni. Az Alábbiakban bemutatjuk, hogyan hozhat létre vektoros beágyazásokat egy elemleíráshoz az Azure OpenAI használatá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
embeddings = generate_embeddings("Shoes for San Francisco summer")
if embeddings is not None:
print(embeddings)
A függvény egy szöveges bemenetet használ – például egy termékleírást –, és az client.embeddings.create OpenAI API metódusával generál egy vektoros beágyazást a szöveghez. Itt a text-embedding-ada-002 modellt használjuk, de a követelményeknek megfelelően más modelleket is választhat. Ha a folyamat sikeres, kinyomtatja a létrehozott beágyazásokat; ellenkező esetben hibaüzenet nyomtatásával kezeli a kivételeket.
3. A Cosmos DB csatlakoztatása és beállítása MongoDB virtuális maghoz
A beágyazások készen állnak, a következő lépés az, hogy tárolja és indexelje őket egy olyan adatbázisban, amely támogatja a vektoros hasonlóság keresését. A MongoDB-hez készült Azure Cosmos DB virtuális mag tökéletes választás ehhez a feladathoz, mivel célja a tranzakciós adatok tárolása és a vektorkeresés végrehajtása egy helyen.
3.1 A kapcsolat beállítása
A Cosmos DB-hez való csatlakozáshoz a pymongo könyvtárat használjuk, amely lehetővé teszi a MongoDB-vel való egyszerű interakciót. Az alábbi kódrészlet kapcsolatot létesít a Cosmos DB for MongoDB virtuális magpéldányával:
import pymongo
# Replace <USERNAME>, <PASSWORD>, and <VCORE_CLUSTER_NAME> with your actual credentials and cluster name
mongo_conn = "mongodb+srv://<USERNAME>:<PASSWORD>@<VCORE_CLUSTER_NAME>.mongocluster.cosmos.azure.com/?tls=true&authMechanism=SCRAM-SHA-256&retrywrites=false&maxIdleTimeMS=120000"
mongo_client = pymongo.MongoClient(mongo_conn)
Cserélje le <USERNAME>a <VCORE_CLUSTER_NAME> mongoDB-felhasználónevet<PASSWORD>, a jelszót és a virtuális magfürt nevét.
4. Az adatbázis- és vektorindex beállítása a Cosmos DB-ben
Miután létrehozott egy kapcsolatot az Azure Cosmos DB-hez, a következő lépések az adatbázis és a gyűjtemény beállítását, majd egy vektorindex létrehozását foglalják magukban a hatékony vektoros hasonlósági keresések lehetővé tétele érdekében. Vizsgáljuk meg ezeket a lépéseket.
4.1 Az adatbázis és a gyűjtemény beállítása
Először létrehozunk egy adatbázist és egy gyűjteményt a Cosmos DB-példányon belül. Ezt a következőképpen teheti meg:
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 DBs shared throughput
db.create_collection(COLLECTION_NAME)
print("Created collection '{}'.\n".format(COLLECTION_NAME))
else:
print("Using collection: '{}'.\n".format(COLLECTION_NAME))
4.2 A vektorindex létrehozása
Ahhoz, hogy hatékony vektor-hasonlósági keresést hajtsunk végre a gyűjteményünkben, létre kell hoznunk egy vektorindexet. A Cosmos DB különböző típusú vektorindexeket támogat, és itt a kettőt tárgyaljuk: az IVF-et és a HNSW-t.
IVF
Az IVF az invertált fájlindexet jelenti, amely az alapértelmezett vektorindexelési algoritmus, amely az összes fürtszinten működik. Ez egy hozzávetőlegesen legközelebbi szomszéd (ANN) megközelítés, amely fürtözést használ az adathalmaz hasonló vektorainak keresésének felgyorsításához. IVF-index létrehozásához használja a következő parancsot:
db.command({
'createIndexes': COLLECTION_NAME,
'indexes': [
{
'name': 'vectorSearchIndex',
'key': {
"contentVector": "cosmosSearch"
},
'cosmosSearchOptions': {
'kind': 'vector-ivf',
'numLists': 1,
'similarity': 'COS',
'dimensions': 1536
}
}
]
});
Fontos
Vektortulajdonságonként csak egy index hozható létre. Vagyis nem hozhat létre több olyan indexet, amely ugyanarra a vektortulajdonságra mutat. 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.
HNSW
A HNSW a Hierarchical Navigable Small World( Hierarchical Navigable Small World) nevű, gráfalapú adatszerkezet, amely fürtökre és alclusterekre particionál vektorokat. A HNSW segítségével nagyobb pontossággal, gyors, közelítő szomszédkeresést hajthat végre nagyobb sebességgel. A HNSW egy hozzávetőleges (ANN) módszer. Az alábbiak szerint állíthatja be:
db.command(
{
"createIndexes": "ExampleCollection",
"indexes": [
{
"name": "VectorSearchIndex",
"key": {
"contentVector": "cosmosSearch"
},
"cosmosSearchOptions": {
"kind": "vector-hnsw",
"m": 16, # default value
"efConstruction": 64, # default value
"similarity": "COS",
"dimensions": 1536
}
}
]
}
)
Feljegyzés
A HNSW-indexelés csak az M40-fürtszinteken és magasabb szinteken érhető el.
5. Adatok beszúrása a gyűjteménybe
Most szúrja be a leltáradatokat, amelyek leírásokat és azok megfelelő vektorbeágyazását tartalmazzák, az újonnan létrehozott gyűjteménybe. Ha adatokat szeretne beszúrni a gyűjteménybe, a insert_many() tár által pymongo biztosított módszert használjuk. A módszer lehetővé teszi, hogy egyszerre több dokumentumot szúrjunk be a gyűjteménybe. Az adatok egy JSON-fájlban vannak tárolva, amelyet betöltünk, majd beszúrunk az adatbázisba.
Töltse le a shoes_with_vectors.json fájlt a GitHub-adattárból, és tárolja a projektmappában lévő data könyvtárban.
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)}")
6. Vektorkeresés a Cosmos DB-ben MongoDB virtuális maghoz
Az adatok sikeres feltöltésével mostantól a vektoros keresés erejét alkalmazva megkereshetjük a lekérdezésen alapuló legrelevánsabb elemeket. A korábban létrehozott vektorindex lehetővé teszi számunkra, hogy szemantikai keresést hajtsunk végre az adathalmazon belül.
6.1 Vektorkeresés végrehajtása
Vektorkeresés végrehajtásához meghatározunk egy függvényt vector_search , amely egy lekérdezést és a visszaadandó találatok számát veszi igénybe. A függvény létrehoz egy vektort a lekérdezéshez a generate_embeddings korábban definiált függvény használatával, majd a Cosmos DB funkciójával $search megkeresi a legközelebbi egyező elemeket a vektorbeágyazások alapján.
# Function to assist with vector search
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
6.2 Vektorkeresési lekérdezés végrehajtása
Végül végrehajtjuk a vektorkeresési függvényt egy adott lekérdezéssel, és feldolgozzuk az eredményeket, hogy megjelenítsük őket:
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")
7. Hirdetéstartalom létrehozása GPT-4 és DALL használatával. E
Az összes kifejlesztett összetevőt kombináljuk lenyűgöző hirdetések készítéséhez, az OpenAI GPT-4-jét használva szöveghez és DALL-hez. E 3 képekhez. A vektorkeresési találatokkal együtt teljes hirdetést alkotnak. Bemutatjuk Heelie-t, az intelligens asszisztensünket is, aki a vonzó hirdetéscímkék létrehozásával foglalkozik. A közelgő kódon keresztül a Heelie működés közben jelenik meg, és továbbfejleszti a hirdetéskészítési folyamatot.
from openai import OpenAI
def generate_ad_title(ad_topic):
system_prompt = '''
You are Heelie, an intelligent assistant for generating witty and cativating tagline for online advertisement.
- 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
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
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
8. Az egészet összehozva
A hirdetésgenerálás interaktívsá tétele érdekében a Gradiot, egy Python-kódtárat használunk egyszerű webes felhasználói felületek létrehozásához. Meghatározunk egy felhasználói felületet, amely lehetővé teszi a felhasználók számára a hirdetési témakörök bevitelét, majd dinamikusan generálja és megjeleníti az eredményül kapott hirdetést.
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()
Hozam
