Ang mga chain ay hindi gumagana lamang para sa isang tawag sa LLM; ang mga ito ay mga koleksyon ng mga tawag, alinman sa isang LLM o ibang utility. Ang mga end-to-end na chain para sa malawakang ginagamit na mga application ay ibinibigay ng LangChain kasama ang isang karaniwang chain API at maraming mga pagsasama-sama ng tool.
Maaaring maging kapaki-pakinabang ang flexibility at kakayahang mag-link ng maraming elemento sa isang entity kapag gusto naming magdisenyo ng chain na tumatanggap ng input ng user, i-set up ito gamit ang PromptTemplate, at pagkatapos ay ihatid ang nabuong resulta sa isang LLM.
Tinutulungan ka ng artikulong ito na maunawaan ang paggamit ng isang function ng LangChain LLMchain sa Python.
Halimbawa: Paano Gamitin ang LLMchain Fuction sa LangChain
Napag-usapan namin kung ano ang mga kadena. Ngayon, makikita natin ang isang praktikal na pagpapakita ng mga chain na ito na ipinatupad sa isang script ng Python. Sa halimbawang ito, ginagamit namin ang pinakapangunahing LangChain chain na LLMchain. Naglalaman ito ng isang PromptTemplate at isang LLM, at pinagsama ang mga ito upang makabuo ng isang output.
Upang simulan ang pagpapatupad ng konsepto, kailangan nating mag-install ng ilang kinakailangang library na hindi kasama sa Python standard library. Ang mga aklatan na kailangan naming i-install ay LangChain at OpenAI. Ini-install namin ang library ng LangChain dahil kailangan naming gamitin ang module ng LLMchain nito pati na rin ang PromptTemplate. Hinahayaan kami ng OpenAI library na gamitin ang mga modelo ng OpenAI para mahulaan ang mga output, ibig sabihin, GPT-3.
Upang i-install ang LangChain library, patakbuhin ang sumusunod na command sa terminal:
$ pip install langchainI-install ang OpenAI library gamit ang sumusunod na command:
$ pip install openai
Kapag kumpleto na ang mga pag-install, maaari na tayong magsimulang magtrabaho sa pangunahing proyekto.
mula sa langchain. mga senyales angkat PromptTemplatemula sa langchain. llms angkat OpenAI
angkat ikaw
ikaw . humigit-kumulang [ 'OPENAI_API_KEY' ] = 'sk-YOUR API KEY'
Ang pangunahing proyekto ay nagsisimula sa pamamagitan ng pag-import ng mga kinakailangang module. Kaya, ini-import muna namin ang PromptTemplate mula sa 'langchain.prompts' library. Pagkatapos, ini-import namin ang OpenAI mula sa 'langchain.llms' library. Susunod, ini-import namin ang 'os' upang itakda ang variable ng kapaligiran.
Sa una, itinakda namin ang OpenAI API key bilang variable ng kapaligiran. Ang environment variable ay isang variable na binubuo ng isang pangalan at isang value at nakatakda sa aming operating system. Ang 'os.environ' ay isang bagay na ginagamit upang i-map ang mga variable ng kapaligiran. Kaya, tinatawag namin ang 'os.environ'. Ang pangalan na itinakda namin para sa API key ay OPENAI_API_KEY. Pagkatapos ay itinalaga namin ang API key bilang halaga nito. Ang API key ay natatangi para sa bawat user. Kaya, kapag sinasanay mo ang code script na ito, isulat ang iyong lihim na API key.
llm = OpenAI ( temperatura = 0.9 )prompt = PromptTemplate (
input_variables = [ 'mga produkto' ] ,
template = 'Ano ang ipapangalan sa isang brand na nagbebenta ng {products}?' ,
)
Ngayong nakatakda na ang susi bilang variable ng kapaligiran, sinisimulan namin ang isang wrapper. Itakda ang temperatura para sa mga modelo ng OpenAI GPT. Ang temperatura ay isang katangian na tumutulong sa atin na matukoy kung gaano ka-unpredictable ang magiging tugon. Kung mas mataas ang halaga ng temperatura, mas mali-mali ang mga tugon. Itinakda namin ang halaga ng temperatura sa 0.9 dito. Kaya, nakukuha namin ang pinaka-random na mga resulta.
Pagkatapos, sinisimulan namin ang isang klase ng PromptTemplate. Kapag ginamit namin ang LLM, bumubuo kami ng prompt mula sa input na kinuha mula sa user at pagkatapos ay ipinapasa ito sa LLM sa halip na ipadala ang input nang direkta sa LLM na nangangailangan ng hard coding (ang prompt ay isang input na kinuha namin mula sa user at kung saan dapat lumikha ng tugon ang tinukoy na modelo ng AI). Kaya, sinisimulan namin ang PromptTemplate. Pagkatapos, sa loob ng mga kulot na brace nito, tinukoy namin ang input_variable bilang 'Mga Produkto' at ang text ng template ay 'Ano ang ipapangalan sa isang brand na nagbebenta ng {mga produkto}?' Sinasabi ng input ng user kung ano ang ginagawa ng brand. Pagkatapos, ipo-format nito ang prompt batay sa impormasyong ito.
mula sa langchain. mga tanikala angkat LLMChainkadena = LLMChain ( llm = llm , prompt = prompt )
Ngayong naka-format na ang aming PromptTemplate, ang susunod na hakbang ay ang paggawa ng LLMchain. Una, i-import ang LLMchain module mula sa 'langchain.chain' library. Pagkatapos, lumikha kami ng isang chain sa pamamagitan ng pagtawag sa LLMchain() function na kumukuha ng input ng user at ipo-format ang prompt dito. Panghuli, ipinapadala nito ang tugon sa LLM. Kaya, ito ay nag-uugnay sa PromptTemplate at LLM.
print ( kadena. tumakbo ( 'Mga gamit sa sining' ) )Upang isagawa ang chain, tinatawagan namin ang chain.run() na paraan at ibigay ang input ng user bilang parameter na tinukoy bilang 'Mga Art Supplies.' Pagkatapos, ipinapasa namin ang pamamaraang ito sa Python print() function upang ipakita ang hinulaang kinalabasan sa Python console.
Binabasa ng modelo ng AI ang prompt at gumagawa ng tugon batay dito.
Dahil hiniling namin na pangalanan ang isang brand na nagbebenta ng mga art supplies, ang hinulaang pangalan ng modelo ng AI ay makikita sa sumusunod na snapshot:
Ipinapakita sa amin ng halimbawang ito ang LLMchaining kapag ibinigay ang isang variable na input. Posible rin ito kapag gumagamit ng maraming variable. Para diyan, kailangan lang nating lumikha ng diksyunaryo ng mga variable upang maipasok ang mga ito nang buo. Tingnan natin kung paano ito gumagana:
mula sa langchain. mga senyales angkat PromptTemplatemula sa langchain. llms angkat OpenAI
angkat ikaw
ikaw . humigit-kumulang [ 'OPENAI_API_KEY' ] = 'sk- Iyong-API-KEY'
llm = OpenAI(temperatura=0.9)
prompt = PromptTemplate(
input_variables=[' Tatak ',' produkto '],
template=' Ano ang magiging pangalan ng { Tatak } na nagbebenta { produkto } ? ',
)
mula sa langchain.chains import LLMChain
chain = LLMChain(llm=llm, prompt=prompt)
print(chain.run({
'Brand': ' Mga kagamitan sa sining ',
'Produkto': ' mga kulay '
}))
Pareho ang code sa nakaraang halimbawa, maliban na kailangan nating ipasa ang dalawang variable sa klase ng prompt template. Kaya, lumikha ng isang diksyunaryo ng input_variables. Ang mahabang bracket ay kumakatawan sa isang diksyunaryo. Dito, mayroon kaming dalawang variable - 'Brand' at 'Product' - na pinaghihiwalay ng kuwit. Ngayon, ang text ng template na ibinibigay namin ay 'Ano ang magiging pangalan ng {Brand} na nagbebenta ng {Product}?' Kaya, hinuhulaan ng modelo ng AI ang isang pangalan na nakatutok sa dalawang input variable na ito.
Pagkatapos, gumawa kami ng LLMchain na nagfo-format sa input ng user gamit ang prompt na ipadala ang tugon sa LLM. Upang patakbuhin ang chain na ito, ginagamit namin ang chain.run() na pamamaraan at ipinapasa ang diksyunaryo ng mga variable na may input ng user bilang 'Brand': 'Mga Art supplies' at 'Produkto' bilang 'Mga Kulay.' Pagkatapos, ipinapasa namin ang paraang ito sa Python print() function para ipakita ang nakuhang tugon.
Ipinapakita ng output na imahe ang hinulaang resulta:
Konklusyon
Ang mga kadena ay ang mga bloke ng gusali ng LangChain. Ang artikulong ito ay dumaan sa konsepto ng paggamit ng LLMchain sa LangChain. Gumawa kami ng panimula sa LLMchain at inilarawan ang pangangailangang gamitin sila sa proyekto ng Python. Pagkatapos, nagsagawa kami ng praktikal na paglalarawan na nagpapakita ng pagpapatupad ng LLMchain sa pamamagitan ng pagkonekta sa PromptTemplate at LLM. Maaari kang lumikha ng mga chain na ito gamit ang isang variable na input pati na rin ang maramihang mga variable na ibinigay ng user. Ang mga nabuong tugon mula sa modelong GPT ay ibinibigay din.