paint-brush
बड़े भाषा मॉडल को स्थानीय रूप से कैसे होस्ट करें द्वारा@thomascherickal
24,876 रीडिंग
24,876 रीडिंग

बड़े भाषा मॉडल को स्थानीय रूप से कैसे होस्ट करें

द्वारा Thomas Cherickal
Thomas Cherickal HackerNoon profile picture

Thomas Cherickal

@thomascherickal

Evergreen Emerging Engineering Edutainment: Evergreen Content About Emerging Technology That...

6 मिनट read2023/06/05
Read on Terminal Reader
Read this story in a terminal
Print this story

बहुत लंबा; पढ़ने के लिए

बड़े भाषा मॉडल (एलएलएम) कृत्रिम बुद्धि (एआई) का एक सबसेट हैं जो प्राकृतिक भाषा को समझने और उत्पन्न करने के लिए डिज़ाइन किए गए हैं। एलएलएम का उपयोग चैटबॉट्स से लेकर भाषा अनुवाद सेवाओं तक कई प्रकार के अनुप्रयोगों को विकसित करने के लिए किया गया है। इस लेख में, हम चर्चा करेंगे कि एक कंप्यूटर पर एलएलएम कैसे बनाया जाए और स्रोत कोड उदाहरण प्रदान करें।
featured image - बड़े भाषा मॉडल को स्थानीय रूप से कैसे होस्ट करें
Thomas Cherickal HackerNoon profile picture
Thomas Cherickal

Thomas Cherickal

@thomascherickal

Evergreen Emerging Engineering Edutainment: Evergreen Content About Emerging Technology That Educates and Entertains!

0-item
1-item
2-item

STORY’S CREDIBILITY

DYOR

DYOR

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)

Code License

Code License

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Guide

Guide

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.


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


आवश्यक शर्तें

शुरू करने से पहले, यह सुनिश्चित करना आवश्यक है कि आपका कंप्यूटर निम्नलिखित आवश्यकताओं को पूरा करता है:


  1. कम से कम 16GB RAM और 1TB के निःशुल्क संग्रहण वाला एक शक्तिशाली कंप्यूटर
  2. कम से कम 8GB वीडियो मेमोरी के साथ एक आधुनिक GPU, जैसे कि NVIDIA GeForce या AMD Radeon
  3. एक Linux ऑपरेटिंग सिस्टम, जैसे कि Ubuntu या CentOS
  4. कमांड लाइन इंटरफेस (सीएलआई) और पायथन प्रोग्रामिंग भाषा का बुनियादी ज्ञान

चरण 1: एनाकोंडा स्थापित करें

एनाकोंडा डेटा साइंस और मशीन लर्निंग के लिए एक लोकप्रिय ओपन-सोर्स प्लेटफॉर्म है। इसमें विभिन्न उपकरण और पुस्तकालय शामिल हैं जिनका उपयोग हम एलएलएम बनाने के लिए करेंगे। एनाकोंडा स्थापित करने के लिए, इन चरणों का पालन करें:


  1. आधिकारिक वेबसाइट से एनाकोंडा इंस्टॉलर डाउनलोड करें: https://www.anaconda.com/products/individual

  2. टर्मिनल खोलें और उस निर्देशिका पर नेविगेट करें जहां इंस्टॉलर डाउनलोड किया गया था

  3. निम्न आदेश टाइप करके इंस्टॉलर चलाएं: बैश एनाकोंडा3–2021.11-लिनक्स-x86_ 64.sh

  4. स्थापना को पूरा करने के लिए स्क्रीन पर दिए गए निर्देशों का पालन करें


चरण 2: एक पायथन वातावरण बनाएँ

हम एलएलएम के लिए आवश्यक पुस्तकालयों और निर्भरताओं को स्थापित करने के लिए एक पायथन वातावरण तैयार करेंगे। परिवेश बनाने के लिए, इन चरणों का पालन करें:


  1. टर्मिनल खोलें और निम्न आदेश टाइप करें: conda create — name lm python=3.8

  2. टाइप करके पर्यावरण को सक्रिय करें: कोंडा सक्रिय एलएम


चरण 3: टेंसरफ्लो स्थापित करें

TensorFlow मशीन लर्निंग मॉडल के निर्माण और प्रशिक्षण के लिए एक ओपन-सोर्स प्लेटफॉर्म है। LLM बनाने के लिए हम TensorFlow का उपयोग करेंगे। TensorFlow को स्थापित करने के लिए, इन चरणों का पालन करें:


  1. टर्मिनल में निम्न कमांड टाइप करें: पाइप टेंसरफ़्लो स्थापित करें

  2. सत्यापित करें कि TensorFlow को पायथन में आयात करके स्थापित किया गया है: TensorFlow को tf के रूप में आयात करें


चरण 4: एक पूर्व-प्रशिक्षित एलएलएम डाउनलोड करें

शुरुआत से एलएलएम को प्रशिक्षित करने के लिए भारी मात्रा में कम्प्यूटेशनल शक्ति और समय की आवश्यकता होती है। सौभाग्य से, पूर्व-प्रशिक्षित मॉडल उपलब्ध हैं जिन्हें हम अपने विशिष्ट उपयोग मामले के लिए फ़ाइन-ट्यून कर सकते हैं। सबसे लोकप्रिय पूर्व-प्रशिक्षित एलएलएम में से एक GPT-2 (जेनरेटिव प्री-प्रशिक्षित ट्रांसफॉर्मर 2) है। पूर्व-प्रशिक्षित GPT-2 मॉडल को डाउनलोड करने के लिए, इन चरणों का पालन करें:


  1. टर्मिनल खोलें और निम्न आदेश टाइप करें: गिट क्लोन https://github.com/openai/gpt-2.git

  2. टाइप करके gpt-2 निर्देशिका पर नेविगेट करें: cd gpt-2

  3. टाइप करके पूर्व-प्रशिक्षित मॉडल डाउनलोड करें: python download_ model.py 117M


चरण 5: पूर्व प्रशिक्षित एलएलएम को ठीक करें

पूर्व-प्रशिक्षित एलएलएम को फाइन-ट्यूनिंग में एक विशिष्ट कार्य के लिए विशिष्ट डेटासेट पर मॉडल को प्रशिक्षित करना शामिल है। हमारे उदाहरण में, हम टेक्स्ट जनरेशन टास्क पर पहले से प्रशिक्षित GPT-2 मॉडल को फाइन-ट्यून करेंगे। मॉडल को फ़ाइन-ट्यून करने के लिए, इन चरणों का पालन करें:


  1. फ़ाइन-ट्यून किए गए मॉडल के लिए टाइप करके एक नई निर्देशिका बनाएँ: mkdir my_model
  2. टाइप करके my_model निर्देशिका पर नेविगेट करें: cd my_model
  3. टाइप करके एक नई पायथन फाइल बनाएं: train.py को टच करें
  4. एक टेक्स्ट एडिटर में train.py फ़ाइल खोलें और निम्न कोड पेस्ट करें:


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 मॉडल को लोड करते हैं और डेटासेट के लिए इनपुट फ़ंक्शन को परिभाषित करते हैं। अंत में, हम प्रशिक्षण समारोह को परिभाषित करते हैं और प्रशिक्षण शुरू करते हैं।


चरण 6: ठीक-ठीक एलएलएम का उपयोग करके पाठ उत्पन्न करें

एक बार एलएलएम ठीक हो जाने के बाद, हम इसका उपयोग पाठ उत्पन्न करने के लिए कर सकते हैं। पाठ उत्पन्न करने के लिए, इन चरणों का पालन करें:


  1. टर्मिनल खोलें और टाइप करके my_model डायरेक्टरी में नेविगेट करें: cd my_model
  2. टाइप करके एक नई पायथन फ़ाइल बनाएँ: Generate.py को स्पर्श करें
  3. एक पाठ संपादक में Generate.py फ़ाइल खोलें और निम्न कोड पेस्ट करें:



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 मॉडल को फाइन-ट्यून किया। अंत में, हमने ठीक-ठीक एलएलएम का उपयोग करके पाठ तैयार किया।


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


अगली पीढ़ी?

अगली पीढ़ी?


संदर्भ

  1. रेडफोर्ड, ए।, वू, जे।, चाइल्ड, आर।, लुआन, डी।, अमोदेई, डी।, और सुतस्केवर, आई। (2019)। भाषा मॉडल अनियंत्रित मल्टीटास्क शिक्षार्थी हैं। ओपनएआई ब्लॉग, 1(8), 9।
  2. ओपनएआई। (2019)। GPT-2: भाषा मॉडल बिना निगरानी वाले मल्टीटास्क शिक्षार्थी हैं। जीथब। https://github.com/openai/gpt-2 से लिया गया।
  3. टेंसरफ्लो। (2021)। TensorFlow: सभी के लिए एक ओपन सोर्स मशीन लर्निंग फ्रेमवर्क। https://www.tensorflow.org/ से लिया गया।
  4. ब्राउन, टीबी, मान, बी।, राइडर, एन।, सुब्बैया, एम।, कपलान, जे।, धारीवाल, पी।, … और अमोदी, डी। (2020)। भाषा मॉडल कम-शॉट सीखने वाले होते हैं। arXiv प्रीप्रिंट arXiv: 2005.14165।


यहाँ भी प्रकाशित हुआ।

X REMOVE AD