Evergreen Emerging Engineering Edutainment: Evergreen Content About Emerging Technology That Educates and Entertains!
The writer is smart, but don't just like, take their word for it. #DoYourOwnResearch before making any investment decisions or decisions regarding you health or security. (Do not regard any of this content as professional investment advice, or health advice)
The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.
Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.
बड़े भाषा मॉडल (एलएलएम) कृत्रिम बुद्धि (एआई) का एक सबसेट हैं जो प्राकृतिक भाषा को समझने और उत्पन्न करने के लिए डिज़ाइन किए गए हैं। इन मॉडलों को बड़ी मात्रा में शाब्दिक डेटा पर प्रशिक्षित किया जाता है और भाषा में पैटर्न सीखने के लिए जटिल एल्गोरिदम का उपयोग किया जाता है। एलएलएम का उपयोग चैटबॉट्स से लेकर भाषा अनुवाद सेवाओं तक कई प्रकार के अनुप्रयोगों को विकसित करने के लिए किया गया है। इस लेख में, हम चर्चा करेंगे कि एक ही कंप्यूटर पर एलएलएम कैसे बनाया जाए और स्रोत कोड उदाहरण प्रदान करें।
शुरू करने से पहले, यह सुनिश्चित करना आवश्यक है कि आपका कंप्यूटर निम्नलिखित आवश्यकताओं को पूरा करता है:
एनाकोंडा डेटा साइंस और मशीन लर्निंग के लिए एक लोकप्रिय ओपन-सोर्स प्लेटफॉर्म है। इसमें विभिन्न उपकरण और पुस्तकालय शामिल हैं जिनका उपयोग हम एलएलएम बनाने के लिए करेंगे। एनाकोंडा स्थापित करने के लिए, इन चरणों का पालन करें:
आधिकारिक वेबसाइट से एनाकोंडा इंस्टॉलर डाउनलोड करें: https://www.anaconda.com/products/individual
टर्मिनल खोलें और उस निर्देशिका पर नेविगेट करें जहां इंस्टॉलर डाउनलोड किया गया था
निम्न आदेश टाइप करके इंस्टॉलर चलाएं: बैश एनाकोंडा3–2021.11-लिनक्स-x86_ 64.sh
स्थापना को पूरा करने के लिए स्क्रीन पर दिए गए निर्देशों का पालन करें
हम एलएलएम के लिए आवश्यक पुस्तकालयों और निर्भरताओं को स्थापित करने के लिए एक पायथन वातावरण तैयार करेंगे। परिवेश बनाने के लिए, इन चरणों का पालन करें:
टर्मिनल खोलें और निम्न आदेश टाइप करें: conda create — name lm python=3.8
टाइप करके पर्यावरण को सक्रिय करें: कोंडा सक्रिय एलएम
TensorFlow मशीन लर्निंग मॉडल के निर्माण और प्रशिक्षण के लिए एक ओपन-सोर्स प्लेटफॉर्म है। LLM बनाने के लिए हम TensorFlow का उपयोग करेंगे। TensorFlow को स्थापित करने के लिए, इन चरणों का पालन करें:
टर्मिनल में निम्न कमांड टाइप करें: पाइप टेंसरफ़्लो स्थापित करें
सत्यापित करें कि TensorFlow को पायथन में आयात करके स्थापित किया गया है: TensorFlow को tf के रूप में आयात करें
शुरुआत से एलएलएम को प्रशिक्षित करने के लिए भारी मात्रा में कम्प्यूटेशनल शक्ति और समय की आवश्यकता होती है। सौभाग्य से, पूर्व-प्रशिक्षित मॉडल उपलब्ध हैं जिन्हें हम अपने विशिष्ट उपयोग मामले के लिए फ़ाइन-ट्यून कर सकते हैं। सबसे लोकप्रिय पूर्व-प्रशिक्षित एलएलएम में से एक GPT-2 (जेनरेटिव प्री-प्रशिक्षित ट्रांसफॉर्मर 2) है। पूर्व-प्रशिक्षित GPT-2 मॉडल को डाउनलोड करने के लिए, इन चरणों का पालन करें:
टर्मिनल खोलें और निम्न आदेश टाइप करें: गिट क्लोन https://github.com/openai/gpt-2.git
टाइप करके gpt-2 निर्देशिका पर नेविगेट करें: cd gpt-2
टाइप करके पूर्व-प्रशिक्षित मॉडल डाउनलोड करें: python download_ model.py 117M
पूर्व-प्रशिक्षित एलएलएम को फाइन-ट्यूनिंग में एक विशिष्ट कार्य के लिए विशिष्ट डेटासेट पर मॉडल को प्रशिक्षित करना शामिल है। हमारे उदाहरण में, हम टेक्स्ट जनरेशन टास्क पर पहले से प्रशिक्षित GPT-2 मॉडल को फाइन-ट्यून करेंगे। मॉडल को फ़ाइन-ट्यून करने के लिए, इन चरणों का पालन करें:
import tensorflow as tf
import numpy as np
import os
import json
import random
import time
import argparse
#Define the command-line arguments
parser = argparse.ArgumentParser()
parser.add_argument("--dataset_path", type=str, required=True, help="Path to the dataset") parser.add_argument("--model_path", type=str, required=True, help="Path to the pre-trained model") parser.add_argument("--output_path", type=str, required=True, help="Path to save the fine-tuned model")
parser.add_argument("--batch_size", type=int, default=16, help="Batch size for training") parser.add_argument("--epochs", type=int, default=1, help="Number of epochs to train for")
args = parser.parse_args()
#Load the pre-trained GPT-2 model
with open(os.path.join(args.model_path, "hparams.json"), "r") as f:
hparams = json.load(f)
model = tf.compat.v1.estimator.Estimator( model_fn=model_fn, model_dir=args.output_path, params=hparams, config=tf.compat.v1.estimator.RunConfig( save_checkpoints_steps=5000, keep_checkpoint_max=10, save_summary_steps=5000 ))
#Define the input function for the dataset
def input_fn(mode):
dataset = tf.data.TextLineDataset(args.dataset_path)
dataset = dataset.repeat()
dataset = dataset.shuffle(buffer_size=10000)
dataset = dataset.batch(args.batch_size)
dataset = dataset.map(lambda x: tf.strings.substr(x, 0, hparams["n_ctx"]))
iterator = dataset.make_one_shot_iterator()
return iterator.get_next()
#Define the training function
def train():
for epoch in range(args.epochs):
model.train(input_fn=lambda: input_fn(tf.estimator.ModeKeys.TRAIN)) print(f"Epoch {epoch+1} completed.")
#Start the training
train()
ऊपर दिए गए कोड में, हम डेटासेट पथ, पूर्व-प्रशिक्षित मॉडल पथ, आउटपुट पथ, बैच आकार और प्रशिक्षण के लिए युगों की संख्या के लिए कमांड-लाइन तर्कों को परिभाषित करते हैं। फिर हम पूर्व-प्रशिक्षित GPT-2 मॉडल को लोड करते हैं और डेटासेट के लिए इनपुट फ़ंक्शन को परिभाषित करते हैं। अंत में, हम प्रशिक्षण समारोह को परिभाषित करते हैं और प्रशिक्षण शुरू करते हैं।
एक बार एलएलएम ठीक हो जाने के बाद, हम इसका उपयोग पाठ उत्पन्न करने के लिए कर सकते हैं। पाठ उत्पन्न करने के लिए, इन चरणों का पालन करें:
import tensorflow as tf
import numpy as np
import os
import json
import random
import time
import argparse
#Define the command-line arguments
parser = argparse.ArgumentParser()
parser.add_argument("--model_path", type=str, required=True, help="Path to the fine-tuned model") parser.add_argument("--length", type=int, default=100, help="Length of the generated text") parser.add_argument("--temperature", type=float, default=0.7, help="Temperature for text generation")
args = parser.parse_args()
#Load the fine-tuned model
with open(os.path.join(args.model_path, "hparams.json"), "r") as f:
hparams = json.load(f)
model_fn = model_fn(hparams, tf.estimator.ModeKeys.PREDICT)
model = tf.compat.v1.estimator.Estimator( model_fn=model_fn, model_dir=args.model_path, params=hparams )
#Define the generation function
def generate_text(length, temperature):
start_token = "<|startoftext|>"
tokens = tokenizer.convert_tokens_to_ids([start_token])
token_length = len(tokens)
while token_length < length:
prediction_input = np.array(tokens[-hparams["n_ctx"]:])
output = list(model.predict(input_fn=lambda: [[prediction_input]]))[0]["logits"]
logits = output[-1] / temperature
logits = logits - np.max(logits)
probs = np.exp(logits) / np.sum(np.exp(logits))
token = np.random.choice(range(hparams["n_vocab"]), p=probs)
tokens.append(token)
token_length += 1
output_text = tokenizer.convert_ids_to_tokens(tokens)
output_text = "".join(output_text).replace("▁", " ")
output_text = output_text.replace(start_token, "")
return output_text
#Generate text
text = generate_text(args.length, args.temperature)
print(text)
उपरोक्त कोड में, हम ठीक-ट्यून किए गए मॉडल पथ, जेनरेट किए गए टेक्स्ट की लंबाई और टेक्स्ट जनरेशन के लिए तापमान के लिए कमांड लाइन तर्कों को परिभाषित करते हैं। फिर हम फ़ाइन-ट्यून किए गए मॉडल को लोड करते हैं और जनरेशन फ़ंक्शन को परिभाषित करते हैं। अंत में, हम Generate_text फ़ंक्शन का उपयोग करके टेक्स्ट जनरेट करते हैं और आउटपुट प्रिंट करते हैं, और हमारा काम हो गया!
इस लेख में, हमने TensorFlow और GPT-2 आर्किटेक्चर का उपयोग करके एक ही कंप्यूटर पर लार्ज लैंग्वेज मॉडल (LLM) बनाने का तरीका सीखा है। हमने TensorFlow को स्थापित करके और OpenAI GitHub रिपॉजिटरी से GPT-2 कोड डाउनलोड करके शुरुआत की। फिर हमने डेटासेट पर GPT-2 मॉडल को प्रशिक्षित किया और उसी डेटासेट का उपयोग करके पूर्व-प्रशिक्षित GPT-2 मॉडल को फाइन-ट्यून किया। अंत में, हमने ठीक-ठीक एलएलएम का उपयोग करके पाठ तैयार किया।
इस आलेख में दिए गए चरणों का पालन करके, आप अपना एलएलएम बना सकते हैं और भाषा अनुवाद, चैटबॉट और सामग्री निर्माण जैसे विभिन्न कार्यों के लिए पाठ उत्पन्न कर सकते हैं।
बड़े भाषा मॉडल को स्थानीय रूप से कैसे होस्ट करें | HackerNoon