Rantaian tidak berfungsi hanya untuk satu panggilan LLM sahaja; ia adalah koleksi panggilan, sama ada ke LLM atau utiliti lain. Rantaian hujung ke hujung untuk aplikasi yang digunakan secara meluas disediakan oleh LangChain bersama-sama dengan API rantaian standard dan pelbagai penyepaduan alat.
Fleksibiliti dan keupayaan untuk memautkan berbilang elemen ke dalam satu entiti mungkin berguna apabila kami ingin mereka bentuk rantaian yang menerima input pengguna, menyediakannya menggunakan PromptTemplate dan kemudian menyampaikan hasil yang dijana ke LLM.
Artikel ini membantu anda memahami penggunaan fungsi LangChain LLMchain dalam Python.
Contoh: Cara Menggunakan Fuction LLMchain dalam LangChain
Kami bercakap tentang apa itu rantai. Sekarang, kita akan melihat demonstrasi praktikal rantaian ini yang dilaksanakan dalam skrip Python. Dalam contoh ini, kami menggunakan rantaian LangChain yang paling asas iaitu LLMchain. Ia mengandungi PromptTemplate dan LLM, dan merantainya bersama-sama untuk menjana output.
Untuk mula melaksanakan konsep, kita perlu memasang beberapa perpustakaan yang diperlukan yang tidak termasuk dalam perpustakaan standard Python. Perpustakaan yang perlu kami pasang ialah LangChain dan OpenAI. Kami memasang perpustakaan LangChain kerana kami perlu menggunakan modul LLMchain serta PromptTemplate. Pustaka OpenAI membolehkan kami menggunakan model OpenAI untuk meramalkan output, iaitu GPT-3.
Untuk memasang perpustakaan LangChain, jalankan arahan berikut pada terminal:
$ pip pasang langchainPasang perpustakaan OpenAI dengan arahan berikut:
$ pip pasang openai
Setelah pemasangan selesai, kami boleh mula mengerjakan projek utama.
daripada langchain. gesaan import PromptTemplatedaripada langchain. llms import OpenAI
import awak
awak . lebih kurang [ 'OPENAI_API_KEY' ] = 'sk-KUNCI API ANDA'
Projek utama bermula dengan mengimport modul yang diperlukan. Jadi, kami mula-mula mengimport PromptTemplate daripada perpustakaan 'langchain.prompts'. Kemudian, kami mengimport OpenAI daripada perpustakaan 'langchain.llms'. Seterusnya, kami mengimport 'os' untuk menetapkan pembolehubah persekitaran.
Pada mulanya, kami menetapkan kunci API OpenAI sebagai pembolehubah persekitaran. Pembolehubah persekitaran ialah pembolehubah yang terdiri daripada nama dan nilai dan ditetapkan pada sistem pengendalian kami. 'os.environ' ialah objek yang digunakan untuk memetakan pembolehubah persekitaran. Jadi, kami panggil 'os.environ'. Nama yang kami tetapkan untuk kunci API ialah OPENAI_API_KEY. Kami kemudian menetapkan kunci API sebagai nilainya. Kunci API adalah unik untuk setiap pengguna. Jadi, apabila anda mengamalkan skrip kod ini, tulis kunci API rahsia anda.
llm = OpenAI ( suhu = 0.9 )segera = PromptTemplate (
input_variables = [ 'produk' ] ,
templat = 'Apakah jenama yang akan dinamakan yang menjual {produk}?' ,
)
Sekarang setelah kunci ditetapkan sebagai pembolehubah persekitaran, kami memulakan pembalut. Tetapkan suhu untuk model OpenAI GPT. Suhu ialah ciri yang membantu kita menentukan sejauh mana tindak balas tidak dapat diramalkan. Semakin tinggi nilai suhu, semakin tidak menentu tindak balasnya. Kami menetapkan nilai suhu kepada 0.9 di sini. Oleh itu, kami mendapat keputusan yang paling rawak.
Kemudian, kami memulakan kelas PromptTemplate. Apabila kami menggunakan LLM, kami menjana gesaan daripada input yang diambil daripada pengguna dan kemudian menghantarnya kepada LLM dan bukannya menghantar input terus ke LLM yang memerlukan pengekodan keras (gesaan ialah input yang kami ambil daripada pengguna dan model AI yang ditakrifkan harus mencipta tindak balas). Jadi, kami memulakan PromptTemplate. Kemudian, dalam kurungan kerintingnya, kami mentakrifkan pembolehubah_input sebagai 'Produk' dan teks templat ialah 'Apakah jenama yang akan dinamakan yang menjual {produk}?' Input pengguna memberitahu apa yang dilakukan oleh jenama. Kemudian, ia memformat gesaan berdasarkan maklumat ini.
daripada langchain. rantai import LLMChainrantai = LLMChain ( llm = llm , segera = segera )
Sekarang setelah PromptTemplate kami diformat, langkah seterusnya ialah membuat LLMchain. Mula-mula, import modul LLMchain daripada perpustakaan 'langchain.chain'. Kemudian, kami mencipta rantai dengan memanggil fungsi LLMchain() yang mengambil input pengguna dan memformat gesaan dengannya. Akhir sekali, ia menghantar respons kepada LLM. Jadi, ia menghubungkan PromptTemplate dan LLM.
cetak ( rantai. lari ( 'Bekalan seni' ) )Untuk melaksanakan rantaian, kami memanggil kaedah chain.run() dan menyediakan input pengguna sebagai parameter yang ditakrifkan sebagai 'Bekalan Seni'. Kemudian, kami menghantar kaedah ini kepada fungsi Python print() untuk memaparkan hasil ramalan pada konsol Python.
Model AI membaca gesaan dan membuat respons berdasarkannya.
Memandangkan kami meminta untuk menamakan jenama yang menjual bekalan seni, nama yang diramalkan oleh model AI boleh dilihat dalam petikan berikut:
Contoh ini menunjukkan kepada kita LLMchaining apabila pembolehubah input tunggal disediakan. Ini juga boleh dilakukan apabila menggunakan berbilang pembolehubah. Untuk itu, kita hanya perlu mencipta kamus pembolehubah untuk memasukkannya sama sekali. Mari lihat bagaimana ini berfungsi:
daripada langchain. gesaan import PromptTemplatedaripada langchain. llms import OpenAI
import awak
awak . lebih kurang [ 'OPENAI_API_KEY' ] = 'sk- KUNCI-API-Anda”
llm = OpenAI(suhu=0.9)
gesaan = PromptTemplate(
input_variables=[' Jenama ',' produk '],
template=' Apa yang akan menjadi nama { Jenama } yang menjual { produk } ? ',
)
daripada langchain.chains import LLMChain
rantai = LLMChain(llm=llm, prompt=prompt)
print(chain.run({
'Jenama': ' Bekalan seni ',
'Produk': ' warna '
}))
Kodnya sama seperti contoh sebelumnya, kecuali kita perlu lulus dua pembolehubah dalam kelas templat segera. Jadi, buat kamus input_variables. Tanda kurung panjang mewakili kamus. Di sini, kami mempunyai dua pembolehubah - 'Jenama' dan 'Produk' - yang dipisahkan dengan koma. Sekarang, teks templat yang kami sediakan ialah 'Apakah nama {Jenama} yang menjual {Produk}?' Oleh itu, model AI meramalkan nama yang memfokuskan pada dua pembolehubah input ini.
Kemudian, kami mencipta LLMchain yang memformat input pengguna dengan gesaan untuk menghantar respons kepada LLM. Untuk menjalankan rantaian ini, kami menggunakan kaedah chain.run() dan lulus kamus pembolehubah dengan input pengguna sebagai 'Jenama': 'Bekalan seni' dan 'Produk' sebagai 'Warna'. Kemudian, kami menghantar kaedah ini kepada fungsi Python print() untuk memaparkan respons yang diperoleh.
Imej output menunjukkan hasil yang diramalkan:
Kesimpulan
Rantaian adalah bahan binaan LangChain. Artikel ini melalui konsep menggunakan LLMchain dalam LangChain. Kami membuat pengenalan kepada LLMchain dan menggambarkan keperluan untuk menggunakan mereka dalam projek Python. Kemudian, kami menjalankan ilustrasi praktikal yang menunjukkan pelaksanaan LLMchain dengan menyambungkan PromptTemplate dan LLM. Anda boleh mencipta rantaian ini dengan pembolehubah input tunggal serta berbilang pembolehubah yang disediakan pengguna. Respons yang dijana daripada model GPT juga disediakan.