Tutorial Lengkap Databricks Dolly untuk Membangun Aplikasi

Menangani data secara manual dapat menunda hasil dan memperlambat kemajuan proyek. Itulah sebabnya data engineer dan analis selalu mencari LLM yang lebih cepat dan lebih murah untuk menangani tugas harian.

Dolly adalah model AI open-source dari Databricks yang, antara lain, dapat membantu analis, engineer, dan profesional lainnya meringankan pekerjaan mereka di berbagai industri. Karena bersifat open-source, siapa pun dapat menggunakan kode pelatihannya untuk membangun LLM yang lebih baik dan lebih disesuaikan dengan kebutuhan mereka.

Mari pelajari lebih lanjut dalam tutorial Databricks Dolly ini.

Mengapa Databricks Dolly?

Yang membuat Databricks Dolly menjadi alternatif yang hebat dibandingkan alat lain adalah pendekatannya dalam membangun solusi kustom untuk perusahaan dari berbagai ukuran. Dolly mengubah LLM dari teknologi eksklusif berbiaya tinggi menjadi alat serbaguna yang dapat dimiliki dan disesuaikan oleh setiap perusahaan.

Sumber: Databricks

Manfaat Dolly

Berikut cara Dolly dapat membantu Anda:

• Kustomisasi: Mengustomisasi LLM sesuai kebutuhan organisasi Anda, sehingga lebih mudah mengelola alur kerja.
• Hemat biaya: Memfasilitasi pembuatan model instruction-following yang disesuaikan dengan murah dan efisien.
• Gesit: Memberdayakan bisnis untuk mengoptimalkan alur kerja data, mengotomatiskan proses kompleks, dan menghasilkan insight dengan lebih efektif.
• Dapat diakses: Meningkatkan efisiensi operasional dengan membuat AI tingkat lanjut lebih mudah diakses dan dapat diadaptasi untuk kasus penggunaan bisnis.
• Aman: Menyediakan solusi yang layak untuk mengembangkan aplikasi AI tanpa memicu masalah keamanan data atau kepatuhan yang umum terkait alat yang bergantung pada API.

Ingin mempelajari lebih lanjut mengenai kemampuan model bahasa berskala besar? Ikuti kursus konsep LLM ini.

Mulai Menggunakan Databricks Dolly

Sekarang, mari lihat bagaimana Anda dapat memanfaatkan Dolly sebaik mungkin untuk kebutuhan Anda.

Gambaran Fungsionalitas Databricks Dolly

Dolly di-fine-tune pada dataset khusus databricks-dolly-15k untuk membuka fungsi yang mirip dengan model yang lebih besar seperti GPT. Karena itu, Anda dapat membuat LLM kustom untuk brainstorming ide, menghasilkan teks, dan melakukan tugas tertentu sesuai perintah.

Menyiapkan Lingkungan Anda di Databricks Dolly

Ikuti instruksi berikut untuk menyiapkan lingkungan Databricks Dolly Anda untuk menghasilkan respons.

Jika Anda memiliki mesin dengan GPU A100, Anda dapat menggunakan model ini dengan pustaka transformers.

Langkah 1: Jalankan kode berikut di notebook Databricks Anda untuk memasang pustaka transformers dan accelerate:

%pip install "accelerate>=0.16.0,<1" "transformers[torch]>=4.28.1,<5" "torch>=1.13.1,<2"Didukung oleh

Langkah 2: Berikutnya impor pipeline dari pustaka transformers:

from transformers import pipeline
import torch
instruct_pipeline = pipeline(model="databricks/dolly-v2-12b", torch_dtype=torch.bfloat16, trust_remote_code=True, device_map="auto")Didukung oleh

Langkah 3: Lalu, Anda dapat menghasilkan respons dari pipeline:

instruct_pipeline("Explain to me the difference between nuclear fission and fusion.")Didukung oleh

Bekerja dengan Databricks Dolly LLM

Operasi dasar dengan Dolly

Berikut beberapa operasi dasar yang dapat Anda lakukan dengan Dolly:

Pembuatan teks

• Penulis dan pembuat konten dapat menghasilkan draf, kerangka, atau tulisan lengkap tentang topik apa pun. Ini akan menghemat waktu dan upaya dalam proses penulisan.
• Bisnis dan pemasar dapat membuat copy yang menarik, deskripsi produk, atau kampanye pemasaran.

Perbedaan antara hasil model asli dan hasil fine-tuned Dolly. [Sumber: Databricks]

Brainstorming

• Wirausahawan dan pemimpin bisnis dapat mengeksplorasi produk, layanan, atau model bisnis baru yang potensial.
• Penulis, seniman, dan desainer dapat menggunakan Dolly untuk inspirasi dan ide-ide istimewa guna memicu proyek kreatif mereka.
• Anda bahkan dapat melakukan brainstorming ide dalam konteks pribadi untuk merencanakan acara atau mengatasi tantangan sehari-hari.

Perbedaan antara hasil model asli dan hasil fine-tuned Dolly. [Sumber: Databricks]

Tanya jawab terbuka

• Siswa dapat mengajukan pertanyaan dan menerima penjelasan mendalam mengenai subjek yang kompleks.
• Profesional dan peneliti dapat meminta informasi latar belakang tentang topik tertentu.

Contoh tanya jawab terbuka dengan Dolly. [Sumber: Databricks]

Teknik lanjutan

Dolly tidak terbatas pada operasi dasar; Anda juga dapat menerapkan beberapa teknik lanjutan berikut:

Fine-tuning pada data kustom

Anda dapat menggunakan model bahasa pra-latih yang lebih besar sebagai basis untuk menyesuaikan LLM personal Anda. Ini akan meningkatkan kemampuan mengikuti instruksi dan memungkinkan Anda melakukan tugas yang disesuaikan dengan kebutuhan.

Mengkurasi data instruksi spesifik domain

Untuk menspesialisasi LLM Anda pada industri tertentu, lengkapi data instruksi standar dengan prompt kustom yang disesuaikan untuk domain apa pun yang diinginkan (kesehatan, keuangan, teknik, dan lainnya).

Dengan melakukan fine-tune pada dataset spesifik yang berisi kosakata, format, dan pengetahuan terkait, model dapat memberikan keluaran yang akurat dan relevan yang terkontekstualisasi dengan bahasa dan konvensi domain tersebut.

Menggabungkan input data dinamis

Anda dapat melatih model agar menggabungkan input dinamis seperti gambar, video, dan data audio. Ini akan memungkinkannya melampaui pemahaman teks dan menghasilkan konten yang mengambil wawasan dari beberapa aliran data secara bersamaan.

Membangun Aplikasi dengan Databricks Dolly

Walaupun Dolly versi asli menyediakan kapabilitas operasional dasar, Anda dapat menyetel model yang ada untuk membangun aplikasi seperti chatbot.

Membuat chatbot

Anda dapat membuat chatbot yang disesuaikan menggunakan Databricks Dolly dalam dua bagian.

Persiapan data & pembuatan basis data vektor

Untuk membuat chatbot, pertama-tama Anda harus menyiapkan basis data vektor Databricks (Chroma) untuk mengumpulkan dan memasukkan data menggunakan Databricks Lakehouse, Delta Lake, dan Delta Live Tables.

Pertama, pasang pustaka yang diperlukan.

%pip install -U chromadb==0.3.22 langchain==0.0.164 transformers==4.29.0 accelerate==0.19.0Didukung oleh

Jalankan perintah berikut di notebook Databricks Anda.

%run ./_resources/00-init $catalog=hive_metastore $db=dbdemos_llmDidukung oleh

Sekarang, misalkan Anda sedang membangun chatbot berkebun.

Catatan: Jika Anda ingin mencoba demo ini sendiri, pastikan untuk menyiapkan db demos di notebook Databricks.

1. Karena kita bekerja dengan dataset berkebun contoh dari dbdemos, ekstrak dataset menggunakan perintah ‘sh’.

%sh
#To keep it simple, we'll download and extract the dataset using standard bash commands 
#Install 7zip to extract the file
apt-get install -y p7zip-full

rm -r /tmp/gardening
mkdir -p /tmp/gardening
cd /tmp/gardening
#Download & extract the gardening archive
curl -L https://archive.org/download/stackexchange/gardening.stackexchange.com.7z -o gardening.7z
7z x gardening.7z 
#Move the dataset to our main bucket
mkdir -p /dbfs/dbdemos/product/llm/gardening/raw
cp -f Posts.xml /dbfs/dbdemos/product/llm/gardening/rawDidukung oleh

2. Sekarang, Anda dapat memeriksa informasi dataset.

%fs ls /dbdemos/product/llm/gardening/rawDidukung oleh

Membersihkan dan menyiapkan tanya jawab:

1. Tinjau dataset mentah.

gardening_raw_path = demo_path+"/gardening/raw"

print(f"loading raw xml dataset under {gardening_raw_path}")

raw_gardening = spark.read.format("xml").option("rowTag", "row").load(f"{gardening_raw_path}/Posts.xml")
display(raw_gardening)
Didukung oleh

2. Kode di bawah ini mengonversi string berformat HTML menjadi teks dan menggunakan BeautifulSoup untuk mengurai HTML dan mengekstrak teks.

from bs4 import BeautifulSoup

#UDF to transform html content as text

@pandas_udf("string")
def html_to_text(html):
  return html.apply(lambda x: BeautifulSoup(x).get_text())

gardening_df =(raw_gardening
                  .filter("_Score >= 5") # keep only good answer/question
                  .filter(length("_Body") <= 1000) #remove too long questions
                  .withColumn("body", html_to_text("_Body")) 

#Convert html to text

                  .withColumnsRenamed({"_Id": "id", "_ParentId": "parent_id"})
                  .select("id", "body", "parent_id"))

# Save 'raw' content for later loading of questions

gardening_df.write.mode("overwrite").saveAsTable(f"gardening_dataset")
display(spark.table("gardening_dataset"))Didukung oleh

3. Sekarang, pasangkan pertanyaan dan jawaban.

gardening_df = spark.table("gardening_dataset")

# Self-join to assemble questions and answers

qa_df = gardening_df.alias("a").filter("parent_id IS NULL") \
         .join(gardening_df.alias("b"), on=[col("a.id") == col("b.parent_id")]) \
         .select("b.id", "a.body", "b.body") \
         .toDF("answer_id", "question", "answer")
        
# Prepare the training dataset: question following with the best answers.

docs_df = qa_df.select(col("answer_id"), F.concat(col("question"), F.lit("\n\n"), col("answer"))).toDF("source", "text")
display(docs_df)
Didukung oleh

Konversi dokumen ke representasi vektor:

from langchain.embeddings import HuggingFaceEmbeddings
 
# Download model from Hugging face

hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")Didukung oleh

Indekskan dokumen di basis data vektor Databricks untuk pencarian yang lebih baik:

dbutils.widgets.dropdown("reset_vector_database", "false", ["false", "true"], "Recompute embeddings for chromadb")
gardening_vector_db_path = demo_path+"/vector_db"
 
# Don't recompute the embeddings if they're already available

compute_embeddings = dbutils.widgets.get("reset_vector_database") == "true" or is_folder_empty(gardening_vector_db_path)
 
if compute_embeddings:
  print(f"creating folder {gardening_vector_db_path} under our blob storage (dbfs)")
  dbutils.fs.rm(gardening_vector_db_path, True)
  dbutils.fs.mkdirs(gardening_vector_db_path)Didukung oleh

4. Sekarang, buat basis data dokumen dengan menyimpan dataset Anda di dalam vektor DB.

from langchain.docstore.document import Document
from langchain.vectorstores import Chroma

# Import if you want to divide Chunk.
# from langchain.text_splitter import CharacterTextSplitter

all_texts = spark.table("gardening_training_dataset")
 
print(f"Saving document embeddings under /dbfs{gardening_vector_db_path}")
 
if compute_embeddings: 

  # Convert lines as langchain Documents.
  # If you want to index for shorter time periods, use the text_short field instead.

  documents = [Document(page_content=r["text"], metadata={"source": r["source"]}) for r in all_texts.collect()]
 
  # Long sentences may need to be split. But it's best to summarize as above.

  # text_splitter = CharacterTextSplitter(separator="\n", chunk_size=1000, chunk_overlap=100)

  # documents = text_splitter.split_documents(documents)
 
  # Initialize chromadb with sentence-transformers/all-mpnet-base-v2 model loaded from hugging face (hf_embed).

  db = Chroma.from_documents(collection_name="gardening_docs", documents=documents, embedding=hf_embed, persist_directory="/dbfs"+gardening_vector_db_path)
  db.similarity_search("dummy") # tickle it to persist metadata (?)
  db.persist()Didukung oleh

Ini akan menyimpan embedding dokumen di /dbfs/dbdemos/product/llm/vector_db

Selesai - dataset tanya jawab Anda siap.

Namun, setelah selesai, mulai ulang kernel Python Anda untuk membebaskan memori.

Rekayasa prompt untuk pertanyaan & jawaban

Pada langkah ini, Anda mengajukan pertanyaan, dan sistem mengambil konten serupa dari dataset tanya jawab. Kemudian sistem merekayasa sebuah prompt yang berisi konten tersebut dan mengirimkannya ke Dolly, yang akan menghasilkan jawaban untuk ditampilkan kepada pengguna.

Berikut cara melakukannya:

1. Unduh 2 embedding dari Hugging Face:

# Start here to load a previously-saved DB

from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import Chroma

if len(get_available_gpus()) == 0:

 Exception("Running dolly without GPU will be slow. We recommend you switch to a Single Node cluster with at least 1 GPU to properly run this demo.")
gardening_vector_db_path = "/dbfs"+demo_path+"/vector_db"
hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")

db = Chroma(collection_name="gardening_docs", embedding_function=hf_embed, persist_directory=gardening_vector_db_path)Didukung oleh

2. Sekarang, lakukan pemeriksaan kemiripan antar pertanyaan.

def get_similar_docs(question, similar_doc_count):
 return db.similarity_search(question, k=similar_doc_count)

# Let's test it with blackberries:

for doc in get_similar_docs("how to grow blackberry?", 2):
 print(doc.page_content)Didukung oleh

3. Gunakan model bahasa dan prompt untuk membangun sistem penjawab pertanyaan menggunakan LangChain.

from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
import torch
from langchain import PromptTemplate
from langchain.llms import HuggingFacePipeline
from langchain.chains.question_answering import load_qa_chain
 
def build_qa_chain():
  torch.cuda.empty_cache()
  model_name = "databricks/dolly-v2-7b" # can use dolly-v2-3b or dolly-v2-7b for smaller models and faster inferences.
 
  # Increase max_new_tokens for a longer response
  # Other settings might give better results! Play around
  instruct_pipeline = pipeline(model=model_name, torch_dtype=torch.bfloat16, trust_remote_code=True, device_map="auto", 
                               return_full_text=True, max_new_tokens=256, top_p=0.95, top_k=50)
  # Note: if you use dolly 12B or smaller model but a GPU with less than 24GB RAM, use 8bit. This requires %pip install bitsandbytes
  # Defining our prompt content.
  # langchain will load our similar documents as {context}
  template = """Below is an instruction that describes a task. Write a response that appropriately completes the request.
 
  Instruction: 
  You are a gardener and your job is to help provide the best gardening answer. 
  Use only information in the following paragraphs to answer the question at the end. Explain the answer with reference to these paragraphs. If you don't know, say that you do not know.
 
  {context}
 
  Question: {question}
 
  Response:
  """
  prompt = PromptTemplate(input_variables=['context', 'question'], template=template)
 
  hf_pipe = HuggingFacePipeline(pipeline=instruct_pipeline)
  # Set verbose=True to see the full prompt:
  return load_qa_chain(llm=hf_pipe, chain_type="stuff", prompt=prompt, verbose=True)Didukung oleh

# Building the chain will load Dolly and can take several minutes depending on the model size
qa_chain = build_qa_chain()Didukung oleh

Pengaturan kunci yang memengaruhi kinerja adalah:

• ‘Max_new_tokens’: Kurangi untuk keluaran yang lebih cepat dan ringkas.
• ‘Num_beams’: Dengan beam search, semakin banyak beam meningkatkan waktu proses secara hampir linear.

4. Selesai. Sekarang, Anda dapat mendefinisikan fungsi untuk tanya jawab sederhana.

def answer_question(question):
 similar_docs = get_similar_docs(question, similar_doc_count=2)

 result = qa_chain({"input_documents": similar_docs, "question": question})
 result_html = f"<p><blockquote style=\"font-size:24\">{question}</blockquote></p>"
 result_html += f"<p><blockquote style=\"font-size:18px\">{result['output_text']}</blockquote></p>"
 result_html += "<p><hr/></p>"
 for d in result["input_documents"]:
   source_id = d.metadata["source"]
   result_html += f"<p><blockquote>{d.page_content}<br/>(Source: <a href=\"https://gardening.stackexchange.com/a/{source_id}\">{source_id}</a>)</blockquote></p>"
 displayHTML(result_html)Didukung oleh

Sekarang Anda dapat menanyakannya pertanyaan terkait berkebun.

answer_question("What is the best kind of soil to grow blueberries in?")Didukung oleh

Lihat dbdemo untuk membangun chatbot di sini.

Kasus Penggunaan di Dunia Nyata

Dengan kapabilitas NLP yang canggih, LLM yang disesuaikan dengan Dolly dapat digunakan dalam banyak kasus nyata, dan berikut beberapa contoh yang paling umum:

1. Otomatisasi peringkasan data untuk analis keuangan

Dolly dapat memproses dataset besar dan menghasilkan ringkasan singkat untuk membantu analis menangkap insight utama dengan lebih cepat.

Misalnya, seorang peneliti keuangan mungkin perlu dengan cepat memahami tren historis harga saham. Dolly dapat menganalisis data dan memberikan gambaran yang jelas, menghemat waktu peneliti yang berharga.

2. Pembersihan dan praproses data di industri ritel

Di perusahaan ritel, analis data bekerja dengan dataset masif yang berisi catatan transaksi dari ribuan toko di seluruh negeri. Namun, data mentah dari tiap toko sering kali berisi inkonsistensi, nilai hilang, entri duplikat, dan kesalahan lainnya.

Dolly dapat mengidentifikasi inkonsistensi, nilai hilang, dan potensi kesalahan pada data sehingga data scientist dapat menggunakan data yang bersih untuk mengekstrak insight bermakna dan membuat visualisasi.

3. Tetap mengikuti riset terbaru di industri farmasi

Di perusahaan farmasi, ilmuwan harus mengikuti publikasi riset terbaru di berbagai disiplin ilmu. Namun, meninjau ratusan makalah riset baru tiap minggu menyita waktu.

Sebagai gantinya, mereka dapat menggunakan Databricks Dolly LLM untuk menganalisis makalah riset dan mengekstrak elemen kunci seperti tujuan, metode, hasil, dan kesimpulan. Dolly dapat menggabungkan ringkasan multi-halaman dan menyoroti insight paling penting dari setiap makalah.

Tantangan dan Keterbatasan

Seperti teknologi LLM perintis lainnya, Dolly memiliki beberapa keterbatasan dan tantangan. Berikut tiga kekurangan utama Dolly:

• Berhalusinasi atau menghasilkan respons yang secara faktual tidak benar karena dilatih pada dataset yang jauh lebih kecil dibandingkan ChatGPT.
• Sulit untuk di-fine-tune dan disesuaikan dengan kebutuhan Anda karena memerlukan tingkat keahlian tertentu dalam machine learning dan NLP.
• Kesulitan menyelesaikan pertanyaan matematika, masalah pemrograman, dan menambahkan unsur humor dalam respons.

Mengurangi Kekurangan Dolly LLM

Meskipun belum ada teknik yang terkonfirmasi untuk mengurangi keterbatasan Dolly saat ini, Databricks terus melakukan riset dan bertujuan menemukan cara untuk meningkatkan model AI yang ada. Dolly adalah salah satu contohnya yang saat ini berada pada versi 2, namun kita mungkin akan melihat peningkatan lebih lanjut di tahun-tahun mendatang.

Kesimpulan dan Langkah Berikutnya

Databricks Dolly adalah model AI open-source yang tersedia untuk penggunaan komersial. Anda dapat menggunakan kode pelatihan dan datasetnya untuk membuat LLM spesifik yang memenuhi kebutuhan Anda.

Jika Anda siap melampaui tutorial Databricks Dolly ini dan memoles keterampilan Anda, mulai dengan sumber daya berikut:

• Mengembangkan model bahasa berskala besar
• Pengantar Databricks
• Webinar: Memulai dengan Databricks

Selamat belajar!