Memicu Revolusi AI - Sebuah Perjalanan dengan RAG dan LangChain

Artikel ini membawa pembaca dalam eksplorasi perjalanan Revolusi AI transformatif yang menginspirasi, yang memahami lebih dalam konsep revolusioner Retrieval-Augmented Generation dan LangChain.

Di era Kecerdasan Buatan (AI) ini, mengambil pengetahuan yang bermakna dari kumpulan data yang luas telah menjadi hal yang sangat penting bagi bisnis dan individu. Masuki Retrieval-Augmented Generation (RAG), sebuah terobosan yang telah meningkatkan kemampuan AI secara drastis, yang memberdayakan sistem untuk tidak hanya menghasilkan teks mirip manusia tetapi juga menarik informasi yang relevan secara real-time. Penggabungan ini menghasilkan respons yang kaya akan konteks dan detail yang presisi.

Saat kita memulai perjalanan menarik melintasi lautan luas Kecerdasan Buatan (AI), penting untuk memahami tiga pilar yang akan menjadi bintang pemandu kita: AI Generatif, Model Bahasa Besar (LLM), LangChain, Hugging Face, dan aplikasi yang berguna di RAG (Retrieval-Augmented Generation) ini.

Model Bahasa Besar dan AI Generatif: Sang Mesin Inovasi

Inti dari perjalanan kita terletak pada Model Bahasa Besar (LLM) dan AI Generatif - dua mesin ampuh yang mendorong kemajuan inovasi.

Model Bahasa Besar (LLM)

LLM, sepertiQwen, GPT, dan lainnya, adalah raksasa teks, yang mampu memahami dan menghasilkan bahasa mirip manusia dalam skala besar. Model ini telah dilatih tentang kumpulan data teks yang luas, sehingga memungkinkan model tersebut memprediksi dan menghasilkan rangkaian teks yang koheren dan relevan secara kontekstual. Model ini adalah kekuatan utama dari banyak tugas pemrosesan bahasa alami, mulai dari penerjemahan hingga pembuatan konten.

AI Generatif (GenAI)

AI Generatif adalah si genius cerdik tentang kreasi di dunia AI. AI mencakup teknologi yang menghasilkan contoh data baru yang menyerupai data pelatihan, seperti gambar, musik, dan, yang paling penting bagi perjalanan kita, teks. Dalam konteks kita, AI Generatif mengacu kepada kemampuan AI untuk menciptakan respons, cerita, atau ide baru dan informatif yang belum pernah ada sebelumnya. Hal ini memungkinkan AI untuk tidak hanya meniru masa lalu tetapi untuk menemukan, berinovasi, dan menginspirasi.

LangChain: Mengatur Gubahan AI Anda

LangChain bertindak sebagai arsitek alur kerja AI kami, yang dengan cermat merancang struktur yang memungkinkan integrasi dan interaksi tanpa hambatan antara berbagai komponen AI. Kerangka kerja ini menyederhanakan proses penyatuan aliran data yang kompleks dari subsistem cerdas, termasuk LLM dan sistem pengambilan, sehingga berbagai tugas seperti ekstraksi informasi dan pemahaman bahasa alami lebih mudah diakses dibandingkan sebelumnya.

Hugging Face: Kota Metropolitan bagi Model AI

Hugging Face muncul sebagai kota metropolitan yang ramai tempat model AI berkembang pesat. Hub pusat ini menawarkan beragam model yang telah terlatih, yang berfungsi sebagai lahan subur bagi eksplorasi dan penerapan pembelajaran mesin. Untuk mendapatkan akses ke hub ini dan sumber dayanya, Anda harus membuat akun Hugging Face. Setelah mengambil langkah ini, pintu menuju dunia AI yang luas menanti Anda — cukup kunjungi Hugging Face dan daftarkan diri untuk memulai petualangan Anda.

RAG: Memanfaatkan Basis Data Vektor untuk Kecerdasan yang Dipercepat

Retrieval-Augmented Generation (RAG) adalah teknik AI canggih yang memadukan kekuatan inventif AI Generatif dengan ketepatan pengambilan pengetahuan, sehingga menciptakan sistem yang tidak hanya mudah diartikulasikan namun juga memiliki informasi yang mendalam. Untuk membuka potensi dan efisiensi penuh dari RAG, RAG mengintegrasikan basis data vektor—alat yang efektif untuk menyaring melalui repositori informasi yang luas dengan cepat. Berikut rincian lebih lanjut tentang cara RAG beroperasi dengan basis data vektor:

Pengambilan dengan Basis Data Vektor: RAG memulai prosesnya dengan mengkueri basis data vektor, yang menampung representasi tersemat dari kumpulan informasi yang besar. Penyematan ini merupakan vektor berdimensi tinggi yang merangkum esensi semantik dokumen atau cuplikan data. Basis data vektor memungkinkan RAG melakukan penelusuran secepat kilat di seluruh penyematan ini untuk menentukan konten yang paling relevan dengan kueri tertentu, seperti AI yang dengan cepat menjelajahi pustaka digital untuk menemukan buku yang tepat.
Augmentasi dengan Konteks: Informasi relevan yang diambil dari basis data vektor kemudian disediakan bagi model generatif sebagai augmentasi kontekstual. Langkah ini membekali AI dengan sejumlah pengetahuan terkonsentrasi, yang meningkatkan kemampuannya untuk mennyusun respons yang tidak hanya kreatif tetapi juga kaya dan tepat secara kontekstual.
Pembuatan Respons sesuai Informasi: Berbekal konteks tersebut, model generatif melanjutkan proses untuk menghasilkan teks. Tidak seperti model generatif standar yang hanya mengandalkan pola yang dipelajari, RAG memadukan hal-hal spesifik dari data yang diambil, sehingga menghasilkan output yang imajinatif dan didukung oleh pengetahuan yang diambil. Dengan demikian, pembuatan ini ditingkatkan, sehingga menghasilkan tanggapan yang lebih akurat, informatif, dan mencerminkan konteks sebenarnya.

Integrasibasis data vektor adalah kunci menuju efisiensi RAG. Metode pencarian metadata tradisional mungkin lebih lambat dan kurang presisi, tetapi basis data vektor memfasilitasi pengambilan informasi yang relevan secara kontekstual dalam sekejap, bahkan dari kumpulan data yang sangat besar. Pendekatan ini tidak hanya menghemat waktu yang berharga tetapi juga memastikan bahwa respons AI didasarkan pada informasi yang paling tepat dan terkini yang tersedia.

Keahlian RAG sangat berguna dalam aplikasi seperti chatbot, asisten digital, dan alat riset canggih — di mana pun penyampaian informasi yang tepat, andal, dan berdasarkan konteks sangatlah penting. Ini bukan hanya tentang menyusun respons yang terdengar meyakinkan; ini tentang menghasilkan konten yang didasarkan pada data yang dapat diverifikasi dan pengetahuan dunia nyata.

Berbekal pemahaman yang diperkaya tentang LangChain, Hugging Face, LLM, GenAI, dan RAG yang disempurnakan dengan basis data vektor, kita berada di ambang petualangan pengodean yang akan menghidupkan teknologi ini. Skrip Python yang akan kita pelajari merepresentasikan sinergi elemen-elemen ini, menunjukkan sistem AI yang mampu merespons tidak hanya dengan kreativitas dan konteks, tetapi juga dengan pemahaman mendalam yang pernah dianggap sebagai ranah fiksi ilmiah. Bersiaplah untuk membuat kode dan rasakan kekuatan transformatif RAG dengan basis data vektor.

Mulai Perjalanan Pengodean

Sebelum Anda Memulai: Poin Penting

Sebelum kita memulai pengembaraan teknologi ini, pastikan Anda sudah menyiapkan semuanya:

Server Linux akan lebih baik jika dilengkapi dengan kartu GPU – karena jelas, kecepatan adalah yang terpenting.
Python 3.6 atau lebih tinggi – tongkat ajaib dalam pemrograman.
pip atau Anaconda – pengelola paket keren Anda yang praktis.
jika dengan kartu GPU, maka driver NVIDIA, CUDA Toolkit, dan cuDNN – tiga pilar kunci untuk akselerasi GPU.

Anda punya semuanya? Luar biasa! Mari kita terjun ke dalam (tentu saja hanya kiasan).

Menjalankan Kode

Dengan mengelola dependensi Python secara hati-hati, Anda memastikan bahwa proyek AI Anda dibangun di atas fondasi yang stabil dan andal. Dengan dependensi yang ada dan lingkungan yang dikonfigurasi dengan benar, Anda siap menjalankan skrip dan menyaksikan kekuatan RAG dan LangChain beraksi.

Sekarang, Anda dapat menjalankan skrip Python untuk melihat RAG beraksi.

Mengatur Tahap: Impor Pustaka dan Muat Variabel

Sebelum kita dapat memulai eksplorasi AI dengan kerangka LangChain dan pustaka Transformers Hugging Face, lingkungan yang aman dan terkonfigurasi dengan baik harus dibangun. Persiapan ini melibatkan impor pustaka yang diperlukan dan pengelolaan informasi sensitif seperti kunci API melalui variabel lingkungan.

from torch import cuda
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
from transformers import AutoModelForCausalLM, AutoTokenizer
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import pipeline
from dotenv import load_dotenv

load_dotenv()

Saat bekerja dengan model AI dari Hugging Face, Anda sering kali memerlukan akses ke API Hugging Face, yang memerlukan kunci API. Kunci ini adalah pengidentifikasi unik Anda saat mengajukan permintaan ke layanan Hugging Face, yang memungkinkan Anda memuat model dan menggunakannya dalam aplikasi Anda.

Berikut apa yang perlu Anda lakukan untuk menyiapkan lingkungan Anda dengan aman:

Dapatkan Kunci API Hugging Face Anda: Setelah Anda membuat akun Hugging Face, Anda dapat menemukan kunci API di pengaturan akun Anda di bagian 'Token Akses'.
Amankan Kunci API Anda: Kunci API Anda merupakan informasi sensitif dan harus tetap bersifat privat. Daripada melakukan pengodean permanen ke dalam skrip, Anda sebaiknya menggunakan variabel lingkungan.
Buat File .env: Buat file bernama .env File ini akan menyimpan variabel lingkungan Anda.
Tambahkan Kunci API Anda ke File .env: Buka file .env dengan editor teks dan tambahkan kunci API Hugging Face Anda dalam format berikut:

HUGGINGFACE_API_KEY=your_api_key_here

Ganti your_api_key_here dengan kunci API sebenarnya yang Anda peroleh dari Hugging Face.

Tentukan Jalur dan Konfigurasi Model

modelPath = "sentence-transformers/all-mpnet-base-v2"
device = 'cuda' if cuda.is_available() else 'cpu'
model_kwargs = {'device': device}

Di sini, kita mengatur jalur ke model terlatih yang akan digunakan untuk penyematan. Kita juga mengonfigurasi pengaturan perangkat, memanfaatkan GPU jika tersedia untuk komputasi yang lebih cepat, atau menetapkan default ke CPU.

Inisialisasi Penyematan Hugging Face dan Penyimpanan Vektor FAISS

embeddings = HuggingFaceEmbeddings(
    model_name=modelPath,
    model_kwargs=model_kwargs,
)

# Data dibuat-buat, hanya untuk main, tapi entah di masa depan
vectorstore = FAISS.from_texts(
    ["Harrison bekerja di Alibaba Cloud"], embedding=embeddings
)

retriever = vectorstore.as_retriever()

Kita memulai instans HuggingFaceEmbeddings dengan model dan konfigurasi pilihan kita. Kemudian, kita membuat penyimpanan vektor menggunakan FAISS, agar kita dapat melakukan pencarian kesamaan secara efisien di ruang berdimensi tinggi. Kita juga membuat instans pengambil yang akan mengambil informasi berdasarkan penyematan.

Siapkan Templat Prompt Obrolan

template = """Jawab pertanyaan hanya berdasarkan konteks berikut:
{context}Pertanyaan: {question}
"""

prompt = ChatPromptTemplate.from_template(template)

Di sini, kita menententukan templat perintah obrolan yang akan digunakan untuk menyusun interaksi dengan AI. Templat ini mencakup placeholder untuk konteks dan pertanyaan, yang akan diisi secara dinamis selama menjalankan rantai.

Menyiapkan Tokenizer dan Model Bahasa

Dalam dunia AI dan pemrosesan bahasa alami, tokenizer dan model bahasa adalah pasangan dinamis yang mengubah teks menjadi tindakan bermakna. Tokenizer mengurai bahasa menjadi beberapa bagian yang dapat dipahami oleh model, sedangkan model bahasa memprediksi dan menghasilkan bahasa berdasarkan input ini. Dalam perjalanan ini, kita menggunakan kelas AutoTokenizer dan AutoModelForCausalLM Hugging Face untuk memanfaatkan kemampuan ini. Namun, harus diingat bahwa satu ukuran tidak cocok untuk semua ketika memilih model bahasa.

Ukuran Model dan Sumber Daya Komputasi

Ukuran model adalah faktor penting untuk dipertimbangkan. Model yang lebih besar seperti Qwen-72B memiliki lebih banyak parameter, yang secara umum berarti model dapat memahami dan membuat teks yang lebih bernuansa. Namun, model tersebut juga membutuhkan lebih banyak daya komputasi. Jika memiliki GPU kelas atas dan memori yang cukup, Anda dapat memilih model yang lebih besar ini untuk memaksimalkan kemampuan model tersebut.

Di sisi lain, model yang lebih kecil seperti Qwen-1.8B jauh lebih dapat dikelola untuk lingkungan komputasi standar. Bahkan model kecil ini harus dapat berjalan di IoT dan perangkat seluler. Meskipun model ini mungkin tidak memahami seluk-beluk bahasa sebaik model lainnya yang lebih besar, model ini tetap memberikan performa istimewa dan lebih mudah diakses oleh mereka yang tidak memiliki perangkat keras khusus.

Model Khusus Tugas

Poin lain yang perlu dipertimbangkan adalah sifat dari tugas Anda. Jika Anda membuat AI percakapan, menggunakan model khusus obrolan seperti Qwen-7B-Chat dapat memberikan hasil yang lebih baik karena model ini disesuaikan untuk dialog dan dapat menangani nuansa percakapan dengan lebih baik daripada model dasar.

Biaya Inferensi

Model yang lebih besar tidak hanya menuntut lebih banyak dari perangkat keras Anda, tetapi mungkin juga menimbulkan biaya lebih tinggi jika Anda menggunakan layanan berbasis cloud untuk menjalankan model Anda. Setiap inferensi memerlukan waktu pemrosesan dan sumber daya, yang dapat bertambah jika Anda bekerja dengan model yang sangat besar.

Seri Qwen

Qwen-1.8B: Model yang lebih kecil cocok untuk tugas yang membutuhkan lebih sedikit daya komputasi. Bagus untuk membuat prototipe dan berjalan di mesin tanpa GPU kuat.
Qwen-7B: Model berukuran sedang yang menyeimbangkan performa dengan tuntutan komputasi. Cocok untuk berbagai tugas, termasuk pembuatan teks dan menjawab pertanyaan.
Qwen-14B: Model yang lebih besar yang dapat menangani tugas yang lebih kompleks dengan nuansa yang lebih luas dalam pemahaman dan pembuatan bahasa.
Qwen-72B: Model terbesar di seri ini, menawarkan performa mutakhir untuk aplikasi AI canggih yang membutuhkan pemahaman bahasa yang mendalam.
Qwen-1.8B-Chat: Sebuah model percakapan yang dirancang khusus untuk membangun chatbots dan sistem dialog lainnya.
Qwen-7B-Chat: Mirip dengan Qwen-1.8B-Chat, tetapi dengan peningkatan kapasitas untuk menangani dialog yang lebih kompleks.
Qwen-14B-Chat: Model percakapan kelas atas yang mampu berinteraksi dengan dialog yang canggih.
Qwen-72B-Chat: Model percakapan paling canggih dalam seri Qwen, memberikan performa yang luar biasa bagi aplikasi obrolan yang menuntut.

Membuat Pilihan

Saat memutuskan model mana yang akan digunakan, pertimbangkan manfaat model yang lebih besar berdasarkan sumber daya yang tersedia dan kebutuhan spesifik proyek Anda. Jika Anda baru saja memulai atau mengembangkan dalam skala yang lebih kecil, model yang lebih kecil mungkin menjadi pilihan terbaik. Seiring berkembangnya kebutuhan Anda, atau jika Anda memerlukan kemampuan yang lebih canggih, pertimbangkan untuk pindah ke model yang lebih besar.

Ingat, seri Qwen adalah sumber terbuka, sehingga Anda dapat bereksperimen dengan model berbeda untuk melihat mana yang paling cocok dengan proyek Anda. Berikut tampilan bagian pemilihan model skrip jika Anda memutuskan untuk menggunakan model lain:

# Ini dapat diubah ke model Qwen mana pun berdasarkan kebutuhan dan sumber daya Andatokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-7B", trust_remote_code=True)model_name_or_path = "Qwen/Qwen-7B"model = AutoModelForCausalLM.from_pretrained(model_name_or_path,
                                             device_map="auto",
                                             trust_remote_code=True)

Kita memuat tokenizer dan model bahasa kausal dari Hugging Face masing-masing dengan kelas AutoTokenizer dan AutoModelForCausalLM. Komponen-komponen ini sangat penting untuk memproses input bahasa alami dan menghasilkan output.

Buat Alur Pembuatan Teks

Alur ini dirancang untuk menghasilkan teks menggunakan model bahasa dan tokenizer yang telah dimuat sebelumnya. Mari kita uraikan parameternya dan pahami perannya dalam mengendalikan perilaku pembuatan teks:

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=8192,
    do_sample=True,
    temperature=0.7,
    top_p=0.95,
    top_k=40,
    repetition_penalty=1.1
)

hf = HuggingFacePipeline(pipeline=pipe)

Penjelasan Parameter dalam Alur Pembuatan Teks:

max_new_token (8192): Parameter ini menentukan jumlah maksimum token yang dapat dihasilkan dalam output. Token bisa berupa kata-kata, karakter, atau subkata, tergantung tokenizer.
do_sample (True): Jika diatur ke True, parameter ini mengaktifkan pengambilan sampel probabilistik dari distribusi kemungkinan token berikutnya yang dihasilkan oleh model. Hal ini menimbulkan keacakan dan variasi dalam teks yang dihasilkan. Jika diatur ke False, model akan selalu memilih token berikutnya yang paling mungkin, sehingga menghasilkan output yang deterministik dan kurang bervariasi.
temperatur (0.7): Parameter temperatur mengontrol seberapa banyak keacakan yang dimasukkan ke dalam proses pengambilan sampel. Nilai temperatur yang lebih rendah (mendekati 0) membuat model lebih percaya diri dalam memilih, sehingga menghasilkan outup yang kurang acak, sedangkan nilai temperatur yang lebih tinggi (mendekati 1) mendorong lebih banyak keacakan dan keragaman.
top_p (0.95): Parameter ini mengontrol pengambilan sampel inti, sebuah teknik yang hanya mempertimbangkan token paling mungkin dengan probabilitas kumulatif di atas ambang batas top_p. Ini membantu dalam menghasilkan teks yang beragam dan koheren, yang menghindari penyertaan token dengan probabilitas sangat rendah yang dapat membuat teks menjadi tidak masuk akal.
top_k (40): Pengambilan sampel top-k membatasi kumpulan pengambilan sampel ke k token berikutnya yang paling mungkin terjadi. Hal ini semakin menyempurnakan kumpulan token yang akan dipertimbangkan model untuk menghasilkan teks berikutnya, memastikan bahwa output-nya tetap relevan dan koheren.
repetition_penalty (1.1): Parameter ini mendorong model untuk tidak mengulangi token atau frasa yang sama, mempromosikan teks yang lebih menarik dan beragam. Nilai yang lebih dari 1 dikenai penaliti sehingga mengurangi kemungkinan token yang sudah muncul.

Setelah meyiapkan alur dengan parameter yang diinginkan, kode untuk baris berikutnya adalah:

hf = HuggingFacePipeline(pipeline=pipe)

Menggabungkan objek alur dalam HuggingFacePipeline. Kelas ini adalah bagian dari kerangka LangChain dan memungkinkan alur diintegrasikan tanpa hambatan ke dalam alur kerja LangChain untuk membangun aplikasi AI. Dengan menggabungkan alur, kita sekarang dapat menggunakannya bersama komponen LangChain lainnya, seperti retriever dan parser, untuk menciptakan sistem AI yang lebih kompleks.

Pemilihan parameter ini secara cermat memungkinkan Anda menyempurnakan perilaku pembuatan teks agar sesuai dengan kebutuhan spesifik aplikasi Anda, baik Anda mencari output yang lebih kreatif dan bervariasi atau menginginkan teks yang koheren dan terfokus secara konsisten.

Bangun dan Jalankan Rantai RAG

Cuplikan kode di bawah ini merepresentasikan sistem RAG menyeluruh yang lengkap di mana pertanyaan awal mendorong pencarian informasi yang relevan, yang kemudian digunakan untuk meningkatkan proses generatif, sehingga menghasilkan jawaban yang sesuai informasi dan relevan secara kontekstual terhadap pertanyaan input.

1. Susunan Rantai:

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | hf
    | StrOutputParser()
)

Berikut adalah yang terjadi di bagian kode ini:

Retriever digunakan untuk mengambil informasi yang relevan berdasarkan kueri. Peran retriever adalah menyisir kumpulan data atau kumpulan dokumen untuk menemukan potongan informasi yang paling relevan dengan pertanyaan yang diajukan. Ini mungkin menggunakan basis data vektor demi efisiensi.
_RunnablePassthrough() _adalah komponen yang hanya melewati pertanyaan tanpa pengubahan apa pun. Ini menunjukkan bahwa rantai dirancang untuk menangani pertanyaan secara langsung, mungkin karena dimasukkan oleh pengguna.
Perintah tidak ditampilkan secara detail di sini, tetapi kemungkinan berfungsi sebagai templat atau serangkaian instruksi yang memformat pertanyaan input dan konteks yang diambil dengan cara yang sesuai untuk tahap berikutnya dalam alur, yaitu model Hugging Face.
Variabel hf merepresentasikan alur Hugging Face, yang mungkin merupakan model bahasa terlatih yang mampu menghasilkan respons. Alur ini akan mengambil input terformat dari langkah sebelumnya dan menggunakan kemampuan generatif untuk menghasilkan jawaban.
StrOutputParser() adalah parser output, dan tugasnya adalah mengambil output mentah dari alur Hugging Face dan menguraikannya ke dalam format yang lebih ramah pengguna, mungkin berupa string.

Penggunaan operator | (pipa) menunjukkan bahwa kode ini menggunakan gaya pemrograman fungsional, khususnya konsep komposisi fungsi atau pola alur dengan output dari satu fungsi menjadi input untuk fungsi berikutnya.

2. Pemanggilan Rantai:

results = chain.invoke("Di mana Harrison bekerja?")

Pada baris ini, rantai akan dipanggil dengan pertanyaan tertentu:_"Di mana Harrison bekerja?"_ Pemanggilan ini memicu seluruh urutan operasi yang ditentukan dalam rantai. Retriever mencari informasi yang relevan, yang kemudian diteruskan bersama pertanyaan melalui perintah dan ke dalam model Hugging Face. Model menghasilkan respons berdasarkan input yang diterima.

3.& nbsp;Mencetak Hasil:

print(results)

Respons yang dihasilkan kemudian diuraikan oleh StrOutputParser() dan dikembalikan sebagai hasil akhir, yang kemudian dicetak ke konsol atau output lainnya.

Terakhir, kita menyusun rantai RAG dengan menautkan retriever, templat perintah, alur Hugging Face, dan parser output. Kita memanggil rantai dengan pertanyaan, dan hasilnya dicetak.

Kesimpulan: Gerbang Anda untuk Menguasai AI

Anda baru saja melakukan lompatan besar ke dunia AI dengan RAG dan LangChain. Dengan memahami dan menjalankan kode ini, Anda membuka potensi untuk menciptakan sistem cerdas yang dapat menalar dan berinteraksi dengan informasi dengan cara yang belum pernah ada sebelumnya.

Artikel ini aslinya ditulis dalam bahasa Inggris. Lihat artikel asli di sini.

Community