புரட்சிகரமான மான்ஸ்டர் ஹன்ட்ஸ்: AI-மேம்படுத்தப்பட்ட D&D என்கவுண்டர்கள்

AI-இயங்கும் இருள் இராணுவம்

இது விளையாட்டு இரவு, உங்கள் நண்பர்கள் கேம்ஸ் டேபிளைச் சுற்றி அமர்ந்திருக்கிறார்கள், அவர்கள் என்ன டன்ஜியன்ஸ் & டிராகன்கள் (D&D) கதாபாத்திரமாக மாறுவார்கள் என்பதைப் பார்க்க காத்திருக்கிறார்கள் மற்றும் அவர்கள் தொடங்குவார்கள். இன்றிரவு, நீங்கள் டன்ஜியன் மாஸ்டர் (கதைசொல்லி மற்றும் வழிகாட்டி), உங்கள் வீரர்களுக்கு சவால் விடும் மற்றும் கவர்ந்திழுக்கும் சிலிர்ப்பான சந்திப்புகளை உருவாக்குபவர். உங்கள் நம்பகமான D&D மான்ஸ்டர் கையேட்டில் ஆயிரக்கணக்கான உயிரினங்கள் உள்ளன. எண்ணற்ற விருப்பங்களில் ஒவ்வொரு சூழ்நிலைக்கும் சரியான அரக்கனைக் கண்டறிவது மிகப்பெரியதாக இருக்கும். இலட்சிய எதிரி, அந்த தருணத்தின் அமைப்பு, சிரமம் மற்றும் கதையுடன் பொருந்த வேண்டும்.

ஒவ்வொரு சூழ்நிலைக்கும் மிகவும் பொருத்தமான அரக்கனை உடனடியாகக் கண்டுபிடிக்கும் கருவியை நாம் உருவாக்கினால் என்ன செய்வது? ஒரே நேரத்தில் பல காரணிகளைக் கருத்தில் கொள்ளும் ஒரு கருவி , ஒவ்வொரு சந்திப்பையும் முடிந்தவரை ஆழமாகவும் உற்சாகமாகவும் இருப்பதை உறுதிசெய்கிறதா?

நமக்கான ஒரு தேடலைத் தொடங்குவோம்: பல பண்புக்கூறு வெக்டார் தேடலின் சக்தியைப் பயன்படுத்தி, இறுதி அரக்கனைக் கண்டறியும் அமைப்பை உருவாக்குங்கள்!

திசையன் தேடலின் மூலம் உயிரினங்களை உருவாக்குதல், அதை ஏன் செய்வது?

திசையன் தேடல் என்பது தகவல் மீட்டெடுப்பில் ஒரு புரட்சியைக் குறிக்கிறது. திசையன் உட்பொதித்தல் - சூழல் மற்றும் சொற்பொருள் அர்த்தத்தை கணக்கில் எடுத்துக்கொள்வதன் மூலம் - திசையன் தேடலுக்கு மிகவும் பொருத்தமான மற்றும் துல்லியமான முடிவுகளை வழங்க, கட்டமைக்கப்பட்ட ஆனால் கட்டமைக்கப்படாத தரவு மற்றும் பல மொழிகள் மற்றும் அளவைக் கையாளவும். ஆனால் நிஜ-உலகப் பயன்பாடுகளில் உயர்தரப் பதில்களை உருவாக்க, நமது தரவுப் பொருள்களின் குறிப்பிட்ட பண்புக்கூறுகளுக்கு வெவ்வேறு எடைகளை நாம் அடிக்கடி ஒதுக்க வேண்டும்.

பல பண்புக்கூறு திசையன் தேடலுக்கு இரண்டு பொதுவான அணுகுமுறைகள் உள்ளன. தரவுப் பொருளின் ஒவ்வொரு பண்புக்கூறையும் தனித்தனியாக உட்பொதிப்பதன் மூலம் இரண்டும் தொடங்குகின்றன. இந்த இரண்டு அணுகுமுறைகளுக்கும் இடையே உள்ள முக்கிய வேறுபாடு என்னவென்றால், எங்கள் உட்பொதிப்புகள் எவ்வாறு சேமிக்கப்படுகின்றன மற்றும் தேடப்படுகின்றன என்பதில் உள்ளது.

1. அப்பாவி அணுகுமுறை - ஒவ்வொரு பண்புக்கூறு வெக்டரையும் தனித்தனி வெக்டர் ஸ்டோர்களில் (ஒரு பண்புக்கூறுக்கு ஒன்று) சேமித்து, ஒவ்வொரு பண்புக்கும் தனித்தனியாகத் தேடவும், தேடல் முடிவுகளை ஒருங்கிணைக்கவும், தேவைக்கேற்ப பிந்தைய செயல்முறை (எ.கா. எடை) செய்யவும்.
2. Superlinked அணுகுமுறை - ஒரே திசையன் ஸ்டோரில் ( Superlinked இன் உள்ளமைக்கப்பட்ட செயல்பாட்டைப் பயன்படுத்தி) அனைத்து பண்புக்கூறு வெக்டார்களையும் ஒருங்கிணைத்து சேமிக்கலாம் Superlinked's spaces வினவல் நேரத்தில் ஒவ்வொரு பண்புக்கூறுகளையும் மிகவும் பொருத்தமான முடிவுகளை வெளியிடுவதற்கு, பிந்தைய செயலாக்கம் இல்லாமல் எடைபோட அனுமதிக்கின்றன .

கீழே, பல பண்புக்கூறு வெக்டர் தேடல் கருவியை செயல்படுத்த இந்த இரண்டு அணுகுமுறைகளையும் பயன்படுத்துவோம் - ஒரு Dungeons and Dragons monster Finder! எங்களின் எளிய செயலாக்கங்கள், குறிப்பாக இரண்டாவது, மிகவும் சக்திவாய்ந்த மற்றும் நெகிழ்வான தேடல் அமைப்புகளை எவ்வாறு உருவாக்குவது என்பதை விளக்கும், சிக்கலான, பன்முக வினவல்களை எளிதாகக் கையாளக்கூடியவை, உங்கள் பயன்பாடு எதுவாக இருந்தாலும்.

திசையன் ஒற்றுமை தேடலுக்கு நீங்கள் புதியவராக இருந்தால், கவலைப்பட வேண்டாம்! நாங்கள் உங்களைப் பாதுகாத்துள்ளோம் - எங்கள் கட்டுமானத் தொகுதிகள் கட்டுரைகளைப் பார்க்கவும்.

சரி, அசுர வேட்டைக்குப் போகலாம்!

தரவுத்தொகுப்பு

முதலில், ஒரு பெரிய மொழி மாதிரியை (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": "..."}, ... ] }

எங்கள் LLM உருவாக்கிய தரவுத்தொகுப்பின் மாதிரியைப் பார்ப்போம். குறிப்பு: எல்எல்எம் உருவாக்கம் தீர்மானிக்க முடியாதது, எனவே உங்கள் முடிவுகள் மாறுபடலாம்.

எங்கள் முதல் ஐந்து அரக்கர்கள் இங்கே:

... மேலும் நாங்கள் உருவாக்கிய வினவல்கள்:

அசல் தரவுத்தொகுப்பு மற்றும் வினவல் எடுத்துக்காட்டுகளை இங்கே பார்க்கவும்.

மீட்டெடுப்பு

எங்கள் இரண்டு அணுகுமுறைகளிலும் நாம் பயன்படுத்தும் அளவுருக்களை அமைப்போம் - அப்பாவி மற்றும் சூப்பர்லிங்க்டு - கீழே.

நாங்கள் எங்கள் திசையன் உட்பொதிவுகளை உருவாக்குகிறோம்:

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

எளிமைக்காக, எங்கள் வெளியீட்டை முதல் 3 பொருத்தங்களுக்கு வரம்பிடுவோம். (தேவையான இறக்குமதிகள் மற்றும் உதவி செயல்பாடுகள் உட்பட முழுமையான குறியீட்டிற்கு, நோட்புக்கைப் பார்க்கவும்.)

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

இப்போது, பல பண்புக்கூறுகள் கொண்ட அசுரன் தேடலைப் பெறுவோம்! முதலில், அப்பாவியான அணுகுமுறையை முயற்சிப்போம்.

அப்பாவி அணுகுமுறை

எங்களின் அப்பாவி அணுகுமுறையில், தனித்தனியாக பண்புகளை உட்பொதித்து, வெவ்வேறு குறியீடுகளில் அவற்றைச் சேமிக்கிறோம். வினவல் நேரத்தில், அனைத்து குறியீடுகளிலும் பல kNN-தேடல்களை இயக்குவோம், பின்னர் எங்களின் அனைத்து பகுதி முடிவுகளையும் ஒன்றாக இணைக்கிறோம்.

ஒரு வகுப்பை வரையறுப்பதன் மூலம் தொடங்குகிறோம்

 NaiveRetriever

எங்களின் 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"))

மேலே உள்ள எங்களால் உருவாக்கப்பட்ட பட்டியலிலிருந்து முதல் வினவலைப் பயன்படுத்துவோம், மேலும் எங்கள் naive_retriever பயன்படுத்தி அரக்கர்களைத் தேடுவோம்:

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

எங்கள்

 naive_retriever

ஒவ்வொரு பண்புக்கும் பின்வரும் தேடல் முடிவுகளை வழங்குகிறது:

அருமை! எங்கள் திரும்பிய அசுரன் முடிவுகள் பொருத்தமானவை - அவை அனைத்தும் சில "ஒளிரும்" பண்புகளைக் கொண்டுள்ளன.

மற்ற இரண்டு பண்புக்கூறுகளைத் தேடும்போது அப்பாவி அணுகுமுறை என்ன திரும்பும் என்று பார்ப்போம்.

மீட்டெடுக்கப்பட்ட அனைத்து அரக்கர்களும் விரும்பிய பண்புகளைக் கொண்டுள்ளனர். முதல் பார்வையில், அப்பட்டமான தேடல் முடிவுகள் நம்பிக்கைக்குரியதாகத் தோன்றலாம். ஆனால் ஒரே நேரத்தில் மூன்று பண்புகளையும் கொண்ட அரக்கர்களை நாம் கண்டுபிடிக்க வேண்டும். இந்த இலக்கை அடைவதில் நமது அரக்கர்கள் எவ்வளவு சிறப்பாக செயல்படுகிறார்கள் என்பதைப் பார்க்க, எங்கள் முடிவுகளை ஒன்றிணைப்போம்:

இங்கே, அப்பாவி அணுகுமுறையின் வரம்புகள் தெளிவாகின்றன. மதிப்பீடு செய்வோம்:

1. பண்பு அடிப்படையில் பொருத்தம்:
   • look : மூன்று அரக்கர்கள் மீட்டெடுக்கப்பட்டனர் (விஸ்பரிங் ஷேட், சாண்ட்ஸ்டார்ம் டிஜின் மற்றும் லுமினோத்).
   • habitat : look முடிவுகளில் இருந்து ஒரே ஒரு அசுரன் மட்டுமே பொருத்தமானது (விஸ்பரிங் ஷேட்).
   • behavior : look முடிவுகளில் ஒரே ஒரு அசுரன் மட்டுமே பொருத்தமானதாக இருந்தது (லுமினோத்), ஆனால் அது habitat பொருத்தமான ஒன்றிலிருந்து வேறுபட்டது.
2. ஒட்டுமொத்த சம்பந்தம்:
   • ஒரே நேரத்தில் மூன்று பண்புகளுக்காக எந்த ஒரு அரக்கனும் மீட்டெடுக்கப்படவில்லை.
   • முடிவுகள் துண்டு துண்டாக உள்ளன: வெவ்வேறு அரக்கர்கள் வெவ்வேறு பண்புகளுக்கு பொருத்தமானவர்கள்.

சுருக்கமாக, அப்பாவியான தேடல் அணுகுமுறை அனைத்து அளவுகோல்களையும் ஒரே நேரத்தில் பூர்த்தி செய்யும் அரக்கர்களைக் கண்டுபிடிக்கத் தவறிவிட்டது. ஒவ்வொரு பண்புக்கும் அதிகமான அரக்கர்களை முன்கூட்டியே மீட்டெடுப்பதன் மூலம் இந்த சிக்கலை சரிசெய்ய முடியுமா? ஒரு பண்புக்கூறுக்கு 3க்கு பதிலாக 6 பேய்களை வைத்து முயற்சிப்போம். இந்த அணுகுமுறை என்ன உருவாக்குகிறது என்பதைப் பார்ப்போம்:

நாங்கள் இப்போது 13 பேய்களை மீட்டுள்ளோம் (எங்கள் சிறிய தரவுத்தொகுப்பில் பாதிக்கும் மேற்பட்டவை!), இன்னும் அதே சிக்கல் உள்ளது: இந்த மூன்று பண்புகளுக்கும் இந்த அரக்கர்கள் ஒன்று கூட மீட்டெடுக்கப்படவில்லை.

மீட்டெடுக்கப்பட்ட அரக்கர்களின் எண்ணிக்கையை அதிகரிப்பது (6க்கு அப்பால்) எங்கள் சிக்கலை தீர்க்கக்கூடும் , ஆனால் இது கூடுதல் சிக்கல்களை உருவாக்குகிறது:

1. தயாரிப்பில், கூடுதல் முடிவுகளை (பல kNN தேடல்கள்) மீட்டெடுப்பது தேடல் நேரத்தை குறிப்பிடத்தக்க வகையில் நீட்டிக்கிறது.
2. நாம் அறிமுகப்படுத்தும் ஒவ்வொரு புதிய பண்புக்கும், ஒரு "முழுமையான" அசுரனைக் கண்டுபிடிப்பதற்கான வாய்ப்புகள் - எங்கள் வினவலில் உள்ள அனைத்து பண்புக்கூறுகளுடன் - அதிவேகமாகக் குறைகிறது. இதைத் தடுக்க, நாம் இன்னும் பல அருகிலுள்ள அண்டை நாடுகளை (அரக்கர்கள்) மீட்டெடுக்க வேண்டும், மீட்டெடுக்கப்பட்ட அரக்கர்களின் மொத்த எண்ணிக்கை அதிவேகமாக வளரும்.
3. நாங்கள் விரும்பிய அனைத்து பண்புகளையும் கொண்ட அரக்கர்களை மீட்டெடுப்போம் என்று எங்களுக்கு இன்னும் உத்தரவாதம் இல்லை.
4. ஒரே நேரத்தில் அனைத்து அளவுகோல்களையும் பூர்த்தி செய்யும் பேய்களை மீட்டெடுக்க முடிந்தால், கூடுதல் மேல்நிலை சமரச முடிவுகளைச் செலவிட வேண்டியிருக்கும்.

மொத்தத்தில், அப்பட்டமான அணுகுமுறை மிகவும் நிச்சயமற்றது மற்றும் சாத்தியமான பல பண்புக்கூறு தேடலுக்கு, குறிப்பாக உற்பத்தியில் திறனற்றது.

மிகைப்படுத்தப்பட்ட அணுகுமுறை

இது அப்பாவியாக இருப்பதை விட சிறப்பாக செயல்படுகிறதா என்பதைப் பார்க்க, எங்கள் இரண்டாவது அணுகுமுறையை செயல்படுத்துவோம்.

முதலில், ஸ்கீமா, ஸ்பேஸ், இன்டெக்ஸ் மற்றும் வினவல் ஆகியவற்றை வரையறுக்கிறோம்:

 @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 }

இப்போது, எக்ஸிகியூட்டரைத் தொடங்கி, தரவைப் பதிவேற்றுகிறோம்:

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

மேலே உள்ள எங்களின் அப்பாவி அணுகுமுறை செயலாக்கத்தில் நாங்கள் இயக்கிய அதே வினவலை இயக்குவோம்:

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

எட் வோய்லா! இந்த நேரத்தில், எங்களின் டாப் ரிடர்ன்ட் பேய்கள் ஒவ்வொன்றும், நமது அசுரனிடம் இருக்க வேண்டும் என்று நாம் விரும்பும் மூன்று குணாதிசயங்களின் ஒரு வகையான "சராசரியை" பிரதிநிதித்துவப்படுத்தும் மதிப்பெண்ணில் உயர்ந்த இடத்தில் உள்ளது. ஒவ்வொரு அசுரனின் ஸ்கோரையும் விரிவாக உடைப்போம்:

எங்களின் இரண்டாவது மற்றும் மூன்றாவது முடிவுகள், லுமினோத் மற்றும் லிவிங் கிராஃபிட்டி ஆகிய இரண்டும் விரும்பிய மூன்று பண்புகளையும் கொண்டுள்ளன. சிறந்த முடிவு, விஸ்பரிங் ஷேட், ஒளி கையாளுதலின் அடிப்படையில் குறைவான பொருத்தமாக இருந்தாலும் - அதன் behavior மதிப்பெண்ணில் (0.006) பிரதிபலிக்கிறது, "ஒளிரும்" அம்சங்கள் மற்றும் இருண்ட சூழலைக் கொண்டுள்ளது, அது அதன் look (0.168) மற்றும் habitat (0.203) மதிப்பெண்களை மிக அதிகமாகக் கொண்டுள்ளது. அதிக, இது அதிகபட்ச மொத்த மதிப்பெண்ணை (0.377) அளிக்கிறது, இது ஒட்டுமொத்தமாக மிகவும் பொருத்தமான அரக்கனாக அமைகிறது. என்ன ஒரு முன்னேற்றம்!

எங்கள் முடிவுகளைப் பிரதிபலிக்க முடியுமா? மற்றொரு வினவலை முயற்சி செய்து கண்டுபிடிக்கலாம்.

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

அருமை! எங்கள் முடிவுகள் மீண்டும் சிறப்பாக உள்ளன.

எங்கள் தரவுத்தொகுப்பிலிருந்து ஒரு குறிப்பிட்ட அசுரனைப் போன்ற பேய்களை நாம் கண்டுபிடிக்க விரும்பினால் என்ன செய்வது? நாம் இதுவரை பார்த்திராத ஒரு அரக்கனுடன் இதை முயற்சிப்போம் - ஹார்மோனிக் பவளப்பாறை. இந்த அசுரனுக்கான பண்புகளை நாம் பிரித்தெடுக்கலாம் மற்றும் வினவல் அளவுருக்களை கைமுறையாக உருவாக்கலாம். ஆனால் வினவல் பொருளில் நாம் பயன்படுத்தக்கூடிய with_vector முறையை Superlinked கொண்டுள்ளது. ஒவ்வொரு அரக்கனின் ஐடியும் அதன் பெயராக இருப்பதால், எங்கள் கோரிக்கையை இவ்வாறு எளிமையாக வெளிப்படுத்தலாம்:

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

எதிர்பார்த்தது போலவே ஹார்மோனிக் பவளமே மிகவும் பொருத்தமானது. ட்ரீம்வீவர் ஆக்டோபஸ் மற்றும் அக்வா வ்ரைத் ஆகிய இரண்டு பேய்களை நாங்கள் தேடுகிறோம். இருவரும் ஹார்மோனிக் பவளத்துடன் முக்கியமான கருப்பொருள் ( பண்பு ) கூறுகளைப் பகிர்ந்து கொள்கிறார்கள்:

1. நீர்வாழ் வாழ்விடங்கள் ( habitat )
2. அவர்களின் சூழலில் செல்வாக்கு அல்லது கையாளும் திறன் ( behavior )
3. மாறும் அல்லது திரவ காட்சி பண்புகள் ( look )

பண்பு எடையிடல்

இப்போது, நாம் look பண்புக்கு அதிக முக்கியத்துவம் கொடுக்க விரும்புகிறோம் என்று வைத்துக்கொள்வோம். வினவல் நேரத்தில் எடைகளை எளிதாக சரிசெய்ய சூப்பர் லிங்க்ட் ஃப்ரேம்வொர்க் உதவுகிறது. எளிதாக ஒப்பிடுவதற்கு look ஹார்மோனிக் பவளப்பாறை போன்ற அரக்கர்களைத் தேடுவோம்.

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

எங்கள் முடிவுகள் அனைத்தும் (பொருத்தமான முறையில்) ஒரே மாதிரியான தோற்றம் கொண்டவை - "அதிர்வுறும் தசைநாண்களுடன் கிளைத்தல்", "முறுக்கப்பட்ட கொடிகள் மற்றும் முட்கள் கொண்ட உடல் போன்ற உயிரினம்", "பாம்பு போன்றது".

இப்போது, மற்றொரு தேடலைச் செய்வோம், தோற்றத்தைப் புறக்கணித்துவிட்டு, ஒரே நேரத்தில் habitat மற்றும் behavior அடிப்படையில் ஒரே மாதிரியான அரக்கர்களைத் தேடுவோம்:

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

மீண்டும், Superlinked அணுகுமுறை சிறந்த முடிவுகளைத் தருகிறது. மூன்று பேய்களும் நீர் நிறைந்த சூழலில் வாழ்கின்றன மற்றும் மனதைக் கட்டுப்படுத்தும் திறன்களைக் கொண்டுள்ளன.

இறுதியாக, மற்றொரு தேடலை முயற்சிப்போம், மூன்று பண்புகளையும் வித்தியாசமாக எடைபோடலாம் - ஹார்மோனிக் பவளத்துடன் ஒப்பிடுகையில் ஓரளவு ஒத்ததாக இருக்கும், மிகவும் வேறுபட்ட வாழ்விடங்களில் வாழும் மற்றும் மிகவும் ஒத்த நடத்தை கொண்ட அரக்கர்களைக் கண்டறிய:

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

மீண்டும் சிறந்த முடிவுகள்! எங்களுடைய மற்ற இரண்டு மீட்டெடுக்கப்பட்ட அரக்கர்கள் - லுமினோத் மற்றும் செஃபிர் டான்சர் - ஹார்மோனிக் பவளப்பாறையைப் போன்ற நடத்தை கொண்டவர்கள் மற்றும் ஹார்மோனிக் பவளப்பாறையிலிருந்து வேறுபட்ட வாழ்விடங்களில் வாழ்கின்றனர். அவை ஹார்மோனிக் பவளத்திலிருந்தும் மிகவும் வேறுபட்டவை. (ஹார்மோனிக் பவளத்தின் போக்குகளும் லுமினோத்தின் ஆண்டெனாவும் ஓரளவு ஒத்த அம்சங்களாக இருந்தாலும், நாங்கள் look_weight 0.5 ஆல் குறைத்தோம், மேலும் இரண்டு அரக்கர்களுக்கும் இடையிலான ஒற்றுமை அங்கேயே முடிகிறது.)

தனிப்பட்ட பண்புகளின் அடிப்படையில் இந்த அரக்கர்களின் ஒட்டுமொத்த மதிப்பெண்கள் எவ்வாறு உடைகின்றன என்பதைப் பார்ப்போம்:

லுமினோத் மற்றும் செஃபிர் டான்சரின் எதிர்மறை habitat மதிப்பெண்களில் காணப்படுவது போல், habitat_weight (-1.0) எதிர்மறையாக எடைபோடுவதன் மூலம், ஒரே மாதிரியான வாழ்விடங்களைக் கொண்ட அரக்கர்களை நாங்கள் வேண்டுமென்றே "தள்ளுகிறோம்". லுமினோத் மற்றும் செஃபிர் டான்சரின் behavior மதிப்பெண்கள் ஒப்பீட்டளவில் அதிகமாக உள்ளன, இது ஹார்மோனிக் கோரலுடன் அவர்களின் நடத்தை ஒற்றுமையைக் குறிக்கிறது. அவர்களின் look மதிப்பெண்கள் நேர்மறையானவை, ஆனால் குறைவானவை, ஹார்மோனிக் கோரலுடன் சில ஆனால் தீவிர காட்சி ஒற்றுமையை பிரதிபலிக்கவில்லை.

சுருக்கமாக, ஹார்மோனிக் பவளத்துடன் முக்கிய நடத்தை பண்புகளைப் பகிர்ந்து கொள்ளும் ஆனால் மிகவும் வித்தியாசமான சூழல்களைக் கொண்ட மற்றும் குறைந்த பட்சம் வித்தியாசமாகத் தோற்றமளிக்கும் அசுரர்களை வெளிக்கொணர்வதில் எங்களுடைய உத்தி behavior_weight habitat_weight -1.0 ஆகவும், look_weight 0.5 ஆகவும் குறைக்கிறது.

முடிவுரை

மல்டி-அட்ரிபியூட் வெக்டார் தேடல் என்பது தகவல் மீட்டெடுப்பதில் குறிப்பிடத்தக்க முன்னேற்றமாகும், இது அடிப்படை சொற்பொருள் ஒற்றுமை தேடலை விட அதிக துல்லியம், சூழல் புரிதல் மற்றும் நெகிழ்வுத்தன்மையை வழங்குகிறது. இருப்பினும், எங்களின் அப்பாவி அணுகுமுறை (மேலே) - தனித்தனியாக பண்புக்கூறு திசையன்களை சேமித்து தேடுதல், பின்னர் முடிவுகளை ஒருங்கிணைத்தல் - திறன், நுணுக்கம் மற்றும் செயல்திறன் ஆகியவற்றில் நாம் ஒரே நேரத்தில் பல பண்புகளுடன் பொருட்களை மீட்டெடுக்க வேண்டும். (மேலும், பல kNN தேடல்கள் இணைக்கப்பட்ட திசையன்களுடன் ஒரு தேடலை விட அதிக நேரம் எடுக்கும்.)

இது போன்ற காட்சிகளைக் கையாள, உங்கள் எல்லா பண்புக்கூறு வெக்டார்களையும் ஒரே திசையன் ஸ்டோரில் சேமித்து, வினவல் நேரத்தில் உங்கள் பண்புக்கூறுகளை எடைபோட்டு, ஒரே தேடலைச் செய்வது நல்லது. வேகமான, நம்பகமான, நுணுக்கமான, மல்டி-அட்ரிபியூட் வெக்டார் மீட்டெடுப்பு தேவைப்படும் எந்தவொரு பயன்பாட்டிற்கும் அப்பாவி அணுகுமுறையை விட சூப்பர் லிங்க் செய்யப்பட்ட அணுகுமுறை மிகவும் துல்லியமானது, திறமையானது மற்றும் அளவிடக்கூடியது - உங்கள் மின் வணிகம் அல்லது பரிந்துரை அமைப்பில் உள்ள நிஜ உலக தரவு சவால்களை உங்கள் பயன்பாட்டு வழக்கு சமாளிக்கிறதா ... அல்லது அசுரர்களுடன் சண்டையிடுவது போன்ற முற்றிலும் வேறுபட்ட ஒன்று.

பங்களிப்பாளர்கள்

• ஆண்ட்ரி பிகுனோவ், ஆசிரியர்
• Mór Kapronczay, ஆசிரியர்