Revolucionirajući lov na čudovišta: D&D susreti poboljšani umjetnom inteligencijom

Armija tame sa AI pogonom

Noć je igre, vaši prijatelji su smješteni oko stola za igre i čekaju da vide kakav će lik Dungeons & Dragons (D&D) postati i zadatak u koji će krenuti. Večeras ste Dungeon Master (pripovjedač i vodič), stvaralac uzbudljivih susreta kako biste izazvali i očarali svoje igrače. Vaš pouzdan D&D Monster priručnik sadrži hiljade stvorenja. Pronalaženje savršenog čudovišta za svaku situaciju među bezbroj opcija može biti neodoljivo. Idealan neprijatelj treba da odgovara ambijentu, težini i narativu trenutka.

Šta ako bismo mogli stvoriti alat koji trenutno pronalazi čudovište najprikladnije za svaki scenarij? Alat koji istovremeno razmatra više faktora , osiguravajući da svaki susret bude što impresivniji i uzbudljiviji?

Krenimo u sopstvenu potragu: izgradimo vrhunski sistem za pronalaženje čudovišta, koristeći moć vektorske pretrage sa više atributa!

Stvaranje stvorenja pomoću vektorske pretrage, zašto to raditi?

Vektorsko pretraživanje predstavlja revoluciju u pronalaženju informacija. Vektorsko ugrađivanje – uzimajući u obzir kontekst i semantičko značenje – omogućava pretragu vektora da vrati relevantnije i preciznije rezultate, rukuje ne samo strukturiranim već i nestrukturiranim podacima i više jezika, te mjeri. Ali da bismo generirali visokokvalitetne odgovore u aplikacijama iz stvarnog svijeta, često moramo dodijeliti različite težine specifičnim atributima naših objekata podataka.

Postoje dva uobičajena pristupa pretrazi vektora sa više atributa. Oba počinju odvojenim ugrađivanjem svakog atributa objekta podataka. Glavna razlika između ova dva pristupa je u načinu na koji se naši embeddingi pohranjuju i pretražuju .

1. naivni pristup - pohraniti svaki vektor atributa u odvojena spremišta vektora (jedan po atributu), izvršiti zasebno pretraživanje za svaki atribut, kombinirati rezultate pretraživanja i naknadno obraditi (npr. težinu) prema potrebi.
2. Superlinked pristup - spojite i pohranite sve vektore atributa u isto skladište vektora (koristeći ugrađenu funkcionalnost Superlinked-a), što nam omogućava da pretražujemo samo jednom , uz prateće povećanje efikasnosti. Superlinkedovi spaces nam takođe omogućavaju da težimo svakom atributu u vreme upita da bismo prikazali relevantnije rezultate, bez naknadne obrade.

U nastavku ćemo koristiti ova dva pristupa za implementaciju alata za pretraživanje vektora s više atributa - Dungeons and Dragons nalaz čudovišta! Naše jednostavne implementacije, posebno druga, ilustrovaće kako da kreirate moćnije i fleksibilnije sisteme za pretragu, one koji mogu sa lakoćom da obrađuju složene, višestruke upite, bez obzira na vaš slučaj upotrebe.

Ako ste novi u pretraživanju vektorske sličnosti, ne brinite! Pokrili smo vas - pogledajte naše članke o građevnim blokovima .

Ok, idemo u lov na čudovišta!

Skup podataka

Prvo ćemo generirati mali sintetički skup podataka o čudovištima, pozivanjem na model velikog jezika (LLM):

 Generate two JSON lists: 'monsters' and 'queries'. 1. 'monsters' list: Create 20 unique monsters with the following properties: - name: A distinctive name - look: Brief description of appearance (2-3 sentences) - habitat: Where the monster lives (2-3 sentences) - behavior: How the monster acts (2-3 sentences) Ensure some monsters share similar features while remaining distinct. 2. 'queries' list: Create 5 queries to search for monsters: - Each query should be in the format: {look: "...", habitat: "...", behavior: "..."} - Use simple, brief descriptions (1-3 words per field) - Make queries somewhat general to match multiple monsters Output format: { "monsters": [ {"name": "...", "look": "...", "habitat": "...", "behavior": "..."}, ... ], "queries": [ {"look": "...", "habitat": "...", "behavior": "..."}, ... ] }

Pogledajmo uzorak skupa podataka koji je generirao naš LLM. Napomena: LLM generacija nije deterministička, tako da se vaši rezultati mogu razlikovati.

Evo naših prvih pet čudovišta:

...i naši generirani upiti:

Pogledajte originalni skup podataka i primjere upita ovdje .

Retrieval

Postavimo parametre koje ćemo koristiti u oba naša pristupa - naivnom i superlinkovanom - u nastavku.

Mi generišemo naše vektorske ugradnje sa:

 sentence-transformers/all-mpnet-base-v2.

Radi jednostavnosti, ograničit ćemo naše rezultate na 3 najbolja meča. (Za kompletan kod, uključujući neophodne uvoze i pomoćne funkcije, pogledajte bilježnicu .)

 LIMIT = 3 MODEL_NAME = "sentence-transformers/all-mpnet-base-v2"

A sada, krenimo u potragu za čudovištima s više atributa! Prvo ćemo isprobati naivni pristup.

Naivan pristup

U našem naivnom pristupu, atribute ugrađujemo nezavisno i spremamo ih u različite indekse. U vrijeme upita pokrećemo višestruka kNN-pretraga na svim indeksima, a zatim kombiniramo sve naše djelomične rezultate u jedan.

Počinjemo od definiranja klase

 NaiveRetriever

da izvršimo pretragu zasnovanu na sličnosti na našem skupu podataka, koristeći naše ugradnje generisane all-mpnet-base-v2 .

 class NaiveRetriever: def __init__(self, data: pd.DataFrame): self.model = SentenceTransformer(MODEL_NAME) self.data = data.copy() self.ids = self.data.index.to_list() self.knns = {} for key in self.data: embeddings = self.model.encode(self.data[key].values) knn = NearestNeighbors(metric="cosine").fit(embeddings) self.knns[key] = knn def search_key(self, key: str, value: str, limit: int = LIMIT) -> pd.DataFrame: embedding = self.model.encode(value) knn = self.knns[key] distances, indices = knn.kneighbors( [embedding], n_neighbors=limit, return_distance=True ) ids = [self.ids[i] for i in indices[0]] similarities = (1 - distances).flatten() # by definition: # cosine distance = 1 - cosine similarity result = pd.DataFrame( {"id": ids, f"score_{key}": similarities, key: self.data[key][ids]} ) result.set_index("id", inplace=True) return result def search(self, query: dict, limit: int = LIMIT) -> pd.DataFrame: results = [] for key, value in query.items(): if key not in self.knns: continue result_key = self.search_key(key, value, limit=limit) result_key.drop(columns=[key], inplace=True) results.append(result_key) merged_results = pd.concat(results, axis=1) merged_results["score"] = merged_results.mean(axis=1, skipna=False) merged_results.sort_values("score", ascending=False, inplace=True) return merged_results naive_retriever = NaiveRetriever(df.set_index("name"))

Upotrijebimo prvi upit s naše generirane liste iznad i pretražimo čudovišta koristeći naš naive_retriever :

 query = { 'look': 'glowing', 'habitat': 'dark places', 'behavior': 'light manipulation' } naive_retriever.search(query)

Naš

 naive_retriever

vraća sljedeće rezultate pretraživanja za svaki atribut:

Sjajno! Naši vraćeni rezultati čudovišta su relevantni - svi imaju neke "sjajne" karakteristike.

Hajde da vidimo šta naivni pristup daje kada pretražujemo druga dva atributa.

Sva pronađena čudovišta posjeduju tražene atribute. Na prvi pogled, naivni rezultati pretraživanja mogu izgledati obećavajuće. Ali moramo pronaći čudovišta koja posjeduju sva tri atributa istovremeno . Hajde da spojimo naše rezultate da vidimo koliko dobro naša čudovišta rade u postizanju ovog cilja:

I tu granice naivnog pristupa postaju očigledne. Procijenimo:

1. Relevantnost prema atributu:
   • look : Tri čudovišta su vraćena (Šaptajuća senka, Džin iz peščane oluje i Luminot).
   • habitat : Samo jedno čudovište iz rezultata look bilo je relevantno (Whispering Shade).
   • behavior : Samo jedno čudovište iz rezultata look je relevantno (Luminoth), ali se razlikuje od onog relevantnog za habitat .
2. Ukupna relevantnost:
   • Nijedno čudovište nije vraćeno za sva tri atributa istovremeno.
   • Rezultati su fragmentirani: različita čudovišta su relevantna za različite atribute.

Ukratko, naivni pristup pretraživanja ne uspijeva pronaći čudovišta koja zadovoljavaju sve kriterije odjednom. Možda možemo riješiti ovaj problem proaktivnim preuzimanjem više čudovišta za svaki atribut? Hajde da probamo sa 6 čudovišta po atributu, umesto sa 3. Pogledajmo šta ovaj pristup generiše:

Sada smo preuzeli 13 čudovišta (više od polovine našeg malog skupa podataka!), i još uvijek imamo isti problem: nijedno od ovih čudovišta nije preuzeto za sva tri atributa.

Povećanje broja pronađenih čudovišta (iznad 6) moglo bi riješiti naš problem, ali stvara dodatne probleme:

1. U proizvodnji, dohvaćanje više rezultata (više kNN pretraga) značajno produžava vrijeme pretraživanja.
2. Za svaki novi atribut koji uvedemo, naše šanse da pronađemo "potpuno" čudovište - sa svim atributima u našem upitu - opadaju eksponencijalno. Da bismo to spriječili, moramo povratiti mnogo više najbližih susjeda (čudovišta), čime ukupan broj pronađenih čudovišta raste eksponencijalno.
3. Još uvijek nemamo garanciju da ćemo povratiti čudovišta koja posjeduju sve naše željene atribute.
4. Ako uspemo da povratimo čudovišta koja zadovoljavaju sve kriterijume odjednom, moraćemo da potrošimo dodatne rezultate na usklađivanje.

Ukratko, naivni pristup je previše neizvjestan i neefikasan za održivo pretraživanje više atributa, posebno u proizvodnji.

Superlinkovani pristup

Hajde da implementiramo naš drugi pristup da vidimo da li radi bolje od naivnog.

Prvo, definiramo shemu, razmake, indeks i upit:

 @schema class Monster: id: IdField look: String habitat: String behavior: String monster = Monster() look_space = TextSimilaritySpace(text=monster.look, model=MODEL_NAME) habitat_space = TextSimilaritySpace(text=monster.habitat, model=MODEL_NAME) behavior_space = TextSimilaritySpace(text=monster.behavior, model=MODEL_NAME) monster_index = Index([look_space, habitat_space, behavior_space]) monster_query = ( Query( monster_index, weights={ look_space: Param("look_weight"), habitat_space: Param("habitat_weight"), behavior_space: Param("behavior_weight"), }, ) .find(monster) .similar(look_space.text, Param("look")) .similar(habitat_space.text, Param("habitat")) .similar(behavior_space.text, Param("behavior")) .limit(LIMIT) ) default_weights = { "look_weight": 1.0, "habitat_weight": 1.0, "behavior_weight": 1.0 }

Sada pokrećemo executor i učitavamo podatke:

 monster_parser = DataFrameParser(monster, mapping={monster.id: "name"}) source: InMemorySource = InMemorySource(monster, parser=monster_parser) executor = InMemoryExecutor(sources=[source], indices=[monster_index]) app = executor.run() source.put([df])

Pokrenimo isti upit koji smo pokrenuli u našoj implementaciji naivnog pristupa iznad:

 query = { 'look': 'glowing', 'habitat': 'dark places', 'behavior': 'light manipulation' } app.query( monster_query, limit=LIMIT, **query, **default_weights )

Et voila! Ovog puta, svako od naših najboljih vraćenih čudovišta visoko se kotira u ocjeni koja predstavlja neku vrstu "srednje vrijednosti" od sve tri karakteristike koje želimo da naše čudovište ima. Hajde da detaljno razložimo rezultat svakog čudovišta:

Naši drugi i treći rezultat, Luminoth i Living Graffiti, posjeduju sve tri željene karakteristike. Najbolji rezultat, Whispering Shade, iako je manje relevantan u smislu manipulacije svjetlom - što se ogleda u njegovom rezultatu behavior (0,006), ima "sjajne" karakteristike i mračno okruženje koje čine njegov look (0,168) i habitat (0,203) vrlo dobrim visoko, što mu daje najviši ukupni rezultat (0,377), što ga čini najrelevantnijim čudovištem u cjelini. Kakvo poboljšanje!

Možemo li ponoviti naše rezultate? Hajde da pokušamo sa drugim upitom i saznamo.

 query = { 'look': 'shapeshifting', 'habitat': 'varied landscapes', 'behavior': 'illusion creation' }

Odlično! Naši rezultati su opet odlični.

Što ako želimo pronaći čudovišta koja su slična određenom čudovištima iz našeg skupa podataka? Pokušajmo s čudovištem koje još nismo vidjeli - Harmonic Coral. Mogli bismo izdvojiti atribute za ovo čudovište i ručno kreirati parametre upita. Ali Superlinked ima metodu with_vector koju možemo koristiti na objektu upita. Budući da je id svakog čudovišta njegovo ime, naš zahtjev možemo izraziti jednostavno kao:

 app.query( monster_query.with_vector(monster, "Harmonic Coral"), **default_weights, limit=LIMIT )

Najbolji rezultat je najrelevantniji, sam Harmonic Coral, kako se i očekivalo. Druga dva čudovišta koje naša pretraga pronalazi su Dreamweaver Octopus i Aqua Wraith. Oba dijele važne tematske ( atributne ) elemente sa Harmonic Coral:

1. Vodena staništa ( habitat )
2. Sposobnost da utiču ili manipulišu svojom okolinom ( behavior )
3. Dinamičke ili fluidne vizuelne karakteristike ( look )

Ponderiranje atributa

Pretpostavimo sada da želimo da damo veći značaj atributu look . Okvir Superlinked nam omogućava da lako prilagodimo težine u trenutku upita. Radi lakšeg poređenja, tražit ćemo čudovišta slična Harmonic Coral-u, ali s našim težinama prilagođenim look .

 weights = { "look_weight": 1.0, "habitat_weight": 0, "behavior_weight": 0 } app.query( monster_query.with_vector(monster, "Harmonic Coral"), limit=LIMIT, **weights )

Svi naši rezultati (prikladno) imaju slične izglede - "Granjanje sa vibrirajućim viticama", "Biljko nalik stvorenju sa tijelom od uvijene loze i trnja", "Zmijino".

Sada, napravimo još jednu pretragu, ignorirajući izgled i umjesto toga tražimo čudovišta koja su slična u smislu habitat i behavior istovremeno:

 weights = { "look_weight": 0, "habitat_weight": 1.0, "behavior_weight": 1.0 }

Opet, Superlinked pristup daje odlične rezultate. Sva tri čudovišta žive u vodenom okruženju i posjeduju sposobnosti kontrole uma.

Konačno, hajde da pokušamo još jednu pretragu, različito ponderišući sva tri atributa - da pronađemo čudovišta koja u poređenju sa Harmonic Coral izgledaju donekle slično, žive u veoma različitim staništima i imaju vrlo slično ponašanje:

 weights = { "look_weight": 0.5, "habitat_weight": -1.0, "behavior_weight": 1.0 }

Opet odlični rezultati! Naša druga dva pronađena čudovišta — Luminoth i Zephyr Dancer — imaju ponašanje slično Harmonic Coral-u i žive u staništima drugačijim od Harmonic Coral-a. Takođe izgledaju veoma različito od Harmonic Corala. (Dok su vitice Harmonic Corala i Luminothova antena donekle slične karakteristike, smanjili smo samo look_weight za 0,5, a sličnost između dva čudovišta se tu završava.)

Hajde da vidimo kako se ukupni rezultati ovih čudovišta izbijaju u smislu pojedinačnih atributa:

Negativnim ponderisanjem habitat_weight (-1.0), mi namjerno "odgurujemo" čudovišta sa sličnim staništima i umjesto toga čudovišta na površini čije je okruženje drugačije od Harmonic Coral-a - kao što se vidi u negativnim ocjenama habitat Luminotha i Zephyr Dancera. Rezultati behavior Luminotha i Zephyr Dancera su relativno visoki, što ukazuje na njihovu sličnost u ponašanju sa Harmonic Coral. Njihovi rezultati look su pozitivni, ali niži, odražavajući neku , ali ne ekstremnu vizualnu sličnost s Harmonic Coral.

Ukratko, naša strategija smanjenja težine habitat_weight na -1.0 i look_weight na 0.5, ali zadržavanje behavior_weight na 1.0 pokazala se učinkovitom u otkrivanju čudovišta koja dijele ključne karakteristike ponašanja sa Harmonic Coralom, ali imaju vrlo različita okruženja i izgledaju barem donekle drugačije.

Zaključak

Vektorska pretraga sa više atributa je značajan napredak u pronalaženju informacija, nudeći više tačnosti, kontekstualnog razumijevanja i fleksibilnosti od osnovne pretrage semantičke sličnosti. Ipak, naš naivni pristup (gore) - odvojeno pohranjivanje i pretraživanje vektora atributa, zatim kombinovanje rezultata - ograničen je u sposobnostima, suptilnosti i efikasnosti kada trebamo da dohvatimo objekte sa višestrukim istovremenim atributima. (Štaviše, višestruka kNN pretraživanja oduzimaju više vremena od jedne pretrage sa povezanim vektorima.)

Za rukovanje ovakvim scenarijima, bolje je pohraniti sve svoje vektore atributa u istu vektorsku trgovinu i izvršiti jedno pretraživanje , ponderirajući vaše atribute u vrijeme upita. Pristup Superlinked je tačniji, efikasniji i skalabilniji od naivnog pristupa za bilo koju aplikaciju koja zahtijeva brzo, pouzdano, nijansirano, višeatributno dohvaćanje vektora - bilo da se vaš slučaj upotrebe bavi problemima podataka iz stvarnog svijeta u vašem e-trgovini ili sistemu preporuka ... ili nešto sasvim drugačije, poput borbe protiv čudovišta.

Saradnici

• Andrej Pikunov, autor
• Mór Kapronczay, urednik