Hướng dẫn toàn diện về Databricks Dolly để xây dựng ứng dụng

Xử lý dữ liệu thủ công có thể làm chậm kết quả và tiến độ dự án. Đó là lý do các kỹ sư dữ liệu và nhà phân tích luôn tìm kiếm các LLM nhanh hơn và rẻ hơn để xử lý công việc hằng ngày.

Dolly là một mô hình AI mã nguồn mở của Databricks có thể giúp nhà phân tích, kỹ sư và các chuyên gia khác giảm bớt công việc trong nhiều ngành. Nhờ là mã nguồn mở, bất kỳ ai cũng có thể sử dụng mã huấn luyện của nó để xây dựng các LLM tốt hơn và tùy biến hơn theo nhu cầu.

Hãy cùng tìm hiểu thêm trong hướng dẫn Databricks Dolly này.

Vì sao chọn Databricks Dolly?

Điểm khiến Databricks Dolly trở thành lựa chọn thay thế tuyệt vời cho các công cụ khác là cách tiếp cận xây dựng giải pháp tùy chỉnh cho doanh nghiệp ở mọi quy mô. Nó biến LLM từ công nghệ độc quyền, chi phí cao thành công cụ linh hoạt mà mọi công ty đều có thể sở hữu và tùy biến.

Nguồn: Databricks

Lợi ích của Dolly

Dolly có thể giúp bạn theo các cách sau:

• Tùy biến: Tùy chỉnh LLM theo nhu cầu của tổ chức, giúp quản lý quy trình làm việc dễ dàng hơn.
• Tiết kiệm chi phí: Hỗ trợ tạo các mô hình tuân thủ hướng dẫn được tùy chỉnh với chi phí thấp và hiệu quả.
• Linh hoạt: Giúp doanh nghiệp tối ưu quy trình dữ liệu, tự động hóa các quy trình phức tạp và tạo insight hiệu quả hơn.
• Dễ tiếp cận: Nâng cao hiệu quả vận hành bằng cách khiến AI tiên tiến trở nên dễ tiếp cận và thích ứng với các bài toán kinh doanh.
• An toàn: Cung cấp giải pháp khả thi để phát triển ứng dụng AI mà không phát sinh các vấn đề về bảo mật dữ liệu hoặc tuân thủ thường gặp ở công cụ phụ thuộc API.

Muốn tìm hiểu thêm về khả năng của các mô hình ngôn ngữ lớn? Hãy học khóa học về các khái niệm LLM.

Bắt đầu với Databricks Dolly

Giờ hãy xem bạn có thể tận dụng Dolly thế nào cho nhu cầu của mình.

Tổng quan về chức năng của Databricks Dolly

Dolly được tinh chỉnh trên tập dữ liệu chuyên biệt databricks-dolly-15k để mở khóa các chức năng tương tự như những mô hình lớn hơn như GPT. Vì vậy, bạn có thể tạo LLM tùy chỉnh để động não ý tưởng, tạo văn bản và thực hiện các tác vụ cụ thể theo lệnh.

Thiết lập môi trường trên Databricks Dolly

Làm theo các hướng dẫn sau để thiết lập môi trường Databricks Dolly cho việc tạo phản hồi.

Nếu bạn có máy với GPU A100, bạn có thể dùng mô hình này với thư viện transformers.

Bước 1: Chạy đoạn mã sau trong notebook Databricks để cài đặt thư viện transformers và accelerate:

%pip install "accelerate>=0.16.0,<1" "transformers[torch]>=4.28.1,<5" "torch>=1.13.1,<2"Được hỗ trợ bởi

Bước 2: Tiếp theo, import pipeline từ thư viện 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")Được hỗ trợ bởi

Bước 3: Sau đó, bạn có thể tạo phản hồi từ pipeline:

instruct_pipeline("Explain to me the difference between nuclear fission and fusion.")Được hỗ trợ bởi

Làm việc với Databricks Dolly LLM

Các thao tác cơ bản với Dolly

Dưới đây là một số thao tác cơ bản bạn có thể thực hiện với Dolly:

Tạo văn bản

• Nhà văn và người sáng tạo nội dung có thể tạo nháp, dàn ý hoặc bài viết hoàn chỉnh về bất kỳ chủ đề nào, giúp tiết kiệm thời gian và công sức.
• Doanh nghiệp và marketer có thể tạo nội dung hấp dẫn, mô tả sản phẩm hoặc chiến dịch marketing.

Sự khác biệt giữa kết quả của mô hình gốc và kết quả sau tinh chỉnh của Dolly. [Nguồn: Databricks]

Động não ý tưởng

• Doanh nhân và lãnh đạo có thể khám phá sản phẩm, dịch vụ hoặc mô hình kinh doanh mới tiềm năng.
• Nhà văn, nghệ sĩ và nhà thiết kế có thể dùng Dolly để lấy cảm hứng và ý tưởng độc đáo cho dự án sáng tạo.
• Bạn thậm chí có thể động não trong bối cảnh cá nhân để lập kế hoạch sự kiện hoặc giải quyết thách thức thường nhật.

Sự khác biệt giữa kết quả của mô hình gốc và kết quả sau tinh chỉnh của Dolly. [Nguồn: Databricks]

Hỏi đáp mở

• Sinh viên có thể đặt câu hỏi và nhận giải thích chuyên sâu về các chủ đề phức tạp.
• Chuyên gia và nhà nghiên cứu có thể yêu cầu thông tin nền về chủ đề cụ thể.

Ví dụ về hỏi đáp mở với Dolly. [Nguồn: Databricks]

Kỹ thuật nâng cao

Dolly không chỉ giới hạn ở các thao tác cơ bản; bạn cũng có thể áp dụng nhiều kỹ thuật nâng cao:

Tinh chỉnh trên dữ liệu tùy chỉnh

Bạn có thể dùng các mô hình ngôn ngữ tiền huấn luyện lớn làm nền tảng để tinh chỉnh LLM cá nhân hóa. Điều này cải thiện khả năng tuân thủ hướng dẫn và cho phép thực hiện các tác vụ phù hợp nhu cầu.

Chọn lọc dữ liệu hướng dẫn theo lĩnh vực

Để chuyên môn hóa LLM trong các ngành cụ thể, hãy bổ sung dữ liệu hướng dẫn chuẩn bằng các prompt tùy chỉnh cho bất kỳ lĩnh vực nào mong muốn (y tế, tài chính, kỹ thuật, v.v.).

Bằng cách tinh chỉnh trên các tập dữ liệu chứa từ vựng, định dạng và tri thức chuyên ngành, mô hình có thể cung cấp đầu ra chính xác, phù hợp với ngôn ngữ và quy ước của lĩnh vực đó.

Kết hợp dữ liệu đầu vào động

Bạn có thể huấn luyện mô hình để kết hợp đầu vào động như hình ảnh, video và âm thanh. Điều này giúp nó vượt ra ngoài hiểu văn bản và tạo nội dung rút trích insight từ nhiều luồng dữ liệu đồng thời.

Xây dựng ứng dụng với Databricks Dolly

Trong khi Dolly gốc cung cấp các khả năng vận hành cơ bản, bạn có thể tinh chỉnh mô hình hiện có để xây dựng ứng dụng như chatbot.

Tạo chatbot

Bạn có thể tạo chatbot tùy chỉnh bằng databricks dolly theo hai phần.

Chuẩn bị dữ liệu & tạo cơ sở dữ liệu vector

Để tạo chatbot, trước tiên bạn phải thiết lập cơ sở dữ liệu vector của Databricks (Chroma) để thu thập và nạp dữ liệu bằng Databricks Lakehouse, Delta Lake và Delta Live Tables.

Trước hết, cài đặt các thư viện cần thiết.

%pip install -U chromadb==0.3.22 langchain==0.0.164 transformers==4.29.0 accelerate==0.19.0Được hỗ trợ bởi

Chạy lệnh sau trong notebook Databricks của bạn.

%run ./_resources/00-init $catalog=hive_metastore $db=dbdemos_llmĐược hỗ trợ bởi

Giờ, giả sử bạn đang xây dựng một chatbot làm vườn.

Lưu ý: Nếu muốn tự thử bản demo này, hãy đảm bảo thiết lập db demos trong notebook Databricks.

1. Vì chúng ta làm việc với tập dữ liệu làm vườn mẫu từ dbdemos, hãy trích xuất tập dữ liệu bằng lệnh ‘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/rawĐược hỗ trợ bởi

2. Bây giờ, bạn có thể kiểm tra thông tin tập dữ liệu.

%fs ls /dbdemos/product/llm/gardening/rawĐược hỗ trợ bởi

Làm sạch và chuẩn bị Q/A:

1. Xem lại tập dữ liệu thô.

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)
Được hỗ trợ bởi

2. Đoạn mã dưới đây chuyển một chuỗi định dạng HTML thành văn bản và dùng BeautifulSoup để phân tích HTML và trích xuất văn bản.

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"))Được hỗ trợ bởi

3. Bây giờ, ghép cặp câu hỏi và câu trả lời.

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)
Được hỗ trợ bởi

Chuyển tài liệu sang biểu diễn vector:

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

hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")Được hỗ trợ bởi

Đánh chỉ mục tài liệu trong cơ sở dữ liệu vector Databricks để tìm kiếm tốt hơn:

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)Được hỗ trợ bởi

4. Giờ hãy tạo cơ sở dữ liệu tài liệu bằng cách lưu trữ tập dữ liệu trong vector 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()Được hỗ trợ bởi

Việc này sẽ lưu các embedding tài liệu tại /dbfs/dbdemos/product/llm/vector_db

Vậy là xong - tập dữ liệu Q/A của bạn đã sẵn sàng.

Tuy nhiên, sau khi hoàn tất, hãy khởi động lại kernel Python để giải phóng bộ nhớ.

Thiết kế prompt cho hỏi & đáp

Ở bước này, bạn đặt câu hỏi và hệ thống sẽ truy xuất nội dung tương tự từ tập Q&A. Sau đó, hệ thống tạo prompt chứa nội dung này và gửi tới Dolly để tạo câu trả lời hiển thị cho khách hàng.

Cách thực hiện như sau:

1. Tải 2 embedding từ 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)Được hỗ trợ bởi

2. Giờ hãy thực hiện kiểm tra độ tương đồng giữa các câu hỏi.

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)Được hỗ trợ bởi

3. Sử dụng mô hình ngôn ngữ và prompt để xây dựng hệ thống trả lời câu hỏi bằng 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)Được hỗ trợ bởi

# Building the chain will load Dolly and can take several minutes depending on the model size
qa_chain = build_qa_chain()Được hỗ trợ bởi

Các thiết lập ảnh hưởng hiệu năng gồm:

• ‘Max_new_tokens’: Giảm để có đầu ra ngắn gọn và nhanh hơn.
• ‘Num_beams’: Với beam search, số beam cao hơn sẽ tăng thời gian chạy xấp xỉ tuyến tính.

4. Vậy là xong. Giờ bạn có thể định nghĩa hàm cho hỏi đáp đơn giản.

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)Được hỗ trợ bởi

Bạn giờ có thể đặt câu hỏi liên quan đến làm vườn.

answer_question("What is the best kind of soil to grow blueberries in?")Được hỗ trợ bởi

Xem dbdemo để xây dựng chatbot tại đây.

Các trường hợp sử dụng thực tế

Với các khả năng NLP nâng cao, các LLM tùy chỉnh xây dựng bằng Dolly có thể dùng trong nhiều tình huống thực tế; dưới đây là những ví dụ phổ biến:

1. Tự động tóm tắt dữ liệu cho nhà phân tích tài chính

Dolly có thể xử lý các tập dữ liệu lớn và tạo bản tóm tắt súc tích giúp nhà phân tích nắm bắt insight nhanh hơn.

Ví dụ, một nhà nghiên cứu tài chính có thể cần hiểu nhanh xu hướng giá cổ phiếu lịch sử. Dolly có thể phân tích dữ liệu và cung cấp tổng quan rõ ràng, tiết kiệm thời gian quý báu.

2. Làm sạch và tiền xử lý dữ liệu trong ngành bán lẻ

Tại các công ty bán lẻ, nhà phân tích dữ liệu làm việc với các tập dữ liệu khổng lồ chứa bản ghi giao dịch từ hàng nghìn cửa hàng trên toàn quốc. Tuy nhiên, dữ liệu thô từ từng cửa hàng thường có sự không nhất quán, thiếu dữ liệu, trùng lặp và các lỗi khác.

Dolly có thể xác định sự không nhất quán, giá trị thiếu và lỗi tiềm ẩn để các nhà khoa học dữ liệu sử dụng dữ liệu sạch nhằm rút trích insight có ý nghĩa và tạo trực quan hóa.

3. Cập nhật nghiên cứu mới nhất trong ngành dược phẩm

Tại các công ty dược, nhà khoa học cần theo kịp nghiên cứu mới công bố trên nhiều lĩnh vực. Tuy nhiên, việc đọc thủ công hàng trăm bài nghiên cứu mỗi tuần rất tốn thời gian.

Thay vào đó, họ có thể dùng Databricks Dolly LLM để phân tích bài báo và trích xuất các yếu tố chính như mục tiêu, phương pháp, kết quả và kết luận. Nó có thể kết hợp các bản tóm tắt nhiều trang và làm nổi bật insight quan trọng nhất từ mỗi bài.

Thách thức và hạn chế

Giống bất kỳ công nghệ LLM tiên phong nào khác, Dolly có một số hạn chế và thách thức. Dưới đây là ba điểm yếu chính của Dolly:

• Có thể “ảo giác” hoặc tạo phản hồi sai sự thật vì được huấn luyện trên tập dữ liệu nhỏ hơn nhiều so với ChatGPT.
• Khó tinh chỉnh và tùy biến cho nhu cầu riêng vì đòi hỏi kiến thức nhất định về machine learning và NLP.
• Gặp khó khăn với bài toán toán học, vấn đề lập trình và thêm yếu tố hài hước trong phản hồi.

Giảm thiểu thiếu sót của Dolly LLM

Hiện chưa có kỹ thuật xác thực để khắc phục các hạn chế của Dolly, nhưng Databricks vẫn liên tục nghiên cứu và tìm cách cải thiện các mô hình AI hiện có. Dolly là một ví dụ như vậy, hiện ở phiên bản 2, và chúng ta có thể thấy thêm cải tiến trong những năm tới.

Kết luận và bước tiếp theo

Databricks Dolly là mô hình AI mã nguồn mở và có thể sử dụng cho mục đích thương mại. Bạn có thể dùng mã huấn luyện và tập dữ liệu của nó để tạo LLM cụ thể đáp ứng nhu cầu.

Nếu bạn sẵn sàng đi xa hơn hướng dẫn Databricks Dolly này và trau dồi kỹ năng, hãy bắt đầu với các tài nguyên sau:

• Phát triển mô hình ngôn ngữ lớn
• Giới thiệu về Databricks
• Webinar: Bắt đầu với Databricks

Chúc bạn học tốt!