एप्लिकेशन बनाने के लिए संपूर्ण Databricks Dolly ट्यूटोरियल

डेटा को मैन्युअल रूप से संभालना परिणामों में देरी कर सकता है और प्रोजेक्ट की प्रगति को धीमा कर सकता है। यही कारण है कि डेटा इंजीनियर और विश्लेषक दैनिक कार्यों को संभालने के लिए तेज़ और सस्ते LLMs की तलाश करते रहते हैं।

Dolly एक ओपन-सोर्स AI मॉडल है जिसे Databricks ने विकसित किया है, जो अन्य बातों के अलावा, विश्लेषकों, इंजीनियरों और अन्य पेशेवरों को विभिन्न उद्योगों में अपना काम आसान बनाने में मदद कर सकता है। चूंकि यह ओपन-सोर्स है, कोई भी इसकी प्रशिक्षण कोड का उपयोग करके अपनी आवश्यकताओं के अनुसार बेहतर और अधिक कस्टमाइज़्ड LLMs बना सकता है।

आइए हमारे Databricks Dolly ट्यूटोरियल में इसके बारे में और जानें।

क्यों Databricks Dolly?

जो चीज Databricks Dolly को अन्य टूल्स का बेहतरीन विकल्प बनाती है, वह है सभी आकार की कंपनियों के लिए कस्टम समाधान बनाने का उसका दृष्टिकोण। यह LLMs को विशिष्ट, महंगी तकनीकों से बदलकर बहुउद्देश्यीय टूल्स में बदल देता है, जिन्हें हर कंपनी अपनी जरूरत के अनुसार अपना और अनुकूलित कर सकती है।

स्रोत: Databricks

Dolly के लाभ

यहाँ बताया गया है कि Dolly आपकी कैसे मदद कर सकता है:

अनुकूलन: आपके संगठन की आवश्यकताओं के अनुसार LLMs को कस्टमाइज़ करता है, जिससे वर्कफ़्लो प्रबंधन आसान होता है।
किफायती: कस्टमाइज़्ड instruction-following मॉडल्स को सस्ती और कुशलता से बनाने में मदद करता है।
एजाइल: व्यवसायों को उनके डेटा वर्कफ़्लोज़ को अनुकूलित करने, जटिल प्रक्रियाओं को स्वचालित करने और अधिक प्रभावी ढंग से अंतर्दृष्टि उत्पन्न करने में सक्षम बनाता है।
सुलभ: उन्नत AI को अधिक सुलभ और व्यावसायिक उपयोग के मामलों के अनुरूप बनाकर परिचालन दक्षता बढ़ाता है।
सुरक्षित: API-निर्भर टूल्स से जुड़े डेटा सुरक्षा या अनुपालन मुद्दों को उत्पन्न किए बिना AI एप्लिकेशन विकसित करने के लिए एक व्यवहार्य समाधान प्रदान करता है।

क्या आप सीखना चाहते हैं कि बड़े भाषा मॉडल क्या कर सकते हैं? यह LLM कॉन्सेप्ट्स पर कोर्स करें।

Databricks Dolly के साथ शुरुआत

अब, देखते हैं कि आप अपनी जरूरतों के लिए Dolly का सर्वोत्तम उपयोग कैसे कर सकते हैं।

Databricks Dolly की कार्यक्षमता का अवलोकन

Dolly को एक विशेष databricks-dolly-15k डेटासेट पर फाइन-ट्यून किया गया है ताकि GPT जैसे अधिक बड़े मॉडलों जैसी क्षमताएँ खोली जा सकें। यही वजह है कि आप कस्टम LLMs बना सकते हैं जो विचार-मंथन, टेक्स्ट जनरेशन और आदेश पर विशिष्ट कार्यों का निष्पादन कर सकें।

Databricks Dolly पर अपना वातावरण सेट करना

रिस्पॉन्स जनरेशन के लिए अपना Databricks Dolly वातावरण सेट करने हेतु ये निर्देशों का पालन करें।

यदि आपके पास A100 GPUs वाली मशीन है, तो आप इस मॉडल को transformers लाइब्रेरी के साथ उपयोग कर सकते हैं।

स्टेप 1: अपने Databricks नोटबुक में निम्न कोड चलाएँ ताकि transformers और accelerate लाइब्रेरीज़ इंस्टॉल हो जाएँ:

%pip install "accelerate>=0.16.0,<1" "transformers[torch]>=4.28.1,<5" "torch>=1.13.1,<2"संचालित द्वारा

स्टेप 2: इसके बाद transformers लाइब्रेरी से pipeline इम्पोर्ट करें:

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")संचालित द्वारा

स्टेप 3: फिर, आप पाइपलाइन से प्रतिक्रियाएँ जेनरेट कर सकते हैं:

instruct_pipeline("Explain to me the difference between nuclear fission and fusion.")संचालित द्वारा

Databricks Dolly LLM के साथ काम करना

Dolly के साथ मूलभूत कार्य

यहाँ कुछ बेसिक ऑपरेशंस हैं जो आप Dolly के साथ कर सकते हैं:

टेक्स्ट जनरेशन

लेखक और कंटेंट क्रिएटर्स किसी भी विषय पर ड्राफ्ट, रूपरेखा, या संपूर्ण लेखन तैयार कर सकते हैं। इससे लिखने की प्रक्रिया में समय और मेहनत बचेगी।
व्यवसाय और मार्केटर्स आकर्षक कॉपी, प्रोडक्ट विवरण, या मार्केटिंग कैंपेन बना सकते हैं।

मूल मॉडल के परिणाम और Dolly के फाइन-ट्यून किए गए परिणामों के बीच अंतर। [स्रोत: Databricks]

ब्रेनस्टॉर्मिंग

उद्यमी और व्यावसायिक नेता संभावित नए प्रोडक्ट, सेवाएँ, या बिज़नेस मॉडल्स तलाश सकते हैं।
लेखक, कलाकार और डिज़ाइनर प्रेरणा और अनोखे विचारों के लिए Dolly का उपयोग कर सकते हैं ताकि उनके क्रिएटिव प्रोजेक्ट आगे बढ़ें।
आप व्यक्तिगत स्तर पर भी इवेंट प्लान करने या रोज़मर्रा की चुनौतियों से निपटने के लिए आइडिया ब्रेनस्टॉर्म कर सकते हैं।

ओपन प्रश्न/उत्तर

छात्र जटिल विषयों पर प्रश्न पूछ सकते हैं और गहन व्याख्याएँ प्राप्त कर सकते हैं।
पेशेवर और शोधकर्ता विशिष्ट विषयों पर पृष्ठभूमि जानकारी मांग सकते हैं।

Dolly के साथ खुले प्रश्न/उत्तर का उदाहरण। [स्रोत: Databricks]

उन्नत तकनीकें

Dolly केवल मूलभूत कार्यों तक सीमित नहीं है; आप इस पर कई उन्नत तकनीकों को भी लागू कर सकते हैं:

कस्टम डेटा पर फाइन-ट्यूनिंग

आप बड़े प्री-ट्रेंड भाषा मॉडलों को आधार के रूप में उपयोग करके अपने निजी LLMs को फाइन-ट्यून कर सकते हैं। इससे इसकी instruction-following क्षमताएँ बेहतर होंगी और आपकी आवश्यकताओं के अनुरूप कार्य कर पाएगा।

डोमेन-विशिष्ट instruction डेटा का क्यूरेशन

अपने LLMs को विशेष उद्योगों में विशेषज्ञ बनाने के लिए, मानक instruction डेटा के साथ इच्छित डोमेन (हेल्थकेयर, फाइनेंस, इंजीनियरिंग, आदि) के अनुरूप कस्टम प्रॉम्प्ट्स जोड़ें।

शब्दावली, फ़ॉर्मैट्स और ज्ञान वाले विशिष्ट डेटासेट्स पर फाइन-ट्यूनिंग करके, मॉडल उस डोमेन की भाषा और परंपराओं के संदर्भ में सटीक और प्रासंगिक आउटपुट दे सकता है।

डायनेमिक डेटा इनपुट शामिल करना

आप अपने मॉडल को इमेज, वीडियो और ऑडियो जैसे डायनेमिक इनपुट्स को शामिल करने के लिए प्रशिक्षित कर सकते हैं। इससे यह केवल टेक्स्ट समझने से आगे बढ़कर, एक साथ कई डेटा स्ट्रीम्स से अंतर्दृष्टि लेकर कंटेंट जेनरेट कर पाएगा।

Databricks Dolly के साथ एप्लिकेशन बनाना

जहाँ मूल Dolly बुनियादी संचालन क्षमताएँ प्रदान करता है, वहीं आप मौजूदा मॉडल को समायोजित करके चैटबॉट जैसे एप्लिकेशन बना सकते हैं।

चैटबॉट बनाना

आप databricks dolly का उपयोग करके दो भागों में एक कस्टमाइज़्ड चैटबॉट बना सकते हैं।

डेटा तैयारी और वेक्टर डेटाबेस निर्माण

चैटबॉट बनाने के लिए, आपको पहले Databricks का वेक्टर डेटाबेस (Chroma) सेट करना होगा ताकि Databricks Lakehouse, Delta Lake, और Delta Live Tables का उपयोग करके डेटा इकट्ठा और ingest किया जा सके।

सबसे पहले, आवश्यक लाइब्रेरीज़ इंस्टॉल करें।

%pip install -U chromadb==0.3.22 langchain==0.0.164 transformers==4.29.0 accelerate==0.19.0संचालित द्वारा

अपने Databricks नोटबुक में निम्न कमांड चलाएँ।

%run ./_resources/00-init $catalog=hive_metastore $db=dbdemos_llmसंचालित द्वारा

अब मान लें कि आप एक गार्डनिंग चैटबॉट बना रहे हैं।

नोट: यदि आप यह डेमो स्वयं आज़माना चाहते हैं, तो Databricks नोटबुक में db demos सेटअप करना सुनिश्चित करें।

1. चूँकि हम dbdemos के सैंपल गार्डनिंग डेटासेट के साथ काम कर रहे हैं, इसलिए ‘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संचालित द्वारा

2. अब, आप डेटासेट की जानकारी जाँच सकते हैं।

%fs ls /dbdemos/product/llm/gardening/rawसंचालित द्वारा

Q/A की सफाई और तैयारी:

1. रॉ डेटासेट की समीक्षा करें।

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)
संचालित द्वारा

2. नीचे दिया गया कोड HTML-फॉर्मेटेड स्ट्रिंग को टेक्स्ट में बदलता है और BeautifulSoup का उपयोग करके HTML को पार्स करता है और टेक्स्ट निकालता है।

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"))संचालित द्वारा

3. अब, प्रश्नों और उत्तरों की पेयरिंग करें।

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)
संचालित द्वारा

डॉक्यूमेंट्स को वेक्टर प्रतिनिधित्व में बदलें:

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

hf_embed = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")संचालित द्वारा

बेहतर खोज के लिए Databricks वेक्टर डेटाबेस में डॉक्यूमेंट्स को इंडेक्स करें:

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)संचालित द्वारा

4. अब, अपने डेटासेट को वेक्टर 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()संचालित द्वारा

यह /dbfs/dbdemos/product/llm/vector_db के अंतर्गत डॉक्यूमेंट एम्बेडिंग्स सहेजेगा

बस इतना ही - आपका Q/A डेटासेट तैयार है।

हालाँकि, काम पूरा होने के बाद, मेमोरी खाली करने के लिए अपना Python कर्नेल रीस्टार्ट करें।

प्रश्न और उत्तर के लिए प्रॉम्प्ट इंजीनियरिंग

इस चरण में, आप एक प्रश्न पूछते हैं, और सिस्टम Q&A डेटासेट से मिलती-जुलती सामग्री लाता है। फिर यह उस सामग्री वाला प्रॉम्प्ट बनाता है और Dolly को भेजता है, जो ग्राहक को दिखाने के लिए उत्तर जेनरेट करता है।

इसे आप इस तरह कर सकते हैं:

Hugging Face से 2 एम्बेडिंग्स डाउनलोड करें:

# 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)संचालित द्वारा

2. अब, प्रश्नों के बीच समानता जाँचें।

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)संचालित द्वारा

3. एक भाषा मॉडल का उपयोग करें और 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)संचालित द्वारा

# Building the chain will load Dolly and can take several minutes depending on the model size
qa_chain = build_qa_chain()संचालित द्वारा

प्रदर्शन को प्रभावित करने वाली प्रमुख सेटिंग्स हैं:

‘Max_new_tokens’: तेज़ और संक्षिप्त आउटपुट के लिए कम करें।
‘Num_beams’: बीम सर्च के साथ, अधिक बीम्स रनटाइम को लगभग रैखिक रूप से बढ़ाते हैं।

4. बस हो गया। अब, आप साधारण प्रश्न-उत्तर के लिए फ़ंक्शन परिभाषित कर सकते हैं।

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)संचालित द्वारा

अब आप इससे गार्डनिंग से संबंधित कोई प्रश्न पूछ सकते हैं।

answer_question("What is the best kind of soil to grow blueberries in?")संचालित द्वारा

चैटबॉट बनाने के लिए यहाँ dbdemo देखें।

वास्तविक दुनिया के उपयोग के मामले

अपनी उन्नत NLP क्षमताओं के साथ, Dolly से बनाए गए कस्टमाइज़्ड LLMs कई वास्तविक-world मामलों में उपयोग किए जा सकते हैं। यहाँ कुछ सामान्य उदाहरण दिए गए हैं:

1. वित्तीय विश्लेषकों के लिए स्वचालित डेटा सारांश

Dolly बड़े डेटासेट्स को प्रोसेस कर सकता है और संक्षिप्त सारांश बना सकता है ताकि विश्लेषक प्रमुख अंतर्दृष्टियों को तेज़ी से समझ सकें।

उदाहरण के लिए, किसी वित्त शोधकर्ता को ऐतिहासिक स्टॉक मूल्य रुझानों को जल्दी समझने की आवश्यकता हो सकती है। Dolly डेटा का विश्लेषण करके एक स्पष्ट अवलोकन प्रदान कर सकता है, जिससे शोधकर्ता का मूल्यवान समय बचेगा।

2. रिटेल उद्योगों में डेटा की सफाई और प्रीप्रोसेसिंग

रिटेल कंपनियों में, डेटा विश्लेषक देशभर के हज़ारों स्टोर्स के ट्रांज़ैक्शन रिकॉर्ड्स वाले बड़े डेटासेट्स के साथ काम करते हैं। हालाँकि, व्यक्तिगत स्टोर्स से आने वाले कच्चे डेटा में अक्सर असंगतियाँ, मिसिंग वैल्यूज़, डुप्लिकेट एंट्रीज़ और अन्य त्रुटियाँ होती हैं।

Dolly डेटा में असंगतियों, मिसिंग वैल्यूज़ और संभावित त्रुटियों की पहचान कर सकता है ताकि डेटा वैज्ञानिक साफ डेटा का उपयोग करके सार्थक अंतर्दृष्टि निकाल सकें और विज़ुअलाइज़ेशन बना सकें।

3. फार्मास्युटिकल उद्योगों में नवीनतम शोध के साथ अद्यतन रहना

फार्मास्युटिकल कंपनियों में वैज्ञानिक कई अनुशासनों में प्रकाशित नवीनतम शोध के साथ अद्यतन रहते हैं। हालाँकि, हर सप्ताह सैकड़ों नए शोध पत्रों की मैन्युअल समीक्षा में काफी समय लगता है।

इसके बजाय, वे Databricks Dolly LLM का उपयोग करके शोध पत्रों का विश्लेषण कर सकते हैं और उद्देश्यों, विधियों, परिणामों और निष्कर्षों जैसे प्रमुख तत्वों को निकाल सकते हैं। यह बहुपृष्ठीय सारांशों को संयोजित कर सकता है और प्रत्येक पेपर से सबसे महत्वपूर्ण अंतर्दृष्टियों को हाइलाइट कर सकता है।

चुनौतियाँ और सीमाएँ

किसी भी अन्य अग्रणी LLM तकनीक की तरह, Dolly में भी कुछ सीमाएँ और चुनौतियाँ हैं। यहाँ Dolly की तीन प्रमुख खामियाँ दी गई हैं:

हैलुसिनेट करना या तथ्यात्मक रूप से गलत प्रतिक्रियाएँ उत्पन्न करना, क्योंकि यह ChatGPT की तुलना में बहुत छोटे डेटासेट पर प्रशिक्षित है।
इसे आपकी ज़रूरतों के लिए फाइन-ट्यून और कस्टमाइज़ करना कठिन है, क्योंकि इसके लिए मशीन लर्निंग और NLP विशेषज्ञता का एक स्तर आवश्यक है।
गणितीय प्रश्नों, प्रोग्रामिंग समस्याओं को हल करने और प्रतिक्रियाओं में हास्य जोड़ने में संघर्ष करता है।

Dolly LLM की कमियों को कम करना

हालाँकि Dolly की वर्तमान सीमाओं को कम करने के लिए कोई पुष्ट तकनीक उपलब्ध नहीं है, Databricks लगातार शोध कर रहा है और अपने मौजूदा AI मॉडलों में सुधार के तरीके खोजने का लक्ष्य रखता है। Dolly इसका एक उदाहरण है जो वर्तमान में संस्करण 2 में है, लेकिन आने वाले वर्षों में हमें और सुधार देखने को मिल सकते हैं।

निष्कर्ष और आगे के कदम

Databricks Dolly एक ओपन-सोर्स AI मॉडल है जो कमर्शियल उपयोग के लिए उपलब्ध है। आप इसके प्रशिक्षण कोड और डेटासेट्स का उपयोग करके अपनी आवश्यकताओं को पूरा करने वाले विशिष्ट LLMs बना सकते हैं।

यदि आप इस Databricks Dolly ट्यूटोरियल से आगे बढ़ने और अपनी मौजूदा कौशल को निखारने के लिए तैयार हैं, तो निम्न संसाधनों से शुरुआत करें:

शुभ सीख!

FAQs

क्या Dolly 2.0 उपयोगकर्ताओं के लिए निःशुल्क है?

हाँ, आप Dolly 2.0 पर मूलभूत कार्य आज़मा सकते हैं। यह ओपन-सोर्स और कमर्शियल-यूज़ लाइसेंस के तहत जारी किया गया है, इसलिए यह निःशुल्क है।

क्या Databricks Dolly LLM को ChatGPT से प्राप्त डेटा पर प्रशिक्षित किया गया है?

नहीं, Databricks Dolly LLM को ChatGPT से प्राप्त डेटा पर प्रशिक्षित नहीं किया गया है। इसके बजाय, Dolly 2.0 को विशेष रूप से नए, मानव-जनित instruction डेटासेट पर फाइन-ट्यून किया गया था।

Dolly और ChatGPT में क्या अंतर है?

Dolly एक ओपन-सोर्स AI मॉडल है, जबकि ChatGPT एक क्लोज़्ड AI मॉडल है। इसका मतलब है कि Dolly का प्रशिक्षण कोड सार्वजनिक है, जबकि ChatGPT का निजी। Dolly को ChatGPT (175 बिलियन पैरामीटर्स) की तुलना में छोटे डेटासेट (6 बिलियन पैरामीटर्स) पर प्रशिक्षित किया गया था, जिससे Dolly कम जटिल और संभावित रूप से कम शक्तिशाली है।

विषय

डेटा इंजीनियरिंग

प्रौद्योगिकियाँ

विषय

एप्लिकेशन बनाने के लिए संपूर्ण Databricks Dolly ट्यूटोरियल

AI के साथ खोजें

क्यों Databricks Dolly?

Dolly के लाभ

Databricks Dolly के साथ शुरुआत

Databricks Dolly की कार्यक्षमता का अवलोकन

Databricks Dolly पर अपना वातावरण सेट करना

Databricks Dolly LLM के साथ काम करना

Dolly के साथ मूलभूत कार्य

टेक्स्ट जनरेशन

ब्रेनस्टॉर्मिंग

ओपन प्रश्न/उत्तर

उन्नत तकनीकें

कस्टम डेटा पर फाइन-ट्यूनिंग

डोमेन-विशिष्ट instruction डेटा का क्यूरेशन

डायनेमिक डेटा इनपुट शामिल करना

Databricks Dolly के साथ एप्लिकेशन बनाना

चैटबॉट बनाना

डेटा तैयारी और वेक्टर डेटाबेस निर्माण

प्रश्न और उत्तर के लिए प्रॉम्प्ट इंजीनियरिंग

वास्तविक दुनिया के उपयोग के मामले

1. वित्तीय विश्लेषकों के लिए स्वचालित डेटा सारांश

2. रिटेल उद्योगों में डेटा की सफाई और प्रीप्रोसेसिंग

3. फार्मास्युटिकल उद्योगों में नवीनतम शोध के साथ अद्यतन रहना

चुनौतियाँ और सीमाएँ

Dolly LLM की कमियों को कम करना

निष्कर्ष और आगे के कदम

FAQs

विषय

प्रौद्योगिकियाँ

विषय