ai-agents-for-beginners

(இந்த பாடத்தின் வீடியோவைப் பார்க்க மேலே உள்ள படத்தைச் சொடுக்கவும்)

ஏஐ ஏஜெண்டுகளில் மேட்டாக்கொக்னிஷன்

அறிமுகம்

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

கற்றல் இலக்குகள்

இந்த பாடத்தைக் முடித்த பிறகு நீங்கள் செய்யக்கூடியவை:

ஏஜெண்ட் வரையறைகளில் கருதப்படும் நியாய வட்டங்கள் (reasoning loops) பற்றிய விளக்கத்தை புரிந்து கொள்வது.
தன்னடக்கம் செய்யும் ஏஜெண்டுக்களுக்கு திட்டமிடல் மற்றும் மதிப்பீட்டு முறைகளை பயன்படுத்துவது.
பணிகளை நிறைவேற்றக் கோடுகளை ந وينைப் பயன்படுத்தி உங்கள் சொந்த ஏஜெண்டுகளை உருவாக்குவது.

மேட்டாக்கொக்னிஷன் அறிமுகம்

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

ஏஜெண்டிக் ஏஐ முறைமைகளின் சூழலில், மேட்டாக்கொக்னிஷன் பல சவால்களை எதிர்கொள்ள உதவுகிறது, அதாவது:

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

மேட்டாக்கொக்னிஷன் என்பது என்ன?

மேட்டாக்கொக்னிஷன் அல்லது “சிந்தைப்பற்றி சிந்தித்தல்” என்பது ஒருவரின் சிந்தனை செயல்களை தன்னுணர்வோடு கட்டுப்படுத்தும் உயர்ந்த நிலை நுண்ணறிவு செயலாகும். ஏஐ துறையில், மேட்டாக்கொக்னிஷன் மூலம் ஏஜெண்டுகள் தங்களுடைய மூலோபாயங்கள் மற்றும் நடவடிக்கைகளை மதிப்பீடு செய்து மாற்றுவதால், பிரச்சினை தீர்க்கும் மற்றும் முடிவெடுத்தல் திறன்கள் மேம்படுகின்றன. மேட்டாக்கொக்னிஷனை புரிந்துகொண்டும், நீங்கள் அதிக அறிவுத்திறன் மற்றும் தக்கவைத்து திறம்பட செயல்படும் ஏஐ ஏஜெண்டுகளை வடிவமைக்க முடியும். உண்மையான மேட்டாக்கொக்னிஷனில், ஏஐ தன் தன்னியத நியாயத்தை தெளிவாகச் சொல்வதைக் காணலாம்.

உதாரணம்: “நான் மலிவான விமானங்களை முன்னுரிமை கொடுத்தேன் ஏனெனில்… நேரடி விமானங்களை தவறவிடலாம், ஆகவே மீண்டும் சரிபார்க்கிறேன்.” அது நடத்தை எப்படி தேர்ந்தெடுத்தது என்பதை கண்காணிப்பது.

கடைசித்薦ர்வுக்கு மட்டுமல்ல, முடிவெடுத்தல் முறையையும் மாற்றுவது; முன்பிருந்த பயனர் விருப்பங்களுக்கு அதிக முறையிலும் சார்ந்ததால் தவறுகள் ஏற்பட்டன என்பதை கவனித்தல்.
“பயனர் ‘மிகவும் கூட்டம்’ என கூறும்போது, சில இடங்களை நீக்கும்படியாக மட்டும் அல்லாமல் ‘சிறந்த இடங்கள்’ தேர்வு செய்வதில் புகழ்பெற்றதை மட்டுமே அடிப்படையாக்கொள்ளும் முறையை மாற்ற வேண்டும்” என்ற மாதிரிகள் கண்டறிதல்.

ஏஐ ஏஜெண்டுகளில் மேட்டாக்கொக்னிஷன் முக்கியத்துவம்

மேட்டாக்கொக்னிஷன் ஏஐ ஏஜெண்ட் வடிவமைப்பில் பல காரணங்களுக்காக முக்கிய பங்கு வகிக்கிறது:

மேட்டாக்கொக்னிஷன் முக்கியத்துவம்

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

ஏஐ ஏஜெண்டின் கூறுகள்

மேட்டாக்கொக்னிடிவ் செயல்பாடுகளில் மூழ்குவதற்கு முன், ஏஐ ஏஜெண்டின் அடிப்படைக் கூறுகளை புரிந்து கொள்வது அவசியம். ஒரு ஏஐ ஏஜெண்ட் பொதுவாக கொண்டிருப்பதைக் குறிப்பிடுவது:

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

இவை இணைந்து ஒரு “நிபுணத்துவ அலகு” உருவாக்கி குறிப்பிட்ட பணிகளை செய்யும்.

உதாரணம்: பயண ஏஜெண்ட், பயண திட்டமிடுவதோடு நிகழ்பிறப்பு தரவுகளையும் கடந்த வாடிக்கையாளர் அனுபவங்களையும் அடிப்படையாகக் கொண்டு பாதை மாற்றும் சேவைகளை வழங்குவது என்று கருதுக.

உதாரணம்: பயண ஏஜெண்ட் சேவையில் மேட்டாக்கொக்னிஷன்

நீங்கள் ஏஐ இயக்கும் பயண ஏஜெண்ட் சேவையை வடிவமைக்கிறது என்று எண்ணுங்கள். இந்த ஏஜெண்ட் பயண திட்டம் செய்ய பயனர்களுக்கு உதவுகிறது. தன்னுணர்வு மற்றும் கடந்த அனுபவங்களை அடிப்படையாகக் கொண்டு செயல் திருத்தி கொள்ளும் வகையில் மேட்டாக்கொக்னிஷன் ஒன்று கொண்டுள்ளது. இது எப்படி செயல்படும் என்பதின் விளக்கம் கீழே உள்ளது:

தற்போதைய பணியில்

பயனருக்கு பாரிஸுக்கு பயணம் திட்டமிட உதவ வேண்டும்.

பணியை முடிப்பதற்கான படிகள்

பயனர் விருப்பங்களை சேகரிக்கவும்: பயண நாள்கள், பட்ஜெட், விருப்பங்கள் (கலைச்சங்கங்கள், சமையல், ஷாப்பிங் மற்றும் சாஹித்யங்கள்) பற்றிய கேள்விகள் கேட்கவும்.
தகவல் தேடல்: பயனர் விருப்பங்களுக்கு ஏற்ப விமானங்கள், தங்குமிடங்கள், சுற்றுலா இடங்கள் மற்றும் உணவகங்கள் தேடல்.
பரிந்துரைகளை உருவாக்கல்: விமான விவரங்கள், ஹோட்டல் முன்பதிவுகள் உள்ளிட்ட தனிப்பட்ட பயண திட்டம் வழங்கல்.
பயனர் கருத்துக்கேட்டல்: பரிந்துரைகள் குறித்து கருத்துக் கேட்டு தேவையான மாற்றங்கள் செய்தல்.

தேவையாகும் வளங்கள்

விமானம் மற்றும் ஹோட்டல் முன்பதிவு தளங்களுக்கான அணுகல்.
பாரிஸின் சுற்றுலா இடங்கள் மற்றும் உணவக தகவல்கள்.
முன்பு ஏற்பட்ட இன்டர்ஐடியாஸ்சன்களின் பயனர் கருத்து தரவு.

அனுபவம் மற்றும் தன்னுணர்வு

பயண ஏஜெண்ட் தன் செயல்திறனை மதிப்பாய்வு செய்து கடந்த அனுபவங்களிலிருந்து கற்றுக்கொள்கிறது. உதாரணமாக:

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

நடைமுறை கண்ணோட்டம் கோடர்படுத்தல்

கீழே பயண ஏஜெண்ட் சேவையில் மேட்டாக்கொக்னிஷன் உள்ளடக்கிய எளிய கோடிங் எடுத்துக்காட்டு உள்ளது:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # தேர்ந்தெடுப்புகளின் அடிப்படையில் எவிடைகளை, ஹோட்டல்களை மற்றும் ஈடுபாடுகளை தேடுக
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # பின்னூட்டத்தை பகுப்பாய்வு செய்து எதிர்கால பரிந்துரைகளை சரிசெய்க
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# உதாரணம் பயன்பாடு
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

மேட்டாக்கொக்னிஷன் முக்கியத்துவம்

தன்னுணர்வு: ஏஜெண்டுகள் தங்கள் செயல்திறனை பகுப்பாய்வு செய்து மேம்படுத்த வேண்டிய பகுதிகளை கண்டுபிடிப்பார்கள்.
தழுவல்திறன்: கருத்துக்களையும் சூழல் மாற்றங்களையும் அடிப்படையாக கொண்டு அங்குதொகைகளை மாற்றக்கூடிய திறன்.
பிழை திருத்தல்: ஏஜெண்டுகள் தானாகவே பிழைகளை கண்டறிந்து சரிசெய்யக் கூடியவை.
வள நிர்வாகம்: நேரம், கணினி சக்தி போன்ற வளங்களை சிறப்பாக பயன்படுத்துதல்.

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

2. ஏஜெண்ட்களில் திட்டமிடல்

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

திட்டமிடல் கூறுகள்

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

உதாரணம்: பயண ஏஜெண்ட் பயணத்தை பயனருக்கு உதவ கூடிய படிகள்:

பயண ஏஜெண்ட் படிகள்

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

உதாரணமாக நடமாடல்

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# ஒரு புக்கிங் கோரிக்கையின் உள்ளே உதாரண பயன்பாடு
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

3. திருத்தும் RAG முறை

முதலில் RAG கருவி மற்றும் முன்னிலை பரிசில் ஏற்றலின் வேறுபாட்டைப் புரிந்துகொள்வோம்

RAG மற்றும் சூழல் ஏற்றல்

மீட்டெடுக்கும் -வானைகூட்டும் தலைமுறை (Retrieval-Augmented Generation - RAG)

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

RAG முறையில், ஏஜெண்ட் அறிவுத் தொகுதியில் இருந்து பொருத்தமான தகவலை மீட்டெடுத்து சீரான பதில்கள் அல்லது நடவடிக்கைகள் உருவாக்க பயன்படுத்துகிறது.

திருத்தும் RAG அணுகுமுறை

திருத்தும் RAG அணுகுமுறை RAG தொழில்நுட்பங்களை பிழைகளை சரி செய்தலும் ஐஏ ஏஜெண்ட்களின் துல்லியத்தை மேம்படுத்தலுக்கும் பயன்படுத்துவதாக உள்ளது. இதன் கூறுகள்:

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

உதாரணம்: தேடல் ஏஜெண்டில் திருத்தும் RAG

வலைத்தளத்திலிருந்து தகவல்களை பெறும் தேடல் ஏஜெண்டை கருதுக. திருத்தும் RAG அணுகுமுறை:

உதிர்செய்தி முறைகள்: பயனர் உள்ளீடுக்கு ஏற்ப தேடல் வினாக்களை உருவாக்குதல்.
கருவிகள்: இயற்கை மொழி செயலாக்கம் மற்றும் இயந்திரக் கற்றல் முறைகளை பயன்படுத்தி தேடல் விளைவுகளை வரிசைப்படுத்துதல் மற்றும் வடிப்புதல்.
மதிப்பீடு: பெறப்பட்ட தகவலில் பிழைகளை கண்டறிந்து திருத்த பயனர் கருத்துக்களை பகுப்பாய்வு செய்தல்.

பயண ஏஜெண்டில் திருத்தும் RAG

திருத்தும் RAG (Retrieval-Augmented Generation) ஐஏ ஆண்டு அதிகாரத்துடன் கூடிய முறையில் தகவல்களை மீட்டெடுத்து உருவாக்குவதோடு பிழைகளை திருத்தவும் பயன்படுத்தப்படுகிறது. பயண ஏஜெண்ட் இதனைப் பயன்படுத்தி மேலும் துல்லியமான பயண பரிந்துரைகளை வழங்கிக் கொள்ளலாம்.

இதில்:

உதிர்செய்தி முறைகள்: பொருத்தமான தகவலை மீட்டெடுப்பதில் ஏஜெண்டை வழிநடத்தும் குறிப்பிட்ட உதிர்செய்திகளைப் பயன்படுத்தல்.
கருவிகள்: மீட்டெடுக்கப்பட்ட தகவலின் பொருத்தத்தை மதிப்பீடு செய்து துல்லியமான பதில்களை உருவாக்கும் முறைகள் இயக்கல்.
மதிப்பீடு: ஏஜெண்டின் செயல்திறனை தொடர்ந்து மதிப்பாய்வு செய்து துல்லியத்தையும் செயல்திறனையும் அதிகரிக்க மாற்றங்களை செய்யல்.

பயண ஏஜெண்டில் திருத்தும் RAG நடைமுறை படிகள்

கடைசி பயனர் தொடர்பு
- பயண இடம், பயண நாட்கள், பட்ஜெட் மற்றும் விருப்பங்கள் போன்ற ஆரம்ப தகவல்களை சேகரிக்கும்.
- உதாரணம்:
```
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
```
தகவல் மீட்டெடுக்கல்
- பயனர் விருப்பங்களின்படி விமானங்கள், தங்குமிடங்கள், சுற்றுலா இடங்கள் மற்றும் உணவகங்களுக்கு தொடர்புடைய தகவலைக் தேடுதல்.
- உதாரணம்:
```
flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
```
அரம்ப பரிந்துரைகள் உருவாக்கல்
- பெறப்பட்ட தகவல்களைப் பயன்படுத்தி தனிப்பட்ட பயண திட்டங்களை உருவாக்குதல்.
- உதாரணம்:
```
itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
```
பயனர் கருத்துக்கள் சேகரித்தல்
- ஆரம்ப பரிந்துரைகளுக்கு பயனர் கருத்துக் கேள்வி.
- உதாரணம்:
```
feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
```
திருத்தும் RAG செயல்முறை
- உதிர்செய்தி முறைகள்: பயனர் கருத்துக்களை வைத்துக் கொண்டு புதிய தேடல் வினாக்களை உருவாக்குதல்.
  - உதாரணம்:
    if "disliked" in feedback: preferences["avoid"] = feedback["disliked"]
- கருவிகள்: பயனர் கருத்தின் அடிப்படையில் புதிய தேடல் விளைவுகளை தரவரிசைப்படுத்த மற்றும் வடிப்பதற்கான கற்றல் முறைகள் மற்றும் ஆல்காரிதங்களை பயன்படுத்தல்.
  - உதாரணம்:
    new_attractions = search_attractions(preferences) new_itinerary = create_itinerary(flights, hotels, new_attractions) print("Updated Itinerary:", new_itinerary)
- மதிப்பீடு: பயனர் கருத்துக்களை பகுப்பாய்வு செய்து பரிந்துரைகளின் பொருத்தத்தையும் துல்லியத்தையும் தொடர்ந்து கண்காணித்து தேவையான திருத்தங்களை செய்யல்.
  - உதாரணம்:
    def adjust_preferences(preferences, feedback): if "liked" in feedback: preferences["favorites"] = feedback["liked"] if "disliked" in feedback: preferences["avoid"] = feedback["disliked"] return preferences preferences = adjust_preferences(preferences, feedback)

நடைமுறை எடுத்துக்காட்டு

கீழே பயண ஏஜெண்டில் திருத்தும் RAG செயல்முறையை இணைத்த உடன்படிக்கையான Python கோட் எடுத்துக்காட்டு உள்ளது:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# உதாரண பயன்பாடு
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

முன்னிலை பரிசில் ஏற்றல்

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

பயண முகவர் பயன்பாட்டிற்கான முன்கூட்டியே சூழல் ஏற்றுதல் எப்படி இருக்கும் என்பதற்கான எளிய எடுத்துக்காட்டு இது:

class TravelAgent:
    def __init__(self):
        # பிரபலமான இடங்கள் மற்றும் அவற்றின் தகவல்களை முன்-ஏற்றுக
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # முன்-ஏற்றிய சூழலிலிருந்து இடத் தகவலைப் பெறுக
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# உதாரண பயன்பாடு
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

விளக்கம்

துவக்கம் (__init__ முறை): TravelAgent வகுப்பு பாரிஸ், டோக்கியோ, நியூயார்க் மற்றும் சிட்னி போன்ற பிரபலமான இடங்களின் தகவல்களை கொண்ட ஒரு அகராதியை முன்கூட்டியே ஏற்றுகிறது. இந்த அகராதி நாட்டை, நாணயத்தை, மொழியை மற்றும் முக்கிய சுற்றுலாத் தலங்களை போன்ற விவரங்களைக் கொண்டுள்ளது.
தகவலை மீட்டெடுப்பது (get_destination_info முறை): பயனர் குறிப்பிட்ட ஒரு இடத்தைக் கேட்டபோது, get_destination_info முறை முன்கூட்டியே ஏற்றப்பட்ட அகராதியிலிருந்து தொடர்புடைய தகவலை பெறுகிறது.

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

திட்டத்தை ஒரு குறிக்கோளுடன் துவங்கி, அதனை முழுமையாக்க iterating செய்வது

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

பயண முகவருக்கான Python மொழியில் குறிக்கோளுடன் திட்டத்தை முதலில் துவங்கி, பிறகு முறையீடு செய்வதற்கான எடுத்துக்காட்டு இதோ:

காட்சி

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

படிகள்

வாடிக்கையாளரின் விருப்பங்கள் மற்றும் பட்ஜெட்டை வரையறுக்கவும்.
இந்த விருப்பங்களின் அடிப்படையில் ஆரம்ப திட்டத்தை உருவாக்கவும்.
திட்டத்தை முறையீட்டு செய்து, வாடிக்கையாளரின் திருப்திக்கு ஏற்ப மேம்படுத்தவும்.

Python குறியீடு

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# எடுத்துக்காட்டு பயன்பாடு
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)

குறியீட்டு விளக்கம்

துவக்கம் (__init__ முறை): TravelAgent வகுப்பு பல சாத்தியமான இடங்களுடன் துவங்குகிறது, ஒவ்வொன்றிலும் பெயர், செலவு மற்றும் செயல்பாட்டு வகை போன்ற பண்புகள் உள்ளன.
திட்டத்தை தொடங்கல் (bootstrap_plan முறை): இந்த முறை வாடிக்கையாளரின் விருப்பங்கள் மற்றும் பட்ஜெட்டை பின்பற்றி ஆரம்ப பயணத் திட்டத்தை உருவாக்குகிறது. இடங்களின் பட்டியலை மாற்றி பார்த்து, வாடிக்கையாளர் விருப்பங்களுடன் ஏற்றுக்கொள்ளும் மற்றும் பட்ஜெட்டுக்குள் இருக்கும் இடங்களைத் திட்டத்தில் சேர்க்கிறது.
விருப்பங்களை பொருந்துதல் (match_preferences முறை): இந்த முறை ஒரு இடம் வாடிக்கையாளர் விருப்பங்களுடன் பொருந்துகிறதா என நிரூபிக்கிறது.
திட்டத்தை முறையீடு செய்தல் (iterate_plan முறை): இந்த முறை ஆரம்ப திட்டத்தை மேம்படுத்தி, திட்டத்தில் உள்ள ஒவ்வொரு இடத்தையும் சிறந்த பொருந்துதலுக்கு மாற்ற முயல்கிறது, வாடிக்கையாளர் விருப்பங்களையும் பட்ஜெட் கட்டுப்பாடுகளையும் கவனத்தில் கொள்கிறது.
செலவைக் கணக்கிடுதல் (calculate_cost முறை): தற்போதைய திட்டத்தின் மொத்த செலவை, புதிய இடத்துடன் சேர்த்து கணக்கிடுகிறது.

உதாரணப் பயன்பாடு

ஆரம்ப திட்டம்: பயண முகவர் வாடிக்கையாளர் சுற்றுலா பார்வைக்கு விருப்பம் மற்றும் $2000 பட்ஜெட்டின் அடிப்படையில் ஆரம்ப திட்டத்தை உருவாக்குகிறார்.
மேம்படுத்தப்பட்ட திட்டம்: பயண முகவர் திட்டத்தை முறையீட்டு செய்து, வாடிக்கையாளர் விருப்பங்கள் மற்றும் பட்ஜெட்டுக்கேற்ப மேம்படுத்துகிறார்.

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

மீண்டும் வரிசைப்படுத்தல் மற்றும் மதிப்பீட்டிற்கு LLM-ஐ பயன்படுத்துதல்

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

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

மீண்டும் வரிசைப்படுத்தல்: LLM அவற்றின் தொடர்பு மற்றும் தரத்தின் அடிப்படையில் மீட்டெடுக்கப்பட்ட பொருட்களை மீண்டும் வரிசைப்படுத்துகிறது. இதனால் மிகவும் தொடர்புடைய மற்றும் தரமுள்ள தகவல்கள் முதலில் காட்சியளிக்கப்படுபவை.

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

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

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

காட்சி - விருப்பங்கள் அடிப்படையில் பயணம்

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

படிகள்:

பயனர் விருப்பங்களை சேகரிக்கவும்.
சாத்தியமான பயண இடங்களின் பட்டியலைப் பெறவும்.
பயனர் விருப்பங்களுக்கு ஏற்ப LLM பயண இடங்களை மீண்டும் வரிசைப்படுத்தி மதிப்பீடு செய்ய பயன்படுத்தவும்.

இதோ முந்தைய எடுத்துக்காட்டை Azure OpenAI சேவைகளைப் பயன்படுத்துமாறு மாற்றுவது:

தேவைகள்

உங்களுக்கு Azure சந்தா இருக்க வேண்டும்.
Azure OpenAI வளத்தை உருவாக்கி உங்கள் API சாவியை பெறுங்கள்.

Python குறியீடு எடுத்துக்காட்டு

import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # Azure OpenAI க்கான ஒரு முன்னோட்டத்தை உருவாக்கவும்
        prompt = self.generate_prompt(preferences)
        
        # கோரிக்கைக்கான தலைப்புகளையும் பயனுள்ள தரவுகளையும் வரையறுக்கவும்
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # மீண்டும் வரிசைப்படுத்தப்பட்ட மற்றும் மதிப்பிடப்பட்ட இடங்களைக் கொண்டு வர Azure OpenAI API ஐ அழைக்கவும்
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # பரிந்துரைகளை எடுக்கவும் மற்றும் மீண்டும் வழங்கவும்
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# எடுத்துக்காட்டு பயன்பாடு
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)

குறியீடு விளக்கம் - விருப்ப புத்தகம்

துவக்கம்: TravelAgent வகுப்பு பெயர் மற்றும் விளக்கத்துடன் பல சாத்தியமான பயண இடங்களின் பட்டியலைத் தொடங்குகிறது.
பரிந்துரைகள் பெறுதல் (get_recommendations முறை): இந்த முறை பயனர் விருப்பத்தைக் கொண்டு Azure OpenAI சேவைக்கான ஒரு பரிந்துரை உத்தாரவு(prompt) உருவாக்கி, HTTP POST கோரிக்கையை Azure OpenAI APIக்கு அனுப்பி மீண்டும் வரிசைப்படுத்தப்பட்ட மற்றும் மதிப்பிடப்பட்ட பயண இடங்களைப் பெறுகிறது.
உத்தாரவு உருவாக்குதல் (generate_prompt முறை): பயனர் விருப்பங்களும் பயண இடங்களின் பட்டியல்களும் அடங்கிய Azure OpenAIக்கு உத்தரவான ஒரு prompt-ஐ உருவாக்குகிறது. இந்த prompt மாதிரியை வழிசெலுத்தி வழங்கப்பட்ட விருப்பங்களைப் பொறுத்து பயண இடங்களை மீண்டும் வரிசைப்படுத்தி மதிப்பிட வைக்கிறது.
API அழைப்பு: requests நூலகம் HTTP POST கோரிக்கையை Azure OpenAI APIக்குத் தரும். பெறப்பட்ட பதில் மீண்டும் வரிசைப்படுத்தப்பட்ட மற்றும் மதிப்பிடப்பட்ட பயண இடங்களைக் கொண்டுள்ளது.
உதாரணப் பயன்பாடு: பயண முகவர் பயனர் விருப்பங்களை (உதாரணமாக, சுற்றுலா பார்வை மற்றும் பல்வகைக் கலாச்சாரம்) சேகரித்து, Azure OpenAI சேவையைப் பயன்படுத்தி மீண்டும் வரிசைப்படுத்தப்பட்ட மற்றும் மதிப்பிடப்பட்ட பரிந்துரைகளைப் பெறுகிறான்.

உங்கள் வ واقعی Azure OpenAI API சாவியாக your_azure_openai_api_key-ஐ மற்றும் உங்கள் Azure OpenAI இயக்கவிலக்கு (deployment) URL-ஐ https://your-endpoint.com/... என்பதுடன் மாற்றவும்.

LLM-ஐ மீண்டும் வரிசைப்படுத்தலும் மதிப்பீட்டும் செய்ய பயன்படுத்தி, பயண முகவர் வாடிக்கையாளர்களுக்கு தனிப்பட்ட மற்றும் தொடர்புடைய பயண பரிந்துரைகளை வழங்கி முழுமையான அனுபவத்தை அதிகரிக்க முடியும்.

RAG: உத்தரவாத முறையா? கருவியா?

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

RAG ஒரு உத்தரவாத முறையாக

இது என்ன?

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

இது எப்படி செயல்படுகிறது:

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

பயண முகவரில் எடுத்துக்காட்டு:

பயனர் உள்ளீடு: “நான் பாரிஷில் அருங்காட்சியகங்களை பார்க்க விரும்புகிறேன்.”
உத்தரவு: “பாரிஷ் நகரில் சிறந்த அருங்காட்சியகங்களை கண்டறி.”
மீட்டெடுக்கப்பட்ட தகவல்: லூர்வ் அருங்காட்சியகம், முகே ஓர்ஸே மற்றும் பிற.
உருவாக்கப்பட்ட பதில்: “பாரிஷ் நகரில் சிறந்த அருங்காட்சியகங்களில் லூர்வ் அருங்காட்சியகம், முகே ஓர்ஸே மற்றும் சென்டர் பொம்பிடு உள்ளன.”

RAG ஒரு கருவியாக

இது என்ன?

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

இது எப்படி செயல்படுகிறது:

ஒதுக்கீடு: AI முகவரின் கட்டமைப்புக்குள் RAG ஒருங்கிணைக்கப்படுவதால், அது தானாகவே மீட்டெடுப்பும் உருவாக்கல்களும் செய்கிறது.
தானாக்காக்கல்: இது பயனர் உள்ளீட்டைக் கொண்டு இறுதிப் பதிலைத் தயாரிக்கும் வரை முழுமையான செயல்பாட்டைக் கட்டுப்படுத்துகிறது, ஒவ்வொரு செயலுக்கும் தனித்தனிப் prompts தேவையில்லை.
திறம்படைத்தன்மை: மீட்டெடுப்பு மற்றும் உருவாக்கல் செயல்முறையை இனிமேல் மிக வேகம், அதிக நுட்பம் கொண்டதாக தலைமை செய்கிறது.

பயண முகவரில் எடுத்துக்காட்டு:

பயனர் உள்ளீடு: “நான் பாரிஷில் அருங்காட்சியகங்களை பார்க்க விரும்புகிறேன்.”
RAG கருவி: தானாக ஆராய்ந்து அருங்காட்சியகங்களை மீட்டெடுத்து, பதிலை உருவாக்குகிறது.
உருவாக்கப்பட்ட பதில்: “பாரிஷ் நகரில் சிறந்த அருங்காட்சியகங்களில் லூர்வ் அருங்காட்சியகம், முகே ஓர்ஸே மற்றும் சென்டர் பொம்பிடு உள்ளன.”

ஒப்பீடு

அம்சம்	உத்தரவாத முறை	கருவி
கைமுறை vs தானாக்	ஒவ்வொரு கேள்விக்கும் கைmatically prompts உருவாக்கல்.	மீட்டெடுக்கும் மற்றும் உருவாக்கும் செயல்முறையை தானாகச் செய்கிறது.
கட்டுப்பாடு	மீட்டெடுப்பு செயல்முறையின் மேலான கட்டுப்பாடு.	மீட்டெடுப்பு மற்றும் உருவாக்கலை சீரமைத்து தானாகச் செய்கிறது.
நெகிழ்வுத்தன்மை	குறிப்பிட்ட தேவைகளுக்கு ஏற்ப தனிப்பயன் உத்தரவுகளை அனுமதிக்கிறது.	பெரிய அளவில் செயல்பாடுகளில் அதிக திறன்.
சிக்கல்	உத்தரவுகளை உருவாக்குதல் மற்றும் சரி பார்தல் தேவையற்றது.	AI முகவரின் கட்டமைப்பில் ஒருங்கிணைக்க எளிது.

நடைமுறை உதாரணங்கள்

உத்தரவாத முறையின் உதாரணம்:

def search_museums_in_paris():
    prompt = "Find top museums in Paris"
    search_results = search_web(prompt)
    return search_results

museums = search_museums_in_paris()
print("Top Museums in Paris:", museums)

கருவியின் உதாரணம்:

class Travel_Agent:
    def __init__(self):
        self.rag_tool = RAGTool()

    def get_museums_in_paris(self):
        user_input = "I want to visit museums in Paris."
        response = self.rag_tool.retrieve_and_generate(user_input)
        return response

travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Top Museums in Paris:", museums)

தொடர்புத்தன்மையை மதிப்பிடுதல்

தொடர்புத்தன்மையை மதிப்பிடுதல் என்பது AI முகவரின் செயல்திறன் açısından முக்கிய அம்சமாகும். இது முகவரால் மீட்டெடுக்கப்படும் மற்றும் உருவாக்கப்படும் தகவல் பயனருக்கு பொருத்தமானது, துல்லியமானது மற்றும் பயன்படக்கூடியதாக இருக்க வேண்டும் என்பதை உறுதிப்படுத்துகிறது. AI முகவர்களில் தொடர்புத்தன்மையை எப்படி மதிப்பிடுவது என்பதை நடைமுறை எடுத்துக்காட்டுகளுடன் பார்க்கலாம்.

தொடர்புத்தன்மையை மதிப்பிடுவதில் முக்கியக் கருத்துக்கள்

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

தொடர்புத்தன்மையை மதிப்பிடும் நடைமுறை முறைகள்

தொடர்பு மதிப்பெண் வழங்கல்:
- மீட்டெடுக்கப்பட்ட ஒவ்வொரு உருப்படியுக்கும், பயனர் கேள்வி மற்றும் விருப்பங்களுக்கு ஏற்ப தொடர்பு மதிப்பெண் வழங்குதல்.
- எடுத்துக்காட்டு:
```
def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score
```
வடிகட்டு மற்றும் வரிசைப்படுத்தல்:
- தொடர்பறிதல் குறைந்த உருப்படிகளை தவிர்த்து மீதமுள்ளவற்றை தொடர்பு மதிப்பெண்களின் அடிப்படையில் வரிசைப்படுத்தல்.
- எடுத்துக்காட்டு:
```
def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # சிறந்த 10 தொடர்புடைய உருப்படிகளை திருப்பிச் செய்
```
பிடிவாத மொழி செயலாக்கம் (NLP):
- பயனர் கேள்வியை புரிந்து கொண்டு தொடர்புடைய தகவலை மீட்டெடுப்பதற்கான NLP முறைகள் பயன்படுத்தல்.
- எடுத்துக்காட்டு:
```
def process_query(query):
    # பயனர் வினவியிலிருந்து முக்கிய தகவல்களை எடுத்தெடுக்க NLP பயன்படுத்தவும்
    processed_query = nlp(query)
    return processed_query
```
பயனர் கருத்துக்கள் இணைப்பு:
- வழங்கப்பட்ட பரிந்துரைகள் மீது பயனர் கருத்துக்களை சேகரித்து, அடுத்தடுத்த தொடர்பு மதிப்பீடுகளை சீரமைக்கவும்.
- எடுத்துக்காடு:
```
def adjust_based_on_feedback(feedback, items):
    for item in items:
        if item['name'] in feedback['liked']:
            item['relevance'] += 1
        if item['name'] in feedback['disliked']:
            item['relevance'] -= 1
    return items
```

எடுத்துக்காட்டு: பயண முகவரில் தொடர்புத்தன்மையை மதிப்பிடுதல்

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

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
        itinerary = create_itinerary(flights, ranked_hotels, attractions)
        return itinerary

    def filter_and_rank(self, items, query):
        ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
        return ranked_items[:10]  # மிக பொருத்தமான மேல் 10 பொருட்களை திருப்பி அனுப்பு

    def relevance_score(self, item, query):
        score = 0
        if item['category'] in query['interests']:
            score += 1
        if item['price'] <= query['budget']:
            score += 1
        if item['location'] == query['destination']:
            score += 1
        return score

    def adjust_based_on_feedback(self, feedback, items):
        for item in items:
            if item['name'] in feedback['liked']:
                item['relevance'] += 1
            if item['name'] in feedback['disliked']:
                item['relevance'] -= 1
        return items

# உதாரணப் பயன்பாடு
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

நோக்கத்துடன் தேடல்

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

நோக்கத்துடன் தேடலில் முக்கியக் கருத்துக்கள்

பயனர் நோக்கம் புரிதல்:
- பயனர் நோக்கத்தை மூன்று முக்கிய வகைகளாக பிரிக்கலாம்: தகவல் தேடும், வழிசெலுத்தல், மற்றும் பரிமாற்றம்.
  - தகவல் நோக்கம்: பயனர் ஒரு பொருளை பற்றிய தகவலைக் கேட்கிறார் (உதா., “பாரிஷ் நகரின் சிறந்த அருங்காட்சியகங்கள் என்ன?”)
  - வழிசெலுத்தல் நோக்கம்: பயனர் ஒரு குறிப்பிட்ட இணையதளத்தோடு அல்லது பக்கத்தோடு செல்ல விரும்புகிறார் (உதா., “லூர்வ் அருங்காட்சியகம் உத்தியோகபூர்வ வலைத்தளம்”).
  - பரிமாற்ற நோக்கம்: பயனர் ஒரு பரிமாற்றம் செய்ய விரும்புகிறார், உதா., விமானத்தை முன்பதிவு செய்தல் (உதா., “பாரிஷுக்கு விமானம் முன்பதிவு செய்”).
சூழல் அறிதல்:
- பயனர் கேள்வியின் சூழலை ஆய்வு செய்து, முந்தைய தொடர்புகள், விருப்பங்கள் மற்றும் தற்போதைய கேள்வியின் விவரங்களை கருத்தில் கொண்டு நோக்கத்தை அடையாளம் காணுகிறது.
பிடிவாத மொழி செயலாக்கம் (NLP):
- இயற்கை மொழி கேள்விகளை புரிந்து, உருப்படிகளை அடையாளம் காண்மதி, உணர்வு பகுப்பு மற்றும் கேள்வி பாகுபாடு போன்ற செயல்முறைகளை செய்தல்.
தனிப்பயனாக்கல்:
- பயனர் வரலாறு, விருப்பங்கள் மற்றும் கருத்துக்களின் அடிப்படையில் தேடல் முடிவுகளை தனிப்பயனாக்கல், தொடர்புத்தன்மையை மேம்படுத்துதல்.

நடைமுறை எடுத்துக்காட்டு: பயண முகவரில் நோக்கத்துடன் தேடல்

பயண முகவர் எடுத்துக்காட்டை கொண்டு நோக்கத்துடன் தேடல் எப்படிச் செய்யப்படுகின்றது பார்க்கலாம்.

பயனர் விருப்பங்கள் சேகரித்தல்

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

பயனர் நோக்கம் புரிந்துகொள்ளுதல்

def identify_intent(query):
    if "book" in query or "purchase" in query:
        return "transactional"
    elif "website" in query or "official" in query:
        return "navigational"
    else:
        return "informational"

சூழல் அறிதல்

def analyze_context(query, user_history):
    # தற்போதைய கேள்வியை பயனர் வரலாற்றுடன் கூட்டி சூழலைப் புரிந்து கொள்ளுங்கள்
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

தேடல் மற்றும் முடிவுகளை தனிப்பயனாக்குதல்

def search_with_intent(query, preferences, user_history):
    intent = identify_intent(query)
    context = analyze_context(query, user_history)
    if intent == "informational":
        search_results = search_information(query, preferences)
    elif intent == "navigational":
        search_results = search_navigation(query)
    elif intent == "transactional":
        search_results = search_transaction(query, preferences)
    personalized_results = personalize_results(search_results, user_history)
    return personalized_results

def search_information(query, preferences):
    # தகவல் நோக்கத்திற்கான உதாரண தேடல் lógica
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # வழிசெலுத்தும் நோக்கத்திற்கான உதாரண தேடல் lógica
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # பரிவர்த்தனை நோக்கத்திற்கான உதாரண தேடல் lógica
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # உதாரண தனிப்பட்டாக்க lógica
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # சிறந்த 10 தனிப்பட்ட முடிவுகளை வழங்கு

** உதாரணப் பயன்பாடு**

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
user_history = ["Louvre Museum website", "Book flight to Paris"]
query = "best museums in Paris"
results = search_with_intent(query, preferences, user_history)
print("Search Results:", results)

4. கருவியாகக் குறியீடு உருவாக்கல்

குறியீடு உருவாக்கும் முகவர்கள் எஐ மாதிரிகளைப் பயன்படுத்தி குறியீட்டை எழுதுவதும் இயக்குவதும் மூலம் சிக்கலான பிரச்சனைகளை தீர்க்கவும் பணிகளை தானாகச் செய்யவும் செய்கிறார்கள்.

குறியீடு உருவாக்கும் முகவர்கள்

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

நடைமுறை பயன்பாடுகள்

தானாக குறியீடு உருவாக்குதல்: தரவு பகுப்பாய்வு, வலைத் தரவு சேகரிப்பு அல்லது மெஷின் கற்றல் போன்ற குறிப்பிட்ட பணிகளுக்கு குறியீட்டு துண்டுகளை உருவாக்குதல்.
SQL ஐ RAG ஆக பயன்படுத்துதல்: தரவுத்தளங்களிலிருந்து தரவை மீட்டெடுத்து மாற்ற SQL வினவல்களைப் பயன்படுத்துதல்.
பிரச்சனைகள் தீர்க்கல்: குறிப்பிட்ட பிரச்சனைகளை தீர்க்க குறியீட்டை உருவாக்கி இயக்குதல், உதா: அல்காரிதம்களை மேம்படுத்துதல் அல்லது தரவுகளை பகுப்பாய்வு செய்தல்.

உதாரணம்: தரவு பகுப்பாய்விற்கான குறியீடு உருவாக்கும் முகவர்

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

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

உதாரணம்: பயண முகவர்க்கு குறியீடு உருவாக்கும் முகவர்

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

குறியீடு உருவாக்கும் முகவரின் கண்ணோட்டம்

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

படி படி செயல்பாடு

பயனர் விருப்பங்களை சேகரித்தல்

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

தரவு பெறக் குறியீடு உருவாக்குதல்

def generate_code_to_fetch_data(preferences):
    # உதாரணம்: பயனர் விருப்பங்களின் அடிப்படையில் விமானங்களைத் தேட கோடுகள் உருவாக்கவும்
    code = f"""
    def search_flights():
        import requests
        response = requests.get('https://api.example.com/flights', params={preferences})
        return response.json()
    """
    return code

def generate_code_to_fetch_hotels(preferences):
    # உதாரணம்: ஹோட்டல்களைத் தேடக் கோடுகள் உருவாக்கவும்
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

உருவாக்கிய குறியீட்டை இயக்குதல்

def execute_code(code):
    # exec பயன்படுத்தி உருவாக்கப்பட்ட குறியீட்டை இயக்கவும்
    exec(code)
    result = locals()
    return result

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
   
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
   
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)

print("Flight Options:", flights)
print("Hotel Options:", hotels)

பயண திட்டம் உருவாக்குதல்

def generate_itinerary(flights, hotels, attractions):
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

attractions = search_attractions(preferences)
itinerary = generate_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

பின்காணுதல் அடிப்படையில் திருத்தம்

def adjust_based_on_feedback(feedback, preferences):
    # பயனர் பின்னூட்டத்தை உத்தரவிட்டு விருப்பங்களை சரிசெய்க
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
   
# புதுப்பிக்கப்பட்ட விருப்பங்களுடன் குறியீட்டை மீண்டும் உருவாக்கி இயக்குக
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
   
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
   
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

சுற்றுப்புற அறிவும் காரணவியலும் பயன்படுத்துதல்

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

இதை எப்படி செய்யலாம் என்ற ஒரு உதாரணம் இங்கே:

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

இந்தக் கருத்துக்களைச் சேர்த்துள்ள புதுப்பிக்கப்பட்ட Python குறியீடு உதாரணம் இங்கே:

def adjust_based_on_feedback(feedback, preferences, schema):
    # பயனர் பின்னூட்டத்தின் அடிப்படையில் முன்னுரிமைகளை சரிசெய்யவும்
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # மற்ற தொடர்புடைய முன்னுரிமைகளை சரிசெய்வதற்கு ஸ்கீமாவைப் பயன்படுத்தி காரணமாற்றம்
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # ஸ்கீமா மற்றும் பின்னூட்டத்தின் அடிப்படையில் முன்னுரிமைகளை சரிசெய்வத 위한 தனிப்பயன் லாஜிக்
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # புதுப்பிக்கப்பட்ட முன்னுரிமைகளின் அடிப்படையில் விமான தரவை வேண்டுகோள் செய்ய குறியீட்டை உருவாக்கவும்
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # புதுப்பிக்கப்பட்ட முன்னுரிமைகளின் அடிப்படையில் ஹோட்டல் தரவை வேண்டுகோள் செய்ய குறியீட்டை உருவாக்கவும்
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # குறியீட்டை சிமுலேட் செய்து மொக் தரவை மீட்டெடுக்கவும்
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # விமானங்கள், ஹோட்டல்கள் மற்றும் கவர்ச்சிகளின் அடிப்படையில் பயண திட்டத்தை உருவாக்கவும்
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# உதாரண ஸ்கீமா
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# உதாரணப் பயன்பாடு
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# புதுப்பிக்கப்பட்ட முன்னுரிமைகளுடன் குறியீட்டை மீளுருவாக்கி இயக்கவும்
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

وضاح - கருத்துக்களை பின்பற்றி துவக்கம் செய்வது

அமைப்புக் கருத்து: schema அகராதி பின்காணுதலின் அடிப்படையில் விருப்பங்களை எவ்வாறு திருத்த வேண்டும் என்பதைக் குறிப்பிடுகிறது. இதில் favorites மற்றும் avoid போன்ற புலங்களும் அவற்றின் மாற்றங்களும் உள்ளன.
விருப்பங்களை திருத்துதல் (adjust_based_on_feedback முறை): இந்த முறை பயனர் பின்காணுதலின் அடிப்படையில் விருப்பங்களை திருத்தும்.
சுற்றுப்புற அடிப்படையிலான திருத்தங்கள் (adjust_based_on_environment முறை): அமைப்பு மற்றும் பின்காணுதலை கருத்தில் கொண்டு திருத்தங்களை தனிப்பயனாக்கும் முறை.
வினவல்களை உருவாக்கி இயக்குதல்: மாற்றப்பட்ட விருப்பங்களை அடிப்படையாக கொண்டு புதிய விமானம் மற்றும் ஹோட்டல் தரவைப் பெற வினவல்களை உருவாக்கி அதை இயக்குகிற சிஸ்டம்.
பயண திட்டம் உருவாக்குதல்: புதிய விமானம், ஹோட்டல் மற்றும் இடங்கள் பற்றிய தரவுகளின் அடிப்படையில் புதுப்பிக்கப்பட்ட பயணத் திட்டத்தை உருவாக்கும்.

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

SQL ஐ Retrieval-Augmented Generation (RAG) முறையாக பயன்படுத்துதல்

SQL (Structured Query Language) என்பது தரவுத்தளங்களுக்கு இடையிலான ஊடாடலை மேற்கொள்ளும் சக்திவாய்ந்த கருவி. Retrieval-Augmented Generation (RAG) முறையின் ஒரு பகுதியாக பயன்படும் போது, SQL தரவுத்தளங்களில் இருந்து பொருத்தமான தகவல்களை மீட்டெடுத்து AI முகவர்களின் பதில்கள் அல்லது செயற்பாடுகளை உருவாக்க உதவுகிறது. பயண முகவர் சூழலில் SQL RAG முறையாக எவ்வாறு பயன்படுத்தப்படும் என்பதை இங்கே பார்ப்போம்.

முக்கியக் கருத்துக்கள்

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

பயன்பாடுகள்

தானாக குறியீடு உருவாக்குதல்: குறிப்பிட்ட பணிகளுக்கான குறியீட்டு துண்டுகளை உருவாக்குதல்.
SQL ஐ RAG ஆக: SQL வினவல்களைப் பயன்படுத்தி தரவை மாற்றுதல்.
பிரச்சனைகள் தீர்க்கல்: பிரச்சனைகளை தீர்க்க குறியீட்டை உருவாக்கி இயக்குதல்.

உதாரணம்: ஒரு தரவு பகுப்பாய்வு முகவர்:

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

நடைமுறை உதாரணம்: பயண முகவரில் SQL பயன்படுத்துதல்

பயனர் விருப்பங்களை சேகரித்தல்

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

SQL வினவல்கள் உருவாக்கல்

def generate_sql_query(table, preferences):
    query = f"SELECT * FROM {table} WHERE "
    conditions = []
    for key, value in preferences.items():
        conditions.append(f"{key}='{value}'")
    query += " AND ".join(conditions)
    return query

SQL வினவல்களை இயக்குதல்

import sqlite3

def execute_sql_query(query, database="travel.db"):
    connection = sqlite3.connect(database)
    cursor = connection.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    connection.close()
    return results

பரிந்துரைகள் உருவாக்குதல்

def generate_recommendations(preferences):
    flight_query = generate_sql_query("flights", preferences)
    hotel_query = generate_sql_query("hotels", preferences)
    attraction_query = generate_sql_query("attractions", preferences)
       
    flights = execute_sql_query(flight_query)
    hotels = execute_sql_query(hotel_query)
    attractions = execute_sql_query(attraction_query)
       
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = generate_recommendations(preferences)
print("Suggested Itinerary:", itinerary)

உதாரண SQL வினவல்கள்

விமான வினவல்

SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

ஹோட்டல் வினவல்

SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

புகழ்பெற்ற இடங்களுக்கான வினவல்

SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

SQL ஐ Retrieval-Augmented Generation (RAG) முறையின் ஒரு பகுதியாக பயன்படுத்துவதன் மூலம், பயண முகவரைக் போன்ற AI முகவர்கள் தொடர்புடைய தரவுகளை உயிரோட்டமான முறையில் மீட்டெடுத்து சரியான மற்றும் தனிப்பயனாக்கப்பட்ட பரிந்துரைகளை வழங்க முடியும்.

மெட்டாக்கொக்னிஷன் உதாரணம்

எனவே மெட்டாக்கொக்னிஷன் செயல்பாட்டின் ஒரு செயல்பாட்டை காட்டுவதற்காக, ஒரு எளிய முகவரைக் கட்டமைப்போம், இது ஒரு பிரச்சனையைத் தீர்க்கும் போது தன் தீர்மான முறைமையைப் பிரதிபலிக்கிறது. இந்த உதாரணத்தில், ஒரு ஹோட்டல் தொடர்ந்தது ஒரு முகவர் தேர்வை 최적화 செய்ய முயலப்பர், அதன் எண்ணத்தை மதிப்பாய்வு செய்து பிழைகள் அல்லது குறைந்த தரமான தேர்வுகள் வந்தால் தன் செயல்பாட்டை திருத்தும்.

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

மெட்டாக்கொக்னிஷனை இவ்வாறு விளக்குகிறது:

துவக்கம் முடிவு: முகவர் மல்ட்டியான ஹோட்டலை தேர்ந்தெடுக்கும், தரத்தின் தாக்கம் புரியாமல்.
பிரதிபலிப்பு மற்றும் மதிப்பாய்வு: துவக்கம் முடிவுக்குப் பிறகு, முகவர் பயனர் கருத்துகளைப் பெற்றுக் கொண்டு ஹோட்டல் “மோசமான”தேர்வு என்பதைக் கணக்கிடும். தெரியவந்தால் அது தன் ஞானத்தை பிரதிபலிக்கும்.
திட்டத்தை மாற்றுதல்: பிரதிபலிப்பின் அடிப்படையில் முகவர் தன் திட்டத்தை மாற்றி “சிக்கனமான”தேர்விலிருந்து “அதிக தரம்” கொண்டதாக மாறி எதிர்கால தீர்மானத்தை மேம்படுத்தும்.

ஒரு உதாரணம் இங்கே:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # முன்னதாக தேர்ந்தெடுக்கப்பட்ட ஹோட்டல்களை சேமிக்கிறது
        self.corrected_choices = []  # திருத்தப்பட்ட தேர்வுகளைச் சேமிக்கிறது
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # கிடைக்கும் உத்திகள்

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # கடந்த தேர்வு நன்று என இல்லையென உபயோகப்படுத்துனர் கருத்து நாம் பெற்றுள்ளோம் என்று நினைத்துக்கொள்வோம்
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # கடந்த தேர்வு திருப்திகரமாக இருந்தால் உத்தியை சரிசெய்யவும்
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# ஹோட்டல்களின் பட்டியலை பைர்ஸ் மற்றும் தரம் உடன் மையப்படுத்து
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# ஒரு முகவரை உருவாக்கவும்
agent = HotelRecommendationAgent()

# படி 1: முகவர் "சமீபத்திய" உத்தியைப் பயன்படுத்தி ஒரு ஹோட்டலை பரிந்துரைக்கிறார்
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# படி 2: முகவர் தேர்வை பரிசீலித்து, தேவையானால் உத்தியை சரிசெய்க
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# படி 3: முகவர் மீண்டும் பரிந்துரைக்கிறார், இந்த முறை சரிசெய்யப்பட்ட உத்தியை பயன்படுத்தி
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

முகவர்களின் மெட்டாக்கொக்னிஷன் திறன்கள்

முக்கியமானது முகவரின் திறன்:

தன் முன்னைய தேர்வுகளையும் தீர்மான செயல்முறையையும் மதிப்பிடுதல்.
அந்த பிரதிபலிப்பின் அடிப்படையில் தன் திட்டத்தைக் திருத்துவது. அதாவது செயல்பாட்டுப் பிரதிபலிப்பு.

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

முடிவு

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

மெட்டாக்கொக்னிஷன் வடிவமைப்பு முறையைப் பற்றி கூடுதலாக கேள்விகள் உள்ளதா?

Microsoft Foundry Discord உடன் இணையவும் மற்ற கற்றலாளர்களுடன் சந்திக்கவும், அலுவலக நேரங்களில் கலந்துகொள்ளவும், மற்றும் உங்கள் AI முகவர்கள் தொடர்பான கேள்விகளை தீர்க்கவும்.

முந்தைய பாடம்

பல்வேறு முகவர் வடிவமைப்பு முறை

அடுத்த பாடம்

தயாரிப்பில் AI முகவர்கள்

மறுப்பு: இந்த ஆவணம் AI மொழிபெயர்ப்பு சேவை Co-op Translator பயன்படுத்தி மொழிபெயர்க்கப்பட்டுள்ளது. நாங்கள் துல்லியத்திற்காக முயற்சி செய்துள்ளோம், ஆனால் தானாக செய்யப்படும் மொழிபெயர்ப்புகளில் பிழைகள் அல்லது தவறுகள் இருக்கலாம் என்பதை கவனத்தில் கொள்ளவும். அசல் ஆவணம் அதன் தாய்மொழியில் அதிகாரப்பூர்வ ஆதாரமாக கருதப்பட வேண்டும். முக்கியமான தகவல்களுக்கு, தொழில்நுட்பமான மனித மொழிபெயர்ப்பு பரிந்துரைக்கப்படுகிறது. இந்த மொழிபெயர்ப்பைப் பயன்படுத்துவதால் ஏற்படும் எந்த தவறான புரிதல்கள் அல்லது தவறான விளக்கத்திற்கும் நாங்கள் பொறுப்பில்வில்லை.

This site is open source. Improve this page.