Dari Nol ke Teknik Prompt Engineering Lanjutan dengan Langchain di Python

Aspek penting dari Model Bahasa Besar (LLM) adalah jumlah parameter yang digunakan oleh model ini untuk belajar. Semakin banyak parameter yang dimiliki model, semakin baik model dapat memahami hubungan antara kata dan frasa. Ini berarti bahwa model dengan miliaran parameter memiliki kemampuan untuk menghasilkan berbagai format teks kreatif dan menjawab pertanyaan terbuka dan menantang dengan cara yang informatif.

LLM seperti ChatGPT, yang menggunakan model Transformer, sangat mahir dalam memahami dan menghasilkan bahasa manusia, sehingga sangat berguna untuk aplikasi yang memerlukan pemahaman bahasa alami. Namun, mereka tidak tanpa keterbatasan, termasuk pengetahuan yang sudah ketinggalan zaman, ketidakmampuan untuk berinteraksi dengan sistem eksternal, kurangnya pemahaman konteks, dan terkadang menghasilkan respons yang terdengar masuk akal tetapi salah atau tidak masuk akal, di antara lainnya.

Untuk mengatasi keterbatasan ini, diperlukan integrasi LLM dengan sumber data dan kemampuan eksternal, yang dapat menimbulkan kompleksitas dan memerlukan keterampilan pemrograman dan pengolahan data yang luas. Ini, dikombinasikan dengan tantangan memahami konsep AI dan algoritma yang kompleks, menyumbang pada kurva belajar yang terkait dengan pengembangan aplikasi menggunakan LLM.

Namun, integrasi LLM dengan alat lain untuk membentuk aplikasi yang ditenagai LLM dapat mengubah lanskap digital kita. Potensi aplikasi tersebut sangat luas, termasuk meningkatkan efisiensi dan produktivitas, menyederhanakan tugas, meningkatkan pengambilan keputusan, dan menyediakan pengalaman yang dipersonalisasi.

Dalam artikel ini, kita akan membahas lebih dalam tentang masalah-masalah ini, menjelajahi teknik-teknik lanjutan dari teknik prompt engineering dengan Langchain, menawarkan penjelasan yang jelas, contoh praktis, dan instruksi langkah demi langkah tentang cara menerapkannya.

Langchain, sebuah perpustakaan yang sangat mutakhir, membawa kemudahan dan fleksibilitas dalam merancang, menerapkan, dan mengoptimalkan prompt. Ketika kita membongkar prinsip-prinsip dan praktik teknik prompt engineering, Anda akan belajar bagaimana menggunakan fitur-fitur kuat Langchain untuk memanfaatkan kekuatan model AI Generatif terbaru seperti GPT-4.

Mengenal Prompt

Sebelum memasuki teknisnya teknik prompt engineering, penting untuk memahami konsep prompt dan signifikansinya.

Sebuah ‘prompt‘ adalah urutan token yang digunakan sebagai input untuk model bahasa, yang memberi instruksi untuk menghasilkan jenis respons tertentu. Prompt memainkan peran kunci dalam mengarahkan perilaku model. Mereka dapat mempengaruhi kualitas teks yang dihasilkan, dan ketika dirancang dengan benar, dapat membantu model memberikan hasil yang mendalam, akurat, dan spesifik konteks.

Teknik prompt engineering adalah seni dan ilmu merancang prompt yang efektif. Tujuannya adalah untuk memicu output yang diinginkan dari model bahasa. Dengan memilih dan merancang prompt dengan hati-hati, seseorang dapat mengarahkan model untuk menghasilkan respons yang lebih akurat dan relevan. Dalam prakteknya, ini melibatkan penyesuaian frasa input untuk menyesuaikan dengan bias struktural dan pelatihan model.

Kesophistikan teknik prompt engineering berkisar dari teknik sederhana, seperti memberi model dengan kata kunci yang relevan, hingga metode yang lebih maju yang melibatkan perancangan prompt yang kompleks dan terstruktur yang menggunakan mekanisme internal model untuk keuntungannya.

Langchain: Alat Prompt Tercepat

LangChain, yang diluncurkan pada Oktober 2022 oleh Harrison Chase, telah menjadi salah satu kerangka kerja open-source yang paling dinilai tinggi di GitHub pada 2023. Ini menawarkan antarmuka yang disederhanakan dan standar untuk mengintegrasikan Model Bahasa Besar (LLM) ke dalam aplikasi. Ini juga menyediakan antarmuka yang kaya fitur untuk teknik prompt engineering, memungkinkan pengembang untuk bereksperimen dengan strategi yang berbeda dan mengevaluasi hasilnya. Dengan menggunakan Langchain, Anda dapat melakukan tugas teknik prompt engineering dengan lebih efektif dan intuitif.

LangFlow berfungsi sebagai antarmuka pengguna untuk mengatur komponen LangChain menjadi flowchart yang dapat dieksekusi, memungkinkan prototip dan eksperimen yang cepat.

LangChain mengisi celah penting dalam pengembangan AI untuk massa. Ini memungkinkan berbagai aplikasi NLP seperti asisten virtual, generator konten, sistem pertanyaan dan jawaban, dan lainnya, untuk menyelesaikan berbagai masalah dunia nyata.

Bukan sebagai model atau penyedia mandiri, LangChain menyederhanakan interaksi dengan model yang beragam, memperluas kemampuan aplikasi LLM di luar keterbatasan panggilan API sederhana.

Arsitektur LangChain

Komponen utama LangChain termasuk Model I/O, Prompt Templates, Memory, Agents, dan Chains.

Model I/O

LangChain memfasilitasi koneksi yang mulus dengan berbagai model bahasa dengan membungkusnya dengan antarmuka standar yang dikenal sebagai Model I/O. Ini memungkinkan peralihan model yang mudah untuk optimasi atau kinerja yang lebih baik. LangChain mendukung berbagai penyedia model bahasa, termasuk OpenAI, HuggingFace, Azure, Fireworks, dan lainnya.

Prompt Templates

Ini digunakan untuk mengelola dan mengoptimalkan interaksi dengan LLM dengan menyediakan instruksi atau contoh yang ringkas. Mengoptimalkan prompt meningkatkan kinerja model, dan fleksibilitas mereka memberikan kontribusi signifikan pada proses input.

Contoh sederhana dari template prompt:

<p>from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=[&amp;quot;subject&amp;quot;],
template=&amp;quot;Apa kemajuan terbaru di bidang {subject}?&amp;quot;)
print(prompt.format(subject=&amp;quot;Pengolahan Bahasa Alami&amp;quot;))</p>

Ketika kita maju dalam kompleksitas, kita menemukan pola yang lebih canggih dalam LangChain, seperti pola Reason and Act (ReAct). ReAct adalah pola vital untuk eksekusi tindakan di mana agen menugaskan tugas ke alat yang sesuai, menyesuaikan input untuk itu, dan menganalisis outputnya untuk menyelesaikan tugas. Contoh Python di bawah ini menunjukkan pola ReAct. Ini menunjukkan bagaimana prompt dirancang di LangChain, menggunakan serangkaian pemikiran dan tindakan untuk memahami masalah dan menghasilkan jawaban akhir:

PREFIX = """Jawab pertanyaan berikut menggunakan alat yang diberikan"""
FORMAT_INSTRUCTIONS = """Ikuti format berikut:
Pertanyaan: {input_question}
Pemikiran: pemikiran awal Anda tentang pertanyaan
Tindakan: tindakan yang Anda pilih dari [{tool_names}]
Input Tindakan: input Anda untuk tindakan
Pengamatan: hasil tindakan"""
SUFFIX = """Mulai!
Pertanyaan: {input}
Pemikiran:{agent_scratchpad}"""

Memory

Memory adalah konsep kritis dalam LangChain, yang memungkinkan LLM dan alat untuk mempertahankan informasi dari waktu ke waktu. Perilaku ini meningkatkan kinerja aplikasi LangChain dengan menyimpan respons sebelumnya, interaksi pengguna, keadaan lingkungan, dan tujuan agen. Strategi ConversationBufferMemory dan ConversationBufferWindowMemory membantu melacak bagian penuh atau bagian terbaru dari percakapan. Untuk pendekatan yang lebih canggih, strategi ConversationKGMemory memungkinkan mengkodekan percakapan sebagai grafik pengetahuan yang dapat diberikan kembali ke prompt atau digunakan untuk memprediksi respons tanpa memanggil LLM.

Agents

Sebuah agen berinteraksi dengan dunia dengan melakukan tindakan dan tugas. Dalam LangChain, agen menggabungkan alat dan rantai untuk eksekusi tugas. Ini dapat membangun koneksi ke dunia luar untuk pengambilan informasi untuk meningkatkan pengetahuan LLM, sehingga mengatasi keterbatasan bawaannya. Mereka dapat memutuskan untuk melewati perhitungan ke kalkulator atau interpreter Python tergantung pada situasi.

Agen dilengkapi dengan subkomponen:

• Alat: Ini adalah komponen fungsional.
• Toolkits: Koleksi alat.
• Agent Executors: Ini adalah mekanisme eksekusi yang memungkinkan memilih antara alat.

Agen dalam LangChain juga mengikuti pola Zero-shot ReAct, di mana keputusan didasarkan hanya pada deskripsi alat. Mekanisme ini dapat diperluas dengan memori untuk mempertimbangkan seluruh riwayat percakapan. Dengan ReAct, bukan meminta LLM untuk melengkapi teks, Anda dapat meminta model untuk merespons dalam loop pemikiran/tindakan/pengamatan.

Rantai

Rantai, sebagaimana namanya, adalah urutan operasi yang memungkinkan perpustakaan LangChain untuk memproses input dan output model bahasa dengan lancar. Komponen integral ini dari LangChain secara fundamental terdiri dari tautan, yang dapat berupa rantai lain atau primitif seperti prompt, model bahasa, atau utilitas.

Bayangkan rantai sebagai sabuk konveyor di sebuah pabrik. Setiap langkah pada sabuk ini mewakili operasi tertentu, yang bisa jadi memanggil model bahasa, menerapkan fungsi Python ke teks, atau bahkan meminta model dengan cara tertentu.

LangChain mengategorikan rantainya menjadi tiga jenis: Rantai Utilitas, Rantai Generik, dan Rantai Gabungkan Dokumen. Kami akan membahas Rantai Utilitas dan Rantai Generik untuk diskusi kami.

• Rantai Utilitas dirancang khusus untuk mengekstrak jawaban yang tepat dari model bahasa untuk tugas yang didefinisikan dengan baik. Sebagai contoh, mari kita lihat LLMMathChain. Rantai utilitas ini memungkinkan model bahasa untuk melakukan perhitungan matematika. Ini menerima pertanyaan dalam bahasa alami, dan model bahasa kemudian menghasilkan potongan kode Python yang kemudian dieksekusi untuk menghasilkan jawaban.
• Rantai Generik, di sisi lain, berfungsi sebagai blok bangunan untuk rantai lain tetapi tidak dapat digunakan secara mandiri. Rantai ini, seperti LLMChain, adalah fondasi dan sering digabungkan dengan rantai lain untuk menyelesaikan tugas yang kompleks. Sebagai contoh, LLMChain sering digunakan untuk mengquery objek model bahasa dengan memformat input berdasarkan template prompt yang diberikan dan kemudian melewatinya ke model bahasa.

Implementasi Langkah demi Langkah dari Teknik Prompt Engineering dengan Langchain

Kami akan memandu Anda melalui proses implementasi teknik prompt engineering menggunakan Langchain. Sebelum melanjutkan, pastikan Anda telah menginstal perangkat lunak dan paket yang diperlukan.

Anda dapat menggunakan alat populer seperti Docker, Conda, Pip, dan Poetry untuk mengatur LangChain. File instalasi yang relevan untuk setiap metode ini dapat ditemukan dalam repositori LangChain di https://github.com/benman1/generative_ai_with_langchain. Ini termasuk Dockerfile untuk Docker, requirements.txt untuk Pip, pyproject.toml untuk Poetry, dan file langchain_ai.yml untuk Conda.

Dalam artikel ini, kita akan menggunakan Pip, pengelola paket standar untuk Python, untuk memfasilitasi instalasi dan pengelolaan perpustakaan pihak ketiga. Jika tidak termasuk dalam distribusi Python Anda, Anda dapat menginstal Pip dengan mengikuti instruksi di https://pip.pypa.io/.

Untuk menginstal perpustakaan dengan Pip, gunakan perintah pip install library_name.

Namun, Pip tidak mengelola lingkungan secara mandiri. Untuk menangani lingkungan yang berbeda, kita menggunakan alat virtualenv.

Dalam bagian berikutnya, kita akan membahas integrasi model.

Langkah 1: Mengatur Langchain

Pertama, Anda perlu menginstal paket Langchain. Kami menggunakan Windows OS. Jalankan perintah berikut di terminal Anda untuk menginstalnya:

pip install langchain

Langkah 2: Mengimpor Langchain dan Modul Lain yang Diperlukan

Selanjutnya, impor Langchain bersama dengan modul lain yang diperlukan. Di sini, kita juga mengimpor perpustakaan transformers, yang secara luas digunakan dalam tugas NLP.

<p>import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Langkah 3: Memuat Model Pra-pelatihan

Open AI

OpenAI model dapat diakses dengan mudah melalui perpustakaan LangChain atau klien Python OpenAI. Terutama, OpenAI menyediakan kelas Embedding untuk model embedding teks. Dua model LLM kunci adalah GPT-3.5 dan GPT-4, yang berbeda terutama dalam panjang token. Harga untuk setiap model dapat ditemukan di situs web OpenAI. Sementara ada model yang lebih canggih seperti GPT-4-32K yang memiliki penerimaan token yang lebih tinggi, ketersediaannya melalui API tidak selalu dijamin.

Mengakses model ini memerlukan kunci API OpenAI. Ini dapat dilakukan dengan membuat akun di platform OpenAI, mengatur informasi penagihan, dan menghasilkan kunci rahasia baru.

<p>import os
os.environ[&amp;quot;OPENAI_API_KEY&amp;quot;] = &#039;your-openai-token&#039;</p>

Setelah membuat kunci, Anda dapat mengatur kunci sebagai variabel lingkungan (OPENAI_API_KEY) atau melewatinya sebagai parameter selama instansiasi kelas untuk panggilan OpenAI.

Pertimbangkan skrip LangChain untuk menunjukkan interaksi dengan model OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# LLM mengambil prompt sebagai input dan menghasilkan kelengkapan
prompt = "siapa presiden Amerika Serikat?"
completion = llm(prompt)

<p>Presiden saat ini dari Amerika Serikat adalah Joe Biden.</p>

Dalam contoh ini, agen diinisialisasi untuk melakukan perhitungan. Agen mengambil input, tugas penjumlahan sederhana, memprosesnya menggunakan model OpenAI yang disediakan, dan mengembalikan hasilnya.

Hugging

Hugging Face adalah perpustakaan Transformers Python yang BEbas DIGUNAKAN, kompatibel dengan PyTorch, TensorFlow, dan JAX, dan termasuk implementasi model seperti BERT, T5, dll.

Hugging Face juga menawarkan Hugging Face Hub, platform untuk hosting repositori kode, model pembelajaran mesin, dataset, dan aplikasi web.

Untuk menggunakan Hugging Face sebagai penyedia model, Anda memerlukan akun dan kunci API, yang dapat diperoleh dari situs web mereka. Token dapat dibuat tersedia di lingkungan Anda sebagai HUGGINGFACEHUB_API_TOKEN.

Pertimbangkan cuplikan Python berikut yang menggunakan model open-source yang dikembangkan oleh Google (GOOGL ), model Flan-T5-XXL:

from langchain.llms import HuggingFaceHub

<p>llm = HuggingFaceHub(model_kwargs={&amp;quot;temperature&amp;quot;: 0.5, &amp;quot;max_length&amp;quot;: 64},repo_id=&amp;quot;google/flan-t5-xxl&amp;quot;)
prompt = &amp;quot;Di negara mana Tokyo?&amp;quot;
completion = llm(prompt)
print(completion)</p>

Skrip ini mengambil pertanyaan sebagai input dan mengembalikan jawaban, menunjukkan kemampuan pengetahuan dan prediksi model.

Langkah 4: Teknik Prompt Engineering Dasar

Untuk memulai, kita akan menghasilkan prompt sederhana dan melihat bagaimana model merespons.

prompt = 'Terjemahkan teks Inggris berikut ke dalam bahasa Prancis: "{0}"'
input_text = 'Halo, bagaimana kabarmu?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

<p>generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

Dalam cuplikan kode di atas, kita memberikan prompt untuk menerjemahkan teks Inggris ke dalam bahasa Prancis. Model bahasa kemudian mencoba menerjemahkan teks yang diberikan berdasarkan prompt.

Langkah 5: Teknik Prompt Engineering Lanjutan

Sementara pendekatan di atas berfungsi, itu tidak sepenuhnya memanfaatkan kekuatan teknik prompt engineering. Mari kita tingkatkan dengan memperkenalkan struktur prompt yang lebih kompleks.

prompt = 'Sebagai penerjemah Prancis yang sangat terampil, terjemahkan teks Inggris berikut ke dalam bahasa Prancis: "{0}"'
input_text = 'Halo, bagaimana kabarmu?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

<p>generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

Dalam cuplikan kode ini, kita memodifikasi prompt untuk menunjukkan bahwa terjemahan dilakukan oleh ‘penerjemah Prancis yang sangat terampil’. Perubahan pada prompt dapat menghasilkan terjemahan yang lebih baik, karena model sekarang mengasumsikan persona ahli.

Membangun Sistem Pertanyaan dan Jawaban Literatur Akademis dengan Langchain

Kita akan membangun sistem pertanyaan dan jawaban literatur akademis menggunakan LangChain yang dapat menjawab pertanyaan tentang makalah akademis yang diterbitkan baru-baru ini.

Pertama, untuk mengatur lingkungan kita, kita menginstal dependensi yang diperlukan.

pip install langchain arxiv openai transformers faiss-cpu

Setelah instalasi, kita membuat notebook Python baru dan mengimpor perpustakaan yang diperlukan:

from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

Inti dari sistem pertanyaan dan jawaban kita adalah kemampuan untuk mengambil makalah akademis yang relevan terkait dengan bidang tertentu, di sini kita mempertimbangkan Pengolahan Bahasa Alami (NLP), menggunakan database akademis arXiv. Untuk melakukan ini, kita mendefinisikan fungsi get_arxiv_data(max_results=10). Fungsi ini mengumpulkan ringkasan makalah NLP terbaru dari arXiv dan mengemasnya menjadi objek Dokumen LangChain, menggunakan ringkasan sebagai konten dan ID entri unik sebagai sumber.

Kita akan menggunakan API arXiv untuk mengambil makalah terbaru terkait NLP:

<p>def get_arxiv_data(max_results=10):
search = arxiv.Search(
query=&amp;quot;NLP&amp;quot;,
max_results=max_results,
sort_by=arxiv.SortCriterion.SubmittedDate,
)</p>

documents = []

<p>for result in search.results():
documents.append(Document(
page_content=result.summary,
metadata={&amp;quot;source&amp;quot;: result.entry_id},
))</p>

return documents

Fungsi ini mengambil ringkasan makalah NLP terbaru dari arXiv dan mengubahnya menjadi objek Dokumen LangChain. Kita menggunakan ringkasan makalah dan ID entri unik (URL ke makalah) sebagai konten dan sumber, masing-masing.

def print_answer(question):
print(
chain(
{
"input_documents": sources,
"question": question,
},
return_only_outputs=True,
)["output_text"]
)

Mari kita tentukan corpus kita dan mengatur LangChain:

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(temperature=0))

Dengan sistem pertanyaan dan jawaban akademis kita sekarang siap, kita dapat mengujinya dengan mengajukan pertanyaan:

print_answer("Apa kemajuan terbaru dalam NLP?")

Outputnya akan menjadi jawaban untuk pertanyaan Anda, dengan menyebutkan sumber dari mana informasi tersebut diperoleh. Sebagai contoh:

<p>Kemajuan terbaru dalam NLP termasuk model pengikut instruksi yang ditingkatkan untuk tugas pencarian informasi dan kerangka komputasi baru untuk memecahkan masalah aliran daya optimal arus bolak-balik (ACOPF) menggunakan unit pemrosesan grafis (GPU).
SUMBER: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Anda dapat dengan mudah beralih antara model atau mengubah sistem sesuai kebutuhan. Sebagai contoh, di sini kita beralih ke GPT-4 yang menghasilkan respons yang jauh lebih baik dan terperinci.

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))

<p>Kemajuan terbaru dalam Pengolahan Bahasa Alami (NLP) termasuk pengembangan model pengikut instruksi yang ditingkatkan untuk tugas pencarian informasi. Model ini dapat disesuaikan dengan berbagai domain informasi dan tugas tanpa perlu pelatihan tambahan. Namun, mereka sering mengalami kesulitan untuk mempertahankan pengetahuan yang diberikan dan mungkin mengalami halusinasi dalam respons mereka. Kemajuan lainnya adalah pengenalan kerangka komputasi untuk memecahkan masalah aliran daya optimal arus bolak-balik (ACOPF) menggunakan unit pemrosesan grafis (GPU). Pendekatan ini menggunakan abstraksi single-instruction, multiple-data (SIMD) dari program nonlinier (NLP) dan menggunakan metode interior-point (IPM) dengan strategi relaksasi ketidaksetaraan. Strategi ini memungkinkan faktorisasi matriks KKT tanpa pivoting numerik, yang sebelumnya menghambat paralelisasi algoritma IPM.
SUMBER: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Token dalam GPT-4 dapat sependek satu karakter atau sepanjang satu kata. Sebagai contoh, GPT-4-32K dapat memproses hingga 32.000 token dalam satu jalankan sementara GPT-4-8K dan GPT-3.5-turbo mendukung 8.000 dan 4.000 token, masing-masing. Namun, perlu diingat bahwa setiap interaksi dengan model ini datang dengan biaya yang secara langsung proporsional dengan jumlah token yang diproses, baik input maupun output.

Dalam konteks sistem pertanyaan dan jawaban kita, jika sebuah literatur akademis melebihi batas token maksimum, sistem akan gagal memprosesnya secara keseluruhan, sehingga mempengaruhi kualitas dan kelengkapan respons. Untuk mengatasi masalah ini, teks dapat dipecah menjadi bagian yang lebih kecil yang sesuai dengan batas token.

FAISS (Facebook AI Similarity Search) (META ) membantu menemukan potongan teks yang paling relevan dengan pertanyaan pengguna dengan cepat. Ini membuat representasi vektor dari setiap potongan teks dan menggunakan vektor-vektor ini untuk mengidentifikasi dan mengambil potongan yang paling mirip dengan representasi vektor dari pertanyaan yang diberikan.

Penting untuk diingat bahwa bahkan dengan menggunakan alat seperti FAISS, kebutuhan untuk membagi teks menjadi potongan yang lebih kecil karena keterbatasan token dapat terkadang menyebabkan kehilangan konteks, mempengaruhi kualitas jawaban. Oleh karena itu, manajemen dan optimasi token yang cermat sangat penting ketika bekerja dengan model bahasa besar ini.

pip install faiss-cpu langchain CharacterTextSplitter

Setelah memastikan perpustakaan di atas terinstal, jalankan

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
from langchain.text_splitter import CharacterTextSplitter
documents = get_arxiv_data(max_results=10) # Sekarang kita dapat menggunakan lebih banyak data
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
for chunk in splitter.split_text(document.page_content):
document_chunks.append(Document(page_content=chunk, metadata=document.metadata))

<p>search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())</p>

<p>chain = load_qa_with_sources_chain(OpenAI(temperature=0))</p>

<p>def print_answer(question):
print(
chain(
{
&amp;quot;input_documents&amp;quot;: search_index.similarity_search(question, k=4),
&amp;quot;question&amp;quot;: question,
},
return_only_outputs=True,
)[&amp;quot;output_text&amp;quot;]
)

Dengan kode selesai, kita sekarang memiliki alat yang kuat untuk mengajukan pertanyaan tentang literatur akademis terbaru di bidang NLP.

Kemajuan terbaru dalam NLP termasuk penggunaan jaringan saraf dalam (DNN) untuk analisis teks otomatis dan tugas NLP seperti pemeriksaan ejaan, deteksi bahasa, ekstraksi entitas, deteksi penulis, pertanyaan dan jawaban, dan tugas lainnya.
SUMBER: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Kesimpulan

Integrasi Model Bahasa Besar (LLM) ke dalam aplikasi telah mempercepat adopsi di berbagai domain, termasuk terjemahan bahasa, analisis sentimen, dan pengambilan informasi. Teknik prompt engineering adalah alat kuat dalam memaksimalkan potensi model ini, dan Langchain memimpin jalan dalam menyederhanakan tugas kompleks ini. Antarmuka standar, template prompt yang fleksibel, integrasi model yang kuat, dan penggunaan inovatif agen dan rantai memastikan hasil optimal untuk kinerja LLM.

Namun, meskipun kemajuan ini, ada beberapa tips yang perlu diingat. Ketika menggunakan Langchain, penting untuk memahami bahwa kualitas output sangat bergantung pada frasa prompt. Bereksperimen dengan gaya dan struktur prompt yang berbeda dapat menghasilkan hasil yang lebih baik. Juga, ingat bahwa Langchain mendukung berbagai model bahasa, dan setiap model memiliki kekuatan dan kelemahan. Memilih model yang tepat untuk tugas spesifik sangat penting. Terakhir, penting untuk diingat bahwa menggunakan model ini datang dengan pertimbangan biaya, karena pemrosesan token secara langsung mempengaruhi biaya interaksi.

Sebagaimana ditunjukkan dalam panduan langkah demi langkah, Langchain dapat memberdayakan aplikasi yang kuat, seperti Sistem Pertanyaan dan Jawaban Literatur Akademis. Dengan komunitas pengguna yang tumbuh dan meningkatnya kepentingan dalam lanskap sumber terbuka, Langchain berjanji untuk menjadi alat penting dalam mengoptimalkan potensi penuh dari LLM seperti GPT-4.