Complete Databricks Dolly-tutorial voor het bouwen van applicaties

Gegevens handmatig verwerken kan resultaten vertragen en de voortgang van het project afremmen. Daarom zijn data-engineers en analisten altijd op zoek naar snellere en goedkopere LLM’s om dagelijkse taken af te handelen.

Dolly is een open-source AI-model van Databricks dat onder andere analisten, engineers en andere professionals kan helpen hun werk te verlichten in uiteenlopende sectoren. Omdat het open-source is, kan iedereen de trainingscode gebruiken om betere en meer aangepaste LLM’s te bouwen die aansluiten op hun behoeften.

Laten we hier meer over leren in onze Databricks Dolly-tutorial.

Waarom Databricks Dolly?

Wat Databricks Dolly een sterk alternatief maakt voor andere tools, is de aanpak om maatwerkoplossingen te bouwen voor bedrijven van elke omvang. Het transformeert LLM’s van exclusieve, dure technologieën naar veelzijdige tools die elk bedrijf kan bezitten en aanpassen.

Bron: Databricks

De voordelen van Dolly

Zo kan Dolly je helpen:

• Maatwerk: Past LLM’s aan op de behoeften van jouw organisatie, waardoor workflows eenvoudiger te beheren zijn.
• Kostenefficiënt: Maakt het mogelijk om aangepaste instruction-following-modellen goedkoop en efficiënt te creëren.
• Wendbaar: Stelt bedrijven in staat hun dataworkflows te optimaliseren, complexe processen te automatiseren en effectiever inzichten te genereren.
• Toegankelijk: Verhoogt de operationele efficiëntie door geavanceerde AI toegankelijker en beter aanpasbaar te maken voor zakelijke usecases.
• Veilig: Biedt een haalbare oplossing om AI-applicaties te ontwikkelen zonder de dataveiligheids- of complianceproblemen die vaak gepaard gaan met API-afhankelijke tools.

Wil je meer leren over wat large language models kunnen? Volg deze cursus over LLM-concepten.

Aan de slag met Databricks Dolly

Laten we nu bekijken hoe je Dolly het beste inzet voor jouw behoeften.

Overzicht van de functionaliteit van Databricks Dolly

Dolly is fijn-afgesteld op een gespecialiseerd databricks-dolly-15k-dataset om functionaliteiten te ontsluiten die vergelijkbaar zijn met meer omvangrijke modellen zoals GPT. Daarom kun je aangepaste LLM’s maken om te brainstormen, tekst te genereren en specifieke taken op commando uit te voeren.

Je omgeving instellen op Databricks Dolly

Volg deze instructies om je Databricks Dolly-omgeving in te stellen voor het genereren van antwoorden.

Als je een machine met A100 GPU’s hebt, kun je dit model gebruiken met de transformers-bibliotheek.

Stap 1: Voer de volgende code uit in je Databricks-notebook om de bibliotheken transformers en accelerate te installeren:

%pip install "accelerate>=0.16.0,<1" "transformers[torch]>=4.28.1,<5" "torch>=1.13.1,<2"Mogelijk gemaakt door

Stap 2: Importeer vervolgens pipeline uit de transformers-bibliotheek:

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")Mogelijk gemaakt door

Stap 3: Daarna kun je antwoorden genereren vanuit de pipeline:

instruct_pipeline("Explain to me the difference between nuclear fission and fusion.")Mogelijk gemaakt door

Werken met Databricks Dolly LLM

Basisbewerkingen met Dolly

Dit zijn enkele van de basisbewerkingen die je met Dolly kunt uitvoeren:

Tekstgeneratie

• Schrijvers en contentmakers kunnen concepten, schetsen of volledige teksten over elk onderwerp genereren. Dit bespaart tijd en moeite in het schrijfproces.
• Bedrijven en marketeers kunnen aansprekende copy, productbeschrijvingen of marketingcampagnes maken.

Verschil tussen het resultaat van het oorspronkelijke model en de fijn-afgestelde resultaten van Dolly. [Bron: Databricks]

Brainstormen

• Ondernemers en businessleiders kunnen potentiële nieuwe producten, diensten of businessmodellen verkennen.
• Schrijvers, kunstenaars en ontwerpers kunnen Dolly gebruiken voor inspiratie en bijzondere ideeën om hun creatieve projecten aan te jagen.
• Je kunt zelfs in privésituaties ideeën brainstormen om evenementen te plannen of alledaagse uitdagingen aan te pakken.

Verschil tussen het resultaat van het oorspronkelijke model en de fijn-afgestelde resultaten van Dolly. [Bron: Databricks]

Open V/A

• Studenten kunnen vragen stellen en diepgaande uitleg krijgen over complexe onderwerpen.
• Professionals en onderzoekers kunnen achtergrondinformatie vragen over specifieke onderwerpen.

Voorbeeld van een open vraag/antwoord met Dolly. [Bron: Databricks]

Geavanceerde technieken

Dolly is niet beperkt tot basisbewerkingen; je kunt er ook verschillende geavanceerde technieken op toepassen:

Fijn-afstemmen op aangepaste data

Je kunt grotere, voorgetrainde taalmodellen gebruiken als basis om je gepersonaliseerde LLM’s fijn af te stemmen. Dit verbetert de instruction-following-capaciteiten en stelt je in staat taken uit te voeren die zijn afgestemd op jouw behoeften.

Domeinspecifieke instructiedata samenstellen

Om je LLM’s te specialiseren in specifieke sectoren, vul je de standaard instructiedata aan met aangepaste prompts voor elk gewenst domein (zorg, finance, engineering, noem maar op).

Door fijn-af te stemmen op specifieke datasets met de bijbehorende woordenschat, formats en kennis, kan het model nauwkeurige en relevante output geven die past bij de taal en conventies van dat domein.

Dynamische datainvoer integreren

Je kunt je model trainen om dynamische invoer zoals afbeeldingen, video en audiodata te verwerken. Zo gaat het verder dan alleen tekst begrijpen en kan het content genereren die inzichten uit meerdere datastromen tegelijk benut.

Applicaties bouwen met Databricks Dolly

Hoewel de oorspronkelijke Dolly basisfunctionaliteit biedt, kun je het bestaande model tweaken om applicaties zoals chatbots te bouwen.

Een chatbot maken

Je kunt een aangepaste chatbot maken met Databricks Dolly in twee delen.

Datavoorbereiding & vectordatabank aanmaken

Om een chatbot te maken, moet je eerst de vectordatabank van Databricks (Chroma) opzetten om data te verzamelen en in te laden via Databricks Lakehouse, Delta Lake en Delta Live Tables.

Installeer eerst de benodigde bibliotheken.

%pip install -U chromadb==0.3.22 langchain==0.0.164 transformers==4.29.0 accelerate==0.19.0Mogelijk gemaakt door

Voer het volgende commando uit in je Databricks-notebook.

%run ./_resources/00-init $catalog=hive_metastore $db=dbdemos_llmMogelijk gemaakt door

Stel, je bouwt een tuinier-chatbot.

Let op: Als je deze demo zelf wilt proberen, zorg dan dat je db demos instelt in het Databricks-notebook.

1. Omdat we werken met een voorbeeld-dataset over tuinieren uit dbdemos, extraheer je de dataset met het ‘sh’-commando.

%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/rawMogelijk gemaakt door

2. Nu kun je de informatie over de dataset controleren.

%fs ls /dbdemos/product/llm/gardening/rawMogelijk gemaakt door

Q/A’s opschonen en voorbereiden:

1. Bekijk de ruwe dataset.

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)
Mogelijk gemaakt door

2. Onderstaande code zet een HTML-geformatteerde string om naar tekst en gebruikt BeautifulSoup om de HTML te parsen en de tekst te extraheren.

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"))Mogelijk gemaakt door

3. Koppel nu vragen en antwoorden.

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)
Mogelijk gemaakt door

Zet documenten om naar vectorrepresentaties:

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

hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")Mogelijk gemaakt door

Indexeer documenten in de vectordatabank van Databricks voor betere zoekresultaten:

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)Mogelijk gemaakt door

4. Maak nu de documentendatabase door je dataset in de vector-DB op te slaan.

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()Mogelijk gemaakt door

Dit slaat document-embeddings op onder /dbfs/dbdemos/product/llm/vector_db

En dat is het – je V/A-dataset is klaar.

Zodra je klaar bent, start je echter je Python-kernel opnieuw om het geheugen vrij te maken.

Prompt engineering voor vragen & antwoorden

In deze stap stel je een vraag en het systeem haalt vergelijkbare content op uit de V&A-dataset. Vervolgens wordt er een prompt samengesteld met die content en naar Dolly gestuurd, die een antwoord genereert om aan de klant te tonen.

Zo pak je dat aan:

1. Download 2 embeddings van 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)Mogelijk gemaakt door

2. Voer nu een gelijkeniscontrole uit tussen vragen.

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)Mogelijk gemaakt door

3. Gebruik een taalmodel en prompt het om met LangChain een systeem te bouwen dat vragen beantwoordt.

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)Mogelijk gemaakt door

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

De belangrijkste instellingen die de prestaties beïnvloeden zijn:

• ‘Max_new_tokens’: Verlaag voor snellere, beknoptere output.
• ‘Num_beams’: Bij beam search neemt de runtime ruwweg lineair toe met meer beams.

4. Dat is alles. Nu kun je de functie definiëren voor eenvoudig vraag-en-antwoord.

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)Mogelijk gemaakt door

Je kunt nu een vraag stellen die met tuinieren te maken heeft.

answer_question("What is the best kind of soil to grow blueberries in?")Mogelijk gemaakt door

Bekijk hier dbdemo voor het bouwen van een chatbot.

Praktische usecases

Met zijn geavanceerde NLP-mogelijkheden kunnen aangepaste LLM’s die met Dolly zijn gemaakt in veel praktijksituaties worden ingezet. Dit zijn enkele van de meest voorkomende voorbeelden:

1. Geautomatiseerde datasamenvattingen voor financieel analisten

Dolly kan grote datasets verwerken en beknopte samenvattingen genereren, zodat analisten sneller de belangrijkste inzichten begrijpen.

Een financieel onderzoeker moet bijvoorbeeld snel historische koersontwikkelingen begrijpen. Dolly kan de data analyseren en een helder overzicht geven, wat de onderzoeker kostbare tijd bespaart.

2. Datacleaning en preprocessing in de retail

Bij retailbedrijven werken data-analisten met enorme datasets met transactiegegevens van duizenden winkels in het hele land. Ruwe data van afzonderlijke winkels bevat echter vaak inconsistenties, ontbrekende waarden, dubbele records en andere fouten.

Dolly kan inconsistenties, ontbrekende waarden en mogelijke fouten in de data identificeren, zodat data scientists met schone data betekenisvolle inzichten kunnen halen en visualisaties kunnen maken.

3. Bijblijven met het nieuwste onderzoek in de farmaceutische industrie

Bij farmaceutische bedrijven blijven wetenschappers op de hoogte van het nieuwste gepubliceerde onderzoek in meerdere disciplines. Het handmatig doornemen van honderden nieuwe papers per week kost echter veel tijd.

In plaats daarvan kunnen ze Databricks Dolly LLM gebruiken om onderzoeksartikelen te analyseren en kernelementen te extraheren, zoals doelstellingen, methoden, resultaten en conclusies. Het kan meerpagina’s tellende samenvattingen combineren en de meest relevante inzichten uit elk artikel uitlichten.

Uitdagingen en beperkingen

Zoals elke andere baanbrekende LLM-technologie kent Dolly enkele beperkingen en uitdagingen. Dit zijn drie belangrijke zwakke punten van Dolly:

• Hallucineert of genereert feitelijk onjuiste antwoorden, omdat het is getraind op een veel kleiner dataset dan ChatGPT.
• Het is lastig om het te fine-tunen en aan te passen aan jouw behoeften, omdat daarvoor een bepaald niveau van machine learning- en NLP-expertise vereist is.
• Heeft moeite met het oplossen van wiskundige vragen, programmeerproblemen en het toevoegen van humor in antwoorden.

Tekortkomingen van Dolly LLM mitigeren

Hoewel er geen bevestigde technieken bestaan om de huidige beperkingen van Dolly te mitigeren, doet Databricks continu onderzoek en streeft het ernaar manieren te vinden om bestaande AI-modellen te verbeteren. Dolly is zo’n voorbeeld, momenteel in versie 2, maar we kunnen in de komende jaren verdere verbeteringen verwachten.

Conclusie en volgende stappen

Databricks Dolly is een open-source AI-model dat beschikbaar is voor commercieel gebruik. Je kunt de trainingscode en datasets gebruiken om specifieke LLM’s te creëren die aan jouw behoeften voldoen.

Ben je klaar om verder te gaan dan deze Databricks Dolly-tutorial en je bestaande vaardigheden te verfijnen? Begin dan met de volgende resources:

• Grote taalmodellen ontwikkelen
• Introductie tot Databricks
• Webinar: Aan de slag met Databricks

Veel leerplezier!