சங்கிலிகள் ஒரு LLM அழைப்புக்கு மட்டும் வேலை செய்யாது; அவை எல்எல்எம் அல்லது மற்றொரு பயன்பாட்டிற்கான அழைப்புகளின் தொகுப்புகள். பரவலாகப் பயன்படுத்தப்படும் பயன்பாடுகளுக்கான எண்ட்-டு-எண்ட் சங்கிலிகள் நிலையான செயின் API மற்றும் பல கருவி ஒருங்கிணைப்புகளுடன் LangChain ஆல் வழங்கப்படுகின்றன.
பயனர் உள்ளீட்டை ஏற்று, PromptTemplate ஐப் பயன்படுத்தி அதை அமைத்து, பின்னர் உருவாக்கப்பட்ட முடிவை LLMக்கு வழங்கும் ஒரு சங்கிலியை வடிவமைக்க விரும்பினால், பல உறுப்புகளை ஒரே உட்பொருளில் இணைக்கும் நெகிழ்வுத்தன்மையும் திறனும் பயனுள்ளதாக இருக்கும்.
Python இல் LangChain LLMchain செயல்பாட்டின் பயன்பாட்டைப் புரிந்துகொள்ள இந்தக் கட்டுரை உங்களுக்கு உதவுகிறது.
எடுத்துக்காட்டு: LangChain இல் LLMchain Fuction ஐ எவ்வாறு பயன்படுத்துவது
சங்கிலிகள் என்றால் என்ன என்பதைப் பற்றி பேசினோம். இப்போது, பைதான் ஸ்கிரிப்ட்டில் செயல்படுத்தப்படும் இந்த சங்கிலிகளின் நடைமுறை விளக்கத்தைக் காண்போம். இந்த எடுத்துக்காட்டில், LLMchain என்ற மிக அடிப்படையான LangChain சங்கிலியைப் பயன்படுத்துகிறோம். இது ஒரு ப்ராம்ப்ட் டெம்ப்ளேட் மற்றும் ஒரு எல்எல்எம் ஆகியவற்றைக் கொண்டுள்ளது மற்றும் வெளியீட்டை உருவாக்க அவற்றை ஒன்றாக இணைக்கிறது.
கருத்தை செயல்படுத்தத் தொடங்க, பைதான் நிலையான நூலகத்தில் சேர்க்கப்படாத சில தேவையான நூலகங்களை நிறுவ வேண்டும். நாம் நிறுவ வேண்டிய நூலகங்கள் LangChain மற்றும் OpenAI ஆகும். LangChain நூலகத்தை நிறுவுகிறோம், ஏனெனில் அதன் LLMchain தொகுதி மற்றும் PromptTemplate ஐப் பயன்படுத்த வேண்டும். OpenAI நூலகம், வெளியீடுகளைக் கணிக்க OpenAI இன் மாதிரிகளைப் பயன்படுத்த அனுமதிக்கிறது, அதாவது GPT-3.
LangChain நூலகத்தை நிறுவ, பின்வரும் கட்டளையை முனையத்தில் இயக்கவும்:
$ pip langchain நிறுவவும்பின்வரும் கட்டளையுடன் OpenAI நூலகத்தை நிறுவவும்:
$ பிப் நிறுவு openai
நிறுவல்கள் முடிந்ததும், முக்கிய திட்டத்தில் வேலை செய்ய ஆரம்பிக்கலாம்.
இருந்து லாங்செயின். தூண்டுகிறது இறக்குமதி PromptTemplateஇருந்து லாங்செயின். llms இறக்குமதி OpenAI
இறக்குமதி நீ
நீ . தோராயமாக [ 'OPENAI_API_KEY' ] = 'sk-உங்கள் API விசை'
தேவையான தொகுதிகளை இறக்குமதி செய்வதன் மூலம் முக்கிய திட்டம் தொடங்குகிறது. எனவே, முதலில் 'langchain.prompts' நூலகத்திலிருந்து PromptTemplate ஐ இறக்குமதி செய்கிறோம். பின்னர், 'langchain.llms' நூலகத்திலிருந்து OpenAI ஐ இறக்குமதி செய்கிறோம். அடுத்து, சூழல் மாறியை அமைக்க “os” ஐ இறக்குமதி செய்கிறோம்.
ஆரம்பத்தில், OpenAI API விசையை சூழல் மாறியாக அமைத்தோம். சூழல் மாறி என்பது ஒரு பெயர் மற்றும் மதிப்பை உள்ளடக்கிய ஒரு மாறியாகும், இது நமது இயக்க முறைமையில் அமைக்கப்பட்டுள்ளது. 'os.environ' என்பது சூழல் மாறிகளை வரைபடமாக்கப் பயன்படும் ஒரு பொருளாகும். எனவே, நாம் 'os.environ' என்று அழைக்கிறோம். API விசைக்கு நாங்கள் அமைத்த பெயர் OPENAI_API_KEY. அதன்பின் API விசையை அதன் மதிப்பாக ஒதுக்குவோம். API விசை ஒவ்வொரு பயனருக்கும் தனிப்பட்டது. எனவே, நீங்கள் இந்த குறியீடு ஸ்கிரிப்டைப் பயிற்சி செய்யும்போது, உங்கள் ரகசிய API விசையை எழுதவும்.
llm = OpenAI ( வெப்ப நிலை = 0.9 )உடனடியாக = PromptTemplate (
உள்ளீடு_மாறிகள் = [ 'தயாரிப்புகள்' ] ,
டெம்ப்ளேட் = '{பொருட்களை} விற்கும் பிராண்டிற்கு என்ன பெயரிடப்படும்?' ,
)
இப்போது விசை சூழல் மாறியாக அமைக்கப்பட்டுள்ளது, நாம் ஒரு ரேப்பரை துவக்குகிறோம். OpenAI GPT மாடல்களுக்கான வெப்பநிலையை அமைக்கவும். வெப்பநிலை என்பது ஒரு குணாதிசயமாகும், இது எதிர்வினை எவ்வளவு எதிர்பாராததாக இருக்கும் என்பதை தீர்மானிக்க உதவுகிறது. அதிக வெப்பநிலை மதிப்பு, பதில்கள் மிகவும் ஒழுங்கற்றவை. இங்கே வெப்பநிலை மதிப்பை 0.9 ஆக அமைத்துள்ளோம். இதனால், நாம் மிகவும் சீரற்ற முடிவுகளைப் பெறுகிறோம்.
பின்னர், ஒரு PromptTemplate வகுப்பை துவக்குகிறோம். நாம் LLM ஐப் பயன்படுத்தும் போது, பயனரிடமிருந்து எடுக்கப்பட்ட உள்ளீட்டில் இருந்து ஒரு ப்ராம்ட்டை உருவாக்கி, LLMக்கு நேரடியாக உள்ளீட்டை அனுப்புவதற்குப் பதிலாக, கடின குறியீட்டு முறை தேவைப்படும் (ஒரு வரியில் இருந்து நாம் எடுத்த உள்ளீடு ஆகும். பயனர் மற்றும் வரையறுக்கப்பட்ட AI மாதிரி ஒரு பதிலை உருவாக்க வேண்டும்). எனவே, நாங்கள் PromptTemplate ஐ துவக்குகிறோம். பின்னர், அதன் சுருள் பிரேஸ்களுக்குள், உள்ளீடு_மாறியை “தயாரிப்புகள்” என வரையறுக்கிறோம் மற்றும் டெம்ப்ளேட் உரையானது “{products} விற்கும் ஒரு பிராண்டிற்கு என்ன பெயரிடப்படும்?” என்பதாகும். பயனர் உள்ளீடு பிராண்ட் என்ன செய்கிறது என்பதைக் கூறுகிறது. பின்னர், இந்த தகவலின் அடிப்படையில் இது வரிவடிவத்தை வடிவமைக்கிறது.
இருந்து லாங்செயின். சங்கிலிகள் இறக்குமதி எல்எல்எம்செயின்சங்கிலி = எல்எல்எம்செயின் ( llm = llm , உடனடியாக = உடனடியாக )
இப்போது எங்கள் PromptTemplate வடிவமைக்கப்பட்டுள்ளது, அடுத்த படியாக LLMchain ஐ உருவாக்க வேண்டும். முதலில், 'langchain.chain' நூலகத்திலிருந்து LLMchain தொகுதியை இறக்குமதி செய்யவும். பின்னர், LLMchain() செயல்பாட்டை அழைப்பதன் மூலம் நாம் ஒரு சங்கிலியை உருவாக்குகிறோம், இது பயனர் உள்ளீட்டை எடுத்து அதன் மூலம் ப்ராம்ட்டை வடிவமைக்கிறது. கடைசியாக, அது LLM க்கு பதிலை அனுப்புகிறது. எனவே, இது PromptTemplate மற்றும் LLM ஐ இணைக்கிறது.
அச்சு ( சங்கிலி. ஓடு ( 'கலை பொருட்கள்' ) )சங்கிலியை இயக்க, நாம் chain.run() முறையை அழைக்கிறோம் மற்றும் பயனர் உள்ளீட்டை அளவுருவாக வழங்குகிறோம், இது 'கலை பொருட்கள்' என வரையறுக்கப்படுகிறது. பின்னர், பைதான் கன்சோலில் கணிக்கப்பட்ட முடிவைக் காண்பிக்க இந்த முறையை பைதான் பிரிண்ட்() செயல்பாட்டிற்கு அனுப்புகிறோம்.
AI மாதிரியானது ப்ராம்ட்டைப் படித்து அதன் அடிப்படையில் பதிலைச் செய்கிறது.
கலைப் பொருட்களை விற்கும் பிராண்டிற்குப் பெயரிடுமாறு நாங்கள் கேட்டதால், AI மாதிரியால் கணிக்கப்பட்ட பெயரை பின்வரும் ஸ்னாப்ஷாட்டில் காணலாம்:
ஒற்றை உள்ளீட்டு மாறி வழங்கப்படும் போது இந்த எடுத்துக்காட்டு LLMchaining ஐக் காட்டுகிறது. பல மாறிகளைப் பயன்படுத்தும் போது இதுவும் சாத்தியமாகும். அதற்கு, மாறிகளின் அகராதியை உருவாக்கி அவற்றை முழுவதுமாக உள்ளிட வேண்டும். இது எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்:
இருந்து லாங்செயின். தூண்டுகிறது இறக்குமதி PromptTemplateஇருந்து லாங்செயின். llms இறக்குமதி OpenAI
இறக்குமதி நீ
நீ . தோராயமாக [ 'OPENAI_API_KEY' ] = 'sk- Your-API-KEY'
llm = OpenAI(வெப்பநிலை=0.9)
prompt = PromptTemplate(
input_variables=[' பிராண்ட் ',' தயாரிப்பு '],
டெம்ப்ளேட்=' என்ன பெயர் இருக்கும் { பிராண்ட் } என்று விற்கிறது { தயாரிப்பு } ? ',
)
langchain.chains இலிருந்து LLMCchain ஐ இறக்குமதி செய்கிறது
சங்கிலி = LLMCchain(llm=llm, prompt=prompt)
அச்சு(chain.run({
'பிராண்ட்': ' கலை பொருட்கள் ',
'தயாரிப்பு': ' வண்ணங்கள் '
}))
ப்ராம்ட் டெம்ப்ளேட் வகுப்பில் இரண்டு மாறிகளை அனுப்ப வேண்டும் என்பதைத் தவிர, குறியீடு முந்தைய உதாரணத்தைப் போலவே செல்கிறது. எனவே, input_variables அகராதியை உருவாக்கவும். நீண்ட அடைப்புக்குறிகள் அகராதியைக் குறிக்கும். இங்கே, எங்களிடம் இரண்டு மாறிகள் உள்ளன - 'பிராண்ட்' மற்றும் 'தயாரிப்பு' - அவை கமாவால் பிரிக்கப்படுகின்றன. இப்போது, நாங்கள் வழங்கும் டெம்ப்ளேட் உரை '{Product} விற்கும் {பிராண்டின்} பெயர் என்ன?' எனவே, AI மாதிரியானது இந்த இரண்டு உள்ளீட்டு மாறிகள் மீது கவனம் செலுத்தும் பெயரைக் கணித்துள்ளது.
பின்னர், LLMக்கு பதிலை அனுப்பும் ப்ராம்ட் மூலம் பயனர் உள்ளீட்டை வடிவமைக்கும் LLMchain ஐ உருவாக்குகிறோம். இந்தச் சங்கிலியை இயக்க, chain.run()முறையைப் பயன்படுத்துகிறோம், மேலும் பயனர் உள்ளீட்டுடன் மாறிகளின் அகராதியை “பிராண்ட்”: “கலைப் பொருட்கள்” மற்றும் “தயாரிப்பு” என்பதை “நிறங்கள்” என அனுப்புகிறோம். பின்னர், பெறப்பட்ட பதிலைக் காண்பிக்க இந்த முறையை பைதான் பிரிண்ட்() செயல்பாட்டிற்கு அனுப்புகிறோம்.
வெளியீட்டுப் படம் கணிக்கப்பட்ட முடிவைக் காட்டுகிறது:
முடிவுரை
சங்கிலிகள் லாங்செயினின் கட்டுமானத் தொகுதிகள். இந்த கட்டுரை LangChain இல் LLMchain ஐப் பயன்படுத்துவதற்கான கருத்தாக்கத்தின் வழியாக செல்கிறது. LLMchainக்கு ஒரு அறிமுகம் செய்து, அவர்களை பைதான் திட்டத்தில் பணியமர்த்த வேண்டியதன் அவசியத்தை சித்தரித்தோம். பின்னர், PromptTemplate மற்றும் LLM ஐ இணைப்பதன் மூலம் LLMchain செயல்படுத்தப்படுவதை நிரூபிக்கும் ஒரு நடைமுறை விளக்கத்தை நாங்கள் மேற்கொண்டோம். நீங்கள் இந்த சங்கிலிகளை ஒரு உள்ளீட்டு மாறி மற்றும் பல பயனர் வழங்கிய மாறிகள் மூலம் உருவாக்கலாம். GPT மாதிரியிலிருந்து உருவாக்கப்பட்ட பதில்களும் வழங்கப்பட்டுள்ளன.