आप OpenAI के मॉडल के साथ जो कर सकते हैं वह आकर्षक है। इसके अलावा, LangChain और llama-index जैसे टूल मूल चैटजीपीटी जैसी प्रणाली को कोड की कुछ पंक्तियों में चलाना और चलाना वास्तव में आसान बनाते हैं। हालाँकि, अधिकांश उदाहरण OpenAI के API पर निर्मित होते हैं जो सभी मामलों में व्यावहारिक नहीं है, उदाहरण के लिए क्योंकि आप अपना डेटा क्लाउड में नहीं भेज सकते हैं या आप पैसा खर्च नहीं कर सकते हैं ।

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

चरण 1: अपना डेटा एकत्र करें और निर्भरताएँ स्थापित करें

इस चरण के लिए, केवल वह सभी डेटा एकत्र करें जिसका आप उपयोग करना चाहते हैं और इसे अपनी स्थानीय मशीन पर एक निर्देशिका में रखें। मेरे मामले में, ये हमारे डेटा क्यूरेशन टूल स्पॉटलाइट के डॉक्स से खींची गई मार्कडाउन फ़ाइलों का एक गुच्छा था (इसे भी देखें ;-))।

अगला, वह सब कुछ स्थापित करें जिसकी आपको आवश्यकता है:

pip install torch transformers langchain llama-index====0.6.0.alpha3

निम्नलिखित कोड की प्रतिलिपि बनाएँ और अपने इनपुट फ़ोल्डर में पथ समायोजित करें। यह अंतिम आउटपुट उत्पन्न करने के लिए पुनर्प्राप्ति और डेटाब्रिक की डोली के लिए एम्बेडिंग उत्पन्न करने के लिए हगिंगफेस ट्रांसफॉर्मर लाइब्रेरी का उपयोग करता है।

from pathlib import Path
import torch
from transformers import pipeline
from langchain.llms.base import LLM
from llama_index import SimpleDirectoryReader, LangchainEmbedding, GPTVectorStoreIndex, PromptHelper, LLMPredictor, ServiceContext
from llama_index.langchain_helpers.text_splitter import TokenTextSplitter
from llama_index.node_parser.simple import SimpleNodeParser
from langchain.embeddings.huggingface import HuggingFaceEmbeddings

INPUT_FOLDER = "path/to/your/data/folder"

index_files = list(Path(INPUT_FOLDER).glob("*"))

max_input_size = 2048
num_output = 256
max_chunk_overlap = 20
prompt_helper = PromptHelper(max_input_size, num_output, max_chunk_overlap)


pipe = pipeline("text-generation", model="databricks/dolly-v2-3b", trust_remote_code=True, torch_dtype=torch.bfloat16, device_map="auto")
embed_model = LangchainEmbedding(HuggingFaceEmbeddings())

class CustomLLM(LLM):
    model_name = "databricks/dolly-v2-3b"

    def _call(self, prompt, stop = None):
        response = pipe(prompt, max_new_tokens=num_output)[0]["generated_text"]
        return response

    @property
    def _identifying_params(self):
        return {"name_of_model": self.model_name}

    @property
    def _llm_type(self):
        return "custom"

# define our LLM
llm_predictor = LLMPredictor(llm=CustomLLM())

node_parser = SimpleNodeParser(text_splitter=TokenTextSplitter(chunk_size=512, chunk_overlap=max_chunk_overlap))
prompt_helper = PromptHelper(max_input_size, num_output, max_chunk_overlap)
service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, node_parser=node_parser, chunk_size_limit=512)
# Load your data
documents = SimpleDirectoryReader(input_files=index_files).load_data()

index = GPTVectorStoreIndex.from_documents(documents, service_context=service_context)

query_engine = index.as_query_engine()

चरण 3: अपने सिस्टम का उपयोग करें

हम पहले ही कर चुके हैं! अब आप अपने डेटा के बारे में प्रश्न पूछने के लिए क्वेरी इंजन ऑब्जेक्ट का उपयोग कर सकते हैं!

हमारे दस्तावेज़ों पर मैंने कोशिश की एक उदाहरण संकेत कुछ ऐसा है:

print(query_engine.query("Summarize typical use cases of the similarity map in few sentences."))

The Similarity Map helps to explore simulation similarities and find explanations for observable phenomens.
It can be used to group designs by similarity, find outliers and detect correlations between features and target values.