Author(s): Mostafa Ibrahim
Awalnya diterbitkan di Menuju AI.
Menyebarkan aplikasi model Bahasa Besar full-stack menggunakan Streamlit, Pinecone (vektor DB) & Langchain
Foto oleh David Pupăză di Unsplash
LangChain adalah perpustakaan yang membantu pengembang membangun aplikasi yang didukung oleh model bahasa besar (LLM). Ini dilakukan dengan menyediakan kerangka kerja untuk menghubungkan LLM ke sumber data lain, seperti internet atau file pribadi Anda. Hal ini memungkinkan pengembang untuk menyatukan beberapa perintah untuk membuat aplikasi yang lebih kompleks.
Biji pinus adalah salah satu kerangka basis data vektor paling populer. Database vektor adalah jenis database yang dirancang khusus untuk menyimpan dan mengambil data vektor secara efisien. Data vektor, dalam konteks ini, mengacu pada data yang direpresentasikan sebagai sekumpulan nilai numerik, atau “vektor”, yang dapat digunakan untuk mendeskripsikan karakteristik suatu objek atau fenomena. Contoh data vektor termasuk gambar, sinyal audio, urutan genetik, dan dokumen teks.
Streamlit adalah pustaka Python sumber terbuka yang memudahkan pembuatan dan berbagi aplikasi web khusus yang indah untuk pembelajaran mesin dan ilmu data.
Gabungkan semuanya, dan Anda mendapatkan aplikasi LLM full-stack! Yang cukup menakjubkan dan tidak akan memakan waktu lama sama sekali! Dalam tutorial ini, kita akan melanjutkan proyek LLM kesayangan saya, membangun LLM yang menjawab pertanyaan di Langchain. Di bagian 1, kami mengekstraksi data, dan di bagian 2, kami menggunakan langchain untuk membangun rantai tanya-jawab yang kuat. Pada bagian ini, kita akan menambahkan vektor kita ke Pinecone dan menerapkan rantai kita ke Streamlit sehingga kita dapat memiliki UI penjawab pertanyaan yang berfungsi seperti ChatGPT. Sebelum kita mulai, Anda mungkin harus membuat akun di Streamlit dan Pinecone!
Bagian 1: Menambahkan vektor kita ke Biji Pinus
Setelah mendaftar ke Pinecone, Anda harus membuka https://app.pinecone.io/ dan mengambil kunci API dan nama Lingkungan. Sekarang mari kita ke bagian yang berdaging. Mari buat skrip yang akan membaca file kita, membuat vektor, dan mengunggah ke Pinecone, kita akan memanggil skrip ini pinecone_vec.pySeperti biasa, kita akan mulai dengan impor. Kita akan memerlukan embeddings OpenAI (atau jangan ragu untuk menggunakan embeddings lainnya, seperti HuggingFace kalimat-transformer), DirectoryLoader langchain, pemecah teks apa pun, dan Pinecone.
dari langchain.embeddings.openai impor OpenAIEmbeddings
dari langchain.vectorstores impor Biji Pinus
impor biji pinus
impor kami
dari langchain.document_loaders impor DirectoryLoader
dari langchain.text_splitter impor RecursiveCharacterTextSplitter
Selanjutnya, kita perlu mengekspor 3 variabel lingkungan di terminal kita. Anda juga dapat menambahkannya ke .env dan menggunakan load_env() Python, tetapi saya tidak akan melakukannya di sini; kami ingin cepat!
ekspor PINECONE_API_KEY=”ur_key”
ekspor PINECONE_ENV=”northamerica-northeast1-gcp”
ekspor OPENAI_API_KEY=”sk….”
Setelah itu, kita perlu memuat dataset kita. Ada beberapa cara untuk melakukannya, bergantung pada jenis kumpulan data Anda, jadi jangan ragu untuk memeriksa pemuat data Langchain. Dalam contoh kami, kami memiliki direktori bernama data_output_filtered_content yang berisi file txt yang mewakili dokumentasi Langchain. Setelah memuat data, kita akan membaginya menjadi potongan yang tidak tumpang tindih menggunakan RecursiveCharacterTextSplitter . Anda dapat membaca lebih lanjut tentang strategi pemotongan untuk model Bahasa Besar di sini, dan Anda juga dapat memilih jenis pemecah teks lainnya dari Langchain di sini. Menurut Langchain, inilah RecursiveCharacterTextSplitter
Pemisah teks ini adalah yang direkomendasikan untuk teks umum. Ini diparameterisasi oleh daftar karakter. Ia mencoba untuk membaginya secara berurutan sampai potongannya cukup kecil. Daftar default adalah [“nn”, “n”, ” “, “”]. Ini memiliki efek mencoba untuk menjaga semua paragraf (dan kemudian kalimat, dan kemudian kata-kata) bersama-sama selama mungkin, karena itu secara umum tampaknya merupakan bagian teks yang paling terkait secara semantik.
my_loader = DirectoryLoader(‘./data_output_filtered_content’, glob=’**/*.txt’)
dokumen = my_loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size = 700, chunk_overlap = 0)
dokumen = text_splitter.split_documents(dokumen)
Selanjutnya, kita akan menginisialisasi lingkungan biji pinus kita:
# menginisialisasi biji pinus
biji pinus.init(
api_key=os.environ[‘PINECONE_API_KEY’]# temukan di app.pinecone.io
lingkungan=os.environ[‘PINECONE_ENV’] # di sebelah kunci api di konsol
)
Selanjutnya, kita harus pergi ke Pinecone dan membuat indeks baru. Anda harus pergi ke bagian indeks Pinecone dan klik “Buat Indeks”. Anda juga perlu mengetahui jumlah dimensi yang cocok untuk kumpulan data Anda. Anda dapat membaca lebih lanjut tentang berbagai dimensi dan jenis pod yang dapat Anda pilih di sini. Jika Anda benar-benar pemula, Anda dapat memilih 768 dan ikuti langkah selanjutnya, jika tidak sesuai dengan dataset Anda, Pinecone akan memberi Anda kesalahan yang berisi nomor yang tepat untuk dataset Anda.
Untuk saat ini, kita akan menggunakan 1536 dimensi, kesamaan cosinus (default), dan pod S1. Kami akan menamai indeks kami “langchain-demo-1536,” dan kami akan mengekspornya sebagai variabel lingkungan:
ekspor PINECONE_INDEX_NAME=”langchain-demo-1536″
Selanjutnya, kita akan mulai mengupload vektor kita ke Pinecone, dengan langchain, dengan 1-liner sederhana ini:
docsearch = Pinecone.from_documents(dokumen, penyematan, index_name=os.environ[‘PINECONE_INDEX_NAME’])
Dan jalankan saja:
python pincone_vec.py
Ini mungkin memakan waktu cukup lama. Jika Anda ingin memeriksa apakah itu berfungsi, cukup klik nama indeks Anda di Pinecone dan periksa metriknya. Dalam kasus saya, saya mendapatkan sekitar 10K vektor:
Sekarang kita dapat menulis kueri sederhana untuk memeriksa apakah itu berfungsi:
docsearch = Pinecone.from_existing_index(os.environ[‘PINECONE_INDEX_NAME’]penyematan)
query = “tuliskan saya kode langchain untuk membuat model wajah saya yang dipeluk”
docs = docsearch.similarity_search(permintaan)
dari langchain.chains.qa_with_sources impor load_qa_with_sources_chain
dari langchain.llms mengimpor model OpenAI = OpenAI(model_name=”text-davinci-003″)
rantai_sumber = load_qa_dengan_rantai_sumber(model, tipe_rantai=”perbaiki”)
hasil = sources_chain.run(input_documents=dokumen, pertanyaan=permintaan)
cetak(hasil)
Keluaran:
# Bangun Model Wajah Memeluk
dari langchain.embeddings impor HuggingFaceHubEmbeddings
dari langchain.llms impor OpenAI repo_id = “google/flan-t5-xl” # Lihat https://huggingface.co/models?pipeline_tag=text-generation&sort=downloads untuk beberapa opsi lainllm = HuggingFaceHubEmbeddings(
repo_id=repo_id,
model_kwargs={
“suhu”: 0,
“max_length”: 64
},
langchain_kwargs={
“expert_mode”: Benar
},
tokenizer_kwargs={
“use_character_text_splitter”: Benar
}
) # Inisialisasi OpenAI LLM
openai_llm = OpenAI(model_kwargs={
“suhu”: 0,
“max_length”: 64
})
Tidak terlalu buruk, kami masih perlu sedikit memperbaiki Rantai kami, tetapi kami akan melakukannya di artikel lain! Dan selesailah Biji Pinus! Kita sekarang dapat menggunakan ini di bagian selanjutnya, yaitu menghubungkannya ke Streamlit.
Bagian 2: Menyebarkan rantai kami di Streamlit
Kami pertama-tama akan mulai dengan forking template yang disediakan oleh langchain untuk Streamlit di sini (kredit ke Langchain karena membuatnya cukup mudah!). Setelah melakukan forking pada repositori GitHub, Anda perlu mengkloningnya dan melakukan beberapa pengeditan.
Pertama, arahkan ke requirements.txt dan tambahkan pinecone-client . Selanjutnya, buka main.py dan tambahkan impor berikut:
impor biji pinus
impor kami
dari langchain.embeddings.openai impor OpenAIEmbeddings
dari langchain.vectorstores impor Biji Pinus
Setelah itu, kita perlu menginisialisasi lingkungan kita dan memuat penyematan:
embeddings = OpenAIEmbeddings() biji pinus.init(
api_key=str(os.environ[‘PINECONE_API_KEY’]),
lingkungan=str(os.environ[‘PINECONE_ENV’])
)nama_indeks = str(os.environ[‘PINECONE_INDEX_NAME’])
Selanjutnya, kita perlu mengedit metode load_chain() :
def load_chain():
docsearch = Pinecone.from_existing_index(index_name, embeddings)
kembali pencarian dokumen
dan juga pernyataan user_input if:
jika input_pengguna:
docs = chain.similarity_search(user_input)
keluaran = dokumen[0].page_content st.session_state.past.append(user_input)
st.session_state.generated.append(keluaran)
Catatan: Anda dapat menggunakan jenis pencarian yang berbeda untuk rantai Anda, dalam hal ini, kami akan menggunakan similarity_search agar semuanya tetap sederhana.
Pada titik ini, kita harus siap, mari instal Streamlit dan jalankan aplikasi ini:
pip instal streamlit
streamlit menjalankan main.py
Jika berfungsi dengan benar, itu akan membuka aplikasi di jendela baru, dan Anda akan mendapatkan pesan yang terlihat seperti ini:
Anda sekarang dapat melihat aplikasi Streamlit di browser Anda. URL lokal: http://localhost:8501
URL jaringan: http://192.168.1.101:8501
Kami juga dapat mengujinya:
Keren, mari dorong ini ke GitHub.
Kami cukup menghubungkannya ke Streamlit. Setelah masuk ke Streamlit, Anda dapat mengklik “Aplikasi baru” di sini dan mengizinkannya untuk mengakses repositori Anda di akun GitHub Anda
Selanjutnya, Anda harus mengarahkannya ke file aplikasi repo, cabang, dan utama:
Anda juga perlu mengklik “Pengaturan lanjutan” dan menambahkan rahasia yang akan kami gunakan:
PINECONE_API_KEY=”ur_key”
PINECONE_ENV=”northamerica-northeast1-gcp”
OPENAI_API_KEY=”sk….”
PINECONE_INDEX_NAME=”langchain-demo-1536″
Pikiran terakhir
Dan itu saja, aplikasi Streamlit kita sudah siap sekarang! Anda dapat menemukan kode yang digunakan dalam tutorial ini di sini dan aplikasi saya di sini. Perhatikan bahwa artikel ini terutama untuk tujuan pendidikan untuk menerapkan aplikasi Langchain yang sangat sederhana. Untuk penggunaan produksi, Anda mungkin perlu melakukan lebih banyak lagi!
Diterbitkan melalui Menuju AI
