Tutorial completo su Databricks Dolly per creare applicazioni

Gestire i dati manualmente può ritardare i risultati e rallentare l’avanzamento del progetto. Ecco perché data engineer e analisti sono sempre alla ricerca di LLM più rapidi ed economici per gestire le attività quotidiane.

Dolly è un modello di IA open source di Databricks che, tra le altre cose, può aiutare analisti, ingegneri e altri professionisti a semplificare il lavoro in diversi settori. Poiché è open source, chiunque può usare il suo codice di training per creare LLM migliori e più personalizzati in base alle proprie esigenze.

Scopriamone di più in questo tutorial su Databricks Dolly.

Perché Databricks Dolly?

Ciò che rende Databricks Dolly un’ottima alternativa ad altri strumenti è l’approccio alla creazione di soluzioni personalizzate per aziende di ogni dimensione. Trasforma gli LLM da tecnologie esclusive e costose in strumenti versatili che ogni azienda può possedere e personalizzare.

Fonte: Databricks

I vantaggi di Dolly

Ecco come Dolly può aiutarti:

• Personalizzazione: Adatta gli LLM alle esigenze della tua organizzazione, facilitando la gestione dei workflow.
• Conveniente: Consente di creare modelli di instruction-following personalizzati in modo economico ed efficiente.
• Agile: Permette alle aziende di ottimizzare i flussi di lavoro sui dati, automatizzare processi complessi e generare insight in modo più efficace.
• Accessibile: Aumenta l’efficienza operativa rendendo l’IA avanzata più accessibile e adattabile ai casi d’uso aziendali.
• Sicuro: Offre una soluzione valida per sviluppare applicazioni di IA senza incorrere nei problemi di sicurezza dei dati o di conformità spesso associati agli strumenti basati su API.

Vuoi saperne di più su cosa possono fare i large language model? Segui questo corso sui concetti dei LLM.

Primi passi con Databricks Dolly

Vediamo ora come sfruttare al meglio Dolly per le tue esigenze.

Panoramica delle funzionalità di Databricks Dolly

Dolly è stato ottimizzato sul dataset specializzato databricks-dolly-15k per sbloccare funzionalità simili a modelli più grandi come GPT. Per questo puoi creare LLM personalizzati per fare brainstorming, generare testo ed eseguire attività specifiche su richiesta.

Configurare l’ambiente su Databricks Dolly

Segui queste istruzioni per configurare l’ambiente di Databricks Dolly per la generazione di risposte.

Se hai una macchina con GPU A100, puoi usare questo modello con la libreria transformers.

Passaggio 1: Esegui il seguente codice nel tuo notebook Databricks per installare le librerie transformers e accelerate:

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

Passaggio 2: Poi importa pipeline dalla libreria 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")Offerto da

Passaggio 3: Quindi, puoi generare risposte dalla pipeline:

instruct_pipeline("Explain to me the difference between nuclear fission and fusion.")Offerto da

Lavorare con il LLM Databricks Dolly

Operazioni di base con Dolly

Ecco alcune delle operazioni di base che puoi eseguire con Dolly:

Generazione di testo

• Scrittori e content creator possono generare bozze, scalette o testi completi su qualsiasi argomento, risparmiando tempo e fatica nella scrittura.
• Aziende e marketer possono creare copy coinvolgenti, descrizioni di prodotto o campagne di marketing.

Differenza tra il risultato del modello originale e i risultati ottimizzati di Dolly. [Fonte: Databricks]

Brainstorming

• Imprenditori e manager possono esplorare nuovi prodotti, servizi o modelli di business potenziali.
• Scrittori, artisti e designer possono usare Dolly per trovare ispirazione e idee originali per alimentare i loro progetti creativi.
• Puoi anche fare brainstorming in contesti personali per pianificare eventi o affrontare sfide quotidiane.

Differenza tra il risultato del modello originale e i risultati ottimizzati di Dolly. [Fonte: Databricks]

Q/A aperte

• Studenti possono porre domande e ricevere spiegazioni approfondite su argomenti complessi.
• Professionisti e ricercatori possono chiedere informazioni di background su temi specifici.

Esempio di domanda/risposta aperta con Dolly. [Fonte: Databricks]

Tecniche avanzate

Dolly non si limita alle operazioni di base; puoi applicargli anche diverse tecniche avanzate:

Fine-tuning su dati personalizzati

Puoi usare modelli linguistici pre-addestrati più grandi come base per ottimizzare i tuoi LLM personalizzati. Questo migliorerà le capacità di seguire istruzioni e ti permetterà di eseguire attività su misura per le tue necessità.

Curare dati di istruzione specifici per dominio

Per specializzare i tuoi LLM in settori particolari, integra i dati di istruzione standard con prompt personalizzati per il dominio desiderato (sanità, finanza, ingegneria e altro).

Apportando fine-tuning su dataset specifici che contengono vocabolario, formati e conoscenze del settore, il modello può fornire output accurati e pertinenti, contestualizzati rispetto al linguaggio e alle convenzioni del dominio.

Incorporare input di dati dinamici

Puoi addestrare il tuo modello a incorporare input dinamici come immagini, video e audio. Questo gli consentirà di andare oltre la comprensione del testo e generare contenuti che traggono insight da più flussi di dati contemporaneamente.

Creare applicazioni con Databricks Dolly

Sebbene la versione originale di Dolly offra funzionalità operative di base, puoi modificare il modello esistente per creare applicazioni come chatbot.

Creare un chatbot

Puoi creare un chatbot personalizzato usando databricks dolly in due parti.

Preparazione dei dati e creazione del database vettoriale

Per creare un chatbot, devi prima configurare il database vettoriale di Databricks (Chroma) per raccogliere e acquisire dati usando Databricks Lakehouse, Delta Lake e Delta Live Tables.

Per prima cosa, installa le librerie necessarie.

%pip install -U chromadb==0.3.22 langchain==0.0.164 transformers==4.29.0 accelerate==0.19.0Offerto da

Esegui il seguente comando nel tuo notebook Databricks.

%run ./_resources/00-init $catalog=hive_metastore $db=dbdemos_llmOfferto da

Ora, supponiamo che tu stia creando un chatbot per il giardinaggio.

Nota: se vuoi provare questo demo in autonomia, assicurati di configurare db demos nel notebook Databricks.

1. Poiché stiamo lavorando con un dataset di giardinaggio di esempio da dbdemos, estrai il dataset usando il comando ‘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/rawOfferto da

2. Ora puoi controllare le informazioni del dataset.

%fs ls /dbdemos/product/llm/gardening/rawOfferto da

Pulizia e preparazione delle Q/A:

1. Esamina il dataset grezzo.

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)
Offerto da

2. Il codice seguente converte una stringa in formato HTML in testo e usa BeautifulSoup per fare il parsing dell’HTML ed estrarne il testo.

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"))Offerto da

3. Ora abbina domande e risposte.

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)
Offerto da

Convertire i documenti in rappresentazione vettoriale:

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

hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")Offerto da

Indicizzare i documenti nel database vettoriale di Databricks per ricerche migliori:

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)Offerto da

4. Ora, crea il database di documenti archiviando il tuo dataset nel DB vettoriale.

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()Offerto da

Questo salverà gli embedding dei documenti in /dbfs/dbdemos/product/llm/vector_db

Ecco fatto: il tuo dataset di Q/A è pronto.

Tuttavia, una volta terminato, riavvia il kernel Python per liberare memoria.

Prompt engineering per domande e risposte

In questo passaggio poni una domanda e il sistema recupera contenuti simili dal dataset di Q&A. Quindi costruisce un prompt contenente il contenuto e lo invia a Dolly, che genera una risposta da mostrare all’utente.

Ecco come fare:

1. Scarica 2 embedding da 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)Offerto da

2. Ora esegui un controllo di similarità tra le domande.

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)Offerto da

3. Usa un modello linguistico e crea un sistema che risponda alle domande con 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)Offerto da

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

Le impostazioni chiave che incidono sulle prestazioni sono:

• ‘Max_new_tokens’: riduci per output più rapidi e concisi.
• ‘Num_beams’: con la beam search, più beam aumentano il runtime in modo approssimativamente lineare.

4. Fatto. Ora puoi definire la funzione per il question answering semplice.

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)Offerto da

Ora puoi fargli una domanda relativa al giardinaggio.

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

Guarda qui il dbdemo per creare un chatbot.

Casi d’uso reali

Grazie alle avanzate capacità di NLP, gli LLM personalizzati creati con Dolly possono essere usati in molti casi reali. Ecco alcuni esempi comuni:

1. Riepilogo dati automatizzato per analisti finanziari

Dolly può elaborare grandi dataset e generare sintesi concise per aiutare gli analisti a cogliere più rapidamente gli insight chiave.

Per esempio, un ricercatore in finanza potrebbe aver bisogno di comprendere velocemente l’andamento storico dei prezzi azionari. Dolly può analizzare i dati e fornire una panoramica chiara, facendo risparmiare tempo prezioso al ricercatore.

2. Pulizia e preprocessing dei dati nel retail

Nelle aziende retail, gli analisti lavorano con enormi dataset contenenti registrazioni di transazioni da migliaia di negozi sul territorio nazionale. Tuttavia, i dati grezzi provenienti dai singoli punti vendita spesso contengono incongruenze, valori mancanti, duplicati e altri errori.

Dolly può individuare incongruenze, valori mancanti ed errori potenziali nei dati, così i data scientist possono usare dati puliti per estrarre insight significativi e creare visualizzazioni.

3. Restare aggiornati sulle ultime ricerche nel settore farmaceutico

Nelle aziende farmaceutiche, gli scienziati devono restare aggiornati sulle ricerche più recenti in più discipline. Tuttavia, esaminare manualmente centinaia di nuovi paper ogni settimana richiede molto tempo.

Invece, possono usare Databricks Dolly LLM per analizzare gli articoli e estrarre elementi chiave come obiettivi, metodi, risultati e conclusioni. Può combinare sintesi su più pagine ed evidenziare gli insight più rilevanti di ciascun paper.

Sfide e limitazioni

Come ogni altra tecnologia LLM pionieristica, Dolly presenta alcune limitazioni e sfide. Ecco tre principali punti deboli di Dolly:

• Tende ad allucinare o a generare risposte fattualmente errate, poiché è addestrato su un dataset molto più piccolo rispetto a ChatGPT.
• È difficile da ottimizzare e personalizzare per le tue esigenze, perché richiede un certo livello di competenza in machine learning e NLP.
• Fa fatica a risolvere domande matematiche, problemi di programmazione e ad aggiungere un senso dell’umorismo nelle risposte.

Mitigare le carenze di Dolly LLM

Sebbene non esistano tecniche confermate per mitigare le attuali limitazioni di Dolly, Databricks sta conducendo ricerche in modo continuativo e punta a trovare modi per migliorare i modelli di IA esistenti. Dolly è un esempio in versione 2, ma potremmo vedere ulteriori miglioramenti nei prossimi anni.

Conclusioni e prossimi passi

Databricks Dolly è un modello di IA open source disponibile per uso commerciale. Puoi usare il suo codice di training e i dataset per creare LLM specifici che soddisfino le tue esigenze.

Se sei pronto ad andare oltre questo tutorial su Databricks Dolly e affinare le tue competenze, inizia con le seguenti risorse:

• Sviluppare large language model
• Introduzione a Databricks
• Webinar: Introduzione a Databricks

Buono studio!