Kembangkan Alat Chat QA Anda dengan teknologi terkini dalam penelitian AI.
Kita berada di tahun dimana LLM telah digunakan secara besar-besaran oleh banyak perusahaan. Mulai dari search engine sederhana hingga chatbot yang ekstensif, LLM telah memenuhi semua kebutuhan bisnis sekarang ini.
Salah satu alat yang sering dibutuhkan oleh bisnis adalah alat Question-Answering (QA). Ini adalah alat bertenaga AI yang dapat dengan cepat menjawab pertanyaan yang dimasukkan pengguna.
Dalam artikel ini, kita akan mengembangkan alat QA yang didukung LLM dengan RAG dan kemampuan text-to-speech (TTS). Bagaimana kita bisa melakukan itu? Mari kita mulai.
Semua kode dalam artikel ini dapat diakses melalui repository ini.
Struktur Proyek
Untuk proyek ini, kita akan mengikuti struktur di bawah ini.
Berikut langkah-langkah yang akan dilakukan pada proyek ini:
Deploy Open-Source Weaviate Vector Database dengan Docker.
Membaca file PDF Insurance Handbook dan menggunakan Embedding Model yang dihosting secara publik dari HuggingFace untuk menyematkan data.
Menyimpan embedding ke dalam Weaviate Vector Store (Knowledge Base).
Mengembangkan sistem RAG dengan Embedding dan Generative Model yang dihosting secara publik dari HuggingFace
Menggunakan Model ElevenLabs Text-to-Speech untuk mengubah output RAG menjadi audio.
Membuat front-end dengan Streamlit.
Secara umum, ada 6 langkah yang akan kita ikuti untuk membuat alat QA dengan RAG dan TTS. Mari kita mulai.
Persiapan
Sebelum memulai, kita akan menyiapkan beberapa file Python yang berisi semua persyaratan agar aplikasi kita dapat berjalan dengan baik.
Pertama, kita memerlukan token akses HuggingFace API karena kita akan menggunakan model yang dihosting di sana. Jika Anda sudah terdaftar dengan HuggingFace, Anda bisa mendapatkannya di halaman token.
Selain itu, kita akan menggunakan ElevenLabs untuk model Text-to-Speech. Jadi, daftar akun gratis di sana dan dapatkan API key.
Dengan kedua API key di tangan Anda, Anda perlu membuat file .env untuk menyimpan key-nya. Isi file dengan kode berikut.
ELEVENLABS_API_KEY= 'Your-ElevenLabs-API'
HUGGINGFACEHUB_API_TOKEN = 'Your-HuggingFace-API'Selanjutnya, kita akan menyiapkan lingkungan dengan menginstal semua paket yang diperlukan.
pip install langchain langchain-community langchain-core weaviate-client elevenlabs streamlit python-dotenv huggingface_hub sentence-transformersSemua persiapan telah selesai, mari kita mulai membuat aplikasi.
Deploy Weaviate Vector Database
Untuk tutorial ini, Anda perlu menginstal Docker Desktop. Anda bisa mengunduh pengaturannya di situs web Docker jika belum menginstallnya.
Untuk men-deploy Weaviate Vector Database dengan mudah, kita akan mengikuti rekomendasi pengaturan dari Weaviate. Dalam proses deployment, kita akan menggunakan docker-compose untuk deploy, yang dapat Anda lihat pada kode di bawah ini.
version: '3.4'
services:
weaviate:
command:
- --host
- 0.0.0.0
- --port
- '8081'
- --scheme
- http
image: cr.weaviate.io/semitechnologies/weaviate:1.24.10
ports:
- 8081:8081
- 50051:50051
volumes:
- weaviate_data:/var/lib/weaviate
restart: on-failure:0
environment:
QUERY_DEFAULTS_LIMIT: 25
AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true'
PERSISTENCE_DATA_PATH: '/var/lib/weaviate'
DEFAULT_VECTORIZER_MODULE: 'none'
ENABLE_MODULES: 'text2vec-cohere,text2vec-huggingface,text2vec-palm,text2vec-openai,generative-openai,generative-cohere,generative-palm,ref2vec-centroid,reranker-cohere,qna-openai'
CLUSTER_HOSTNAME: 'node1'
volumes:
weaviate_data:Di environment Anda, buat file bernama docker-compose.yml dan salin kode di atas. Pada kode di atas, kita akan menarik image dari Weaviate dan memiliki semua modul terkait. Kode di atas juga akan menyediakan persistensi data dengan PERSISTENCE_DATA_PATH. Weaviate Vector store juga diekspos di port 8081.
Setelah semuanya siap, jalankan kode berikut di terminal Anda.
docker-compose up
Anda akan melihat container seperti di atas di Docker Desktop. Dengan ini, kita sudah menyiapkan database vektor open-source kita.
Membangun Insurance Handbook Knowledge Base
Bagian selanjutnya dari proyek kita adalah membangun knowledge base menggunakan LangChain, HuggingFace, dan Weaviate. Bagian ini bertujuan untuk memiliki database vektor yang diisi dengan hasil embedding dari Insurance Handbook yang dapat diakses dari aplikasi.
Pertama, kita akan mengatur klien Weaviate dan Embedding model. Kita dapat mengaturnya dengan kode berikut.
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Weaviate
import weaviate
client = weaviate.Client(
url="http://localhost:8081",
)
model_name = "sentence-transformers/all-mpnet-base-v2"
model_kwargs = {'device': 'cpu'}
encode_kwargs = {'normalize_embeddings': False}
hf = HuggingFaceEmbeddings(
model_name=model_name,
model_kwargs=model_kwargs,
encode_kwargs=encode_kwargs
)Pada kode di atas, kita akan mengatur klien Weaviate dengan menghubungkan ke localhost:8081 dan embedding model HuggingFace menggunakan model mpnet sentence transformer sederhana.
Selanjutnya, kita akan membaca PDF Insurance Handbook dengan LangChain dan membagi data teks menjadi potongan-potongan tertentu.
loader = PyPDFLoader("Insurance_Handbook_20103.pdf")
pages = loader.load_and_split()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=50,
length_function=len,
is_separator_regex=False,
)
texts = text_splitter.split_documents(pages)
full_texts = [i.page_content for i in texts]Membagi data teks penting karena membantu mengatasi batasan ukuran teks model dan memastikan bahwa setiap segmen teks bermakna dan lengkap secara kontekstual. Cobalah untuk mengubah-ubah parameter chunk_size dan chunk_overlap jika Anda merasa hasilnya kurang baik.
Terakhir, kita akan menyimpan data teks yang disematkan di Weaviate Vector Database dengan kode berikut.
vector_db = Weaviate.from_texts(
full_texts,hf, client=client, by_text=False,
index_name='BookOfInsurance', text_key='intro'
)Dengan ini, kita sudah memiliki knowledge base. Kita bisa melakukan similarity search menggunakan kode berikut jika Anda ingin menguji database.
print(vector_db.similarity_search("What is expense ratio?", k=3))Terakhir, jangan lupa untuk menutup klien Weaviate.
client.close()Mengembangkan Alat QA yang Didukung LLM dengan RAG dan text-to-speech (TTS)
Sebelum membuat alatnya, kita perlu mengatur beberapa file utility.
Pengaturan File Utility
Pertama, kita akan mengatur koneksi model Generatif LLM dengan LangChain dan HuggingFace. Saat artikel ini ditulis, ada bug selama proses koneksi, jadi kita perlu mengembangkan lazy connection untuk menghindari error pada token HuggingFace.
Saya menaruh file tersebut di folder yang disebut utils dan menamai file tersebut hf_lazyclass.py. Masukkan seluruh kode di bawah ini ke dalam file tersebut.
from langchain_community.llms.huggingface_endpoint import HuggingFaceEndpoint
from langchain_core.pydantic_v1 import root_validator
from langchain_core.utils import get_from_dict_or_env
class LazyHuggingFaceEndpoint(HuggingFaceEndpoint):
"""LazyHuggingFaceEndpoint"""
@root_validator()
def validate_environment(cls, values):
"""Validate that package is installed; SKIP API token validation."""
try:
from huggingface_hub import AsyncInferenceClient, InferenceClient
except ImportError:
msg = (
"Could not import huggingface_hub python package. "
"Please install it with `pip install huggingface_hub`."
)
raise ImportError(msg) # noqa: B904
huggingfacehub_api_token = get_from_dict_or_env(
values, "huggingfacehub_api_token", "HUGGINGFACEHUB_API_TOKEN"
)
values["client"] = InferenceClient(
model=values["model"],
timeout=values["timeout"],
token=huggingfacehub_api_token,
**values["server_kwargs"],
)
values["async_client"] = AsyncInferenceClient(
model=values["model"],
timeout=values["timeout"],
token=huggingfacehub_api_token,
**values["server_kwargs"],
)
return valuesSelanjutnya, saya juga akan membuat file kelas Text-to-Speech, yang saya beri nama tts_speech.py.
import os
import uuid
from elevenlabs import VoiceSettings
from elevenlabs.client import ElevenLabs
ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
client = ElevenLabs(
api_key=ELEVENLABS_API_KEY,
)
def text_to_speech_file(text: str) -> str:
# Memanggil API konversi text_to_speech dengan parameter terperinci
response = client.text_to_speech.convert(
voice_id="pNInz6obpgDQGcFmaJgB", # Adam pre-made voice
optimize_streaming_latency="0",
output_format="mp3_22050_32",
text=text,
model_id="eleven_turbo_v2", # use the turbo model for low latency, for other languages use the `eleven_multilingual_v2`
voice_settings=VoiceSettings(
stability=0.0,
similarity_boost=1.0,
style=0.0,
use_speaker_boost=True,
),
)
save_file_path = f"{uuid.uuid4()}.mp3"
# Writing udio ke file
with open(save_file_path, "wb") as f:
for chunk in response:
if chunk:
f.write(chunk)
print(f"{save_file_path}: A new audio file was saved successfully!")
return save_file_pathPada kode di atas, kita menggunakan suara Pre-Made, tetapi Anda dapat mencoba menemukan suara yang sesuai untuk alat di ElevenLabs Voice Lab.
Dengan semua yang sudah siap, kita akan mengatur alat tersebut.
Mengembangkan Alat
Bagian ini akan menggabungkan semuanya ke dalam Front-End Streamlit dengan model RAG dan TTS.
Pertama, kita akan mengatur koneksi Model Generatif untuk RAG dan Weaviate Vector database.
import streamlit as st
import weaviate
from langchain_community.vectorstores import Weaviate
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain.chains import RetrievalQA
from dotenv import load_dotenv
import os
from utils.hf_lazyclass import LazyHuggingFaceEndpoint
from utils.tts_speech import text_to_speech_file
load_dotenv()
hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
client = weaviate.Client(
url="http://localhost:8081",
)
repo_id = "mistralai/Mistral-7B-Instruct-v0.2"
llm = LazyHuggingFaceEndpoint(
repo_id=repo_id, max_new_tokens=128, temperature=0.5, huggingfacehub_api_token = hf_token
)
model_name = "sentence-transformers/all-mpnet-base-v2"
model_kwargs = {'device': 'cpu'}
encode_kwargs = {'normalize_embeddings': False}
hf = HuggingFaceEmbeddings(
model_name=model_name,
model_kwargs=model_kwargs,
encode_kwargs=encode_kwargs
)Kita menginisiasi Klien Weaviate, model LLM Generatif, dan embedding model HuggingFace dalam kode di atas. Pada contoh ini, saya akan menggunakan model Mistral Instruct LLM untuk model Generative LLM.
Selanjutnya kita setup sistem RAG dengan kode berikut.
response = client.schema.get()
weaviate_vectorstore = Weaviate(client=client,
index_name=response['classes'][0]['class'],
text_key="intro",by_text = False, embedding=hf)
retriever = weaviate_vectorstore.as_retriever()
qa_chain = RetrievalQA.from_chain_type(
llm=llm, chain_type="stuff", retriever = retriever
)Terakhir, kita mengatur file Streamlit untuk menerima input teks dan memberikan output audio dengan kode berikut.
st.title('Insurance Handbook QA with Voice')
st.write("""
This is a simple application where we utilize RAG and Text-to-Speech to answer all your queries regarding Insurance.
In this application, we use the following tech stack:
1. Weaviate Vector Database with Docker Hosting
2. LangChain LLM Framework
3. HuggingFace Embedding Model all-mpnet-base-v2
4. HuggingFace Generative Model Mistral-7B-Instruct-v0.2
5. Elevenlabs Text-to-Speech Model
6. Streamlit for Front-End
""")
if 'prompt' not in st.session_state:
st.session_state.prompt = ''
if 'audiofile' not in st.session_state:
st.session_state.audiofile = ''
query = st.text_input("Ask Your Insurance Question👇", "")
if st.button("Answer my Question"):
st.session_state.prompt = query
response = qa_chain.invoke(query)
st.session_state.audiofile = text_to_speech_file(response['result'])
st.audio(st.session_state.audiofile, format="audio/mpeg", loop = False)Jika semuanya berjalan dengan baik, mari kita jalankan file Streamlit. Anda akan melihat halaman seperti gambar di bawah ini.
Mari kita coba alatnya. Misalnya, saya akan bertanya, “”What is the definition of Admitted Company?”. Hasilnya adalah file audio yang akan saya sematkan di bawah ini.
Anda dapat mengubah model, suara, dan halaman front-end untuk membuatnya lebih menarik. Anda juga bisa membangun Knowledge Base Anda sendiri untuk bidang yang Anda diinginkan.
Kesimpulan
Kita telah mengeksplorasi cara membangun alat QA kita dengan RAG dan Text-to-Speech. Dengan menggunakan kombinasi alat dan model open-source, kita bisa membangun alat canggih yang diinginkan oleh bisnis.
留言