Hugging Face का Text Generation Inference टूलकिट LLMs के लिए — AI में एक गेम चेंजर

चित्र: लेखक द्वारा

कृत्रिम बुद्धिमत्ता के तीव्रता से विकसित होते क्षेत्र में, बड़े भाषा मॉडल हालिया प्रगतियों के मुख्य नायक बनकर उभरे हैं।

टेक्स्ट जनरेशन एक क्रांतिकारी क्षमता बन गई है, जिसने मशीनों के मानव-समान पाठ को समझने और उत्पन्न करने के तरीके को बदल दिया है। यही लोकप्रियता कारण है कि LLMs के साथ काम को आसान बनाने के लिए कई टूल लॉन्च किए गए हैं।

बड़े भाषा मॉडलों (LLMs) का तेज़ प्रसार, जिनमें लगभग हर सप्ताह नए मॉडल सामने आ रहे हैं, इस तकनीक की होस्टिंग के विकल्पों में भी समानांतर वृद्धि लेकर आया है। उपलब्ध टूल्स के इस विशाल इकोसिस्टम में, Hugging Face का Text Generation Inference (TGI) खास तौर पर उल्लेखनीय है, क्योंकि यह हमें अपनी स्थानीय मशीन पर एक सेवा के रूप में LLM चलाने की सुविधा देता है।

सरल शब्दों में कहें, यह हमें अपने मॉडल को कॉल करने के लिए एक एंड-पॉइंट उपलब्ध कराता है।

यह गाइड बताएगा कि Hugging Face TGI क्यों गेम-चेंजर है और आप इसका उपयोग ऐसे उन्नत AI मॉडल बनाने में कैसे कर सकते हैं जो मनुष्यों द्वारा लिखे गए पाठ से लगभग अप्रभेद्य टेक्स्ट उत्पन्न कर सकें।

Hugging Face Text Generation Inference क्या है?

Hugging Face Text Generation Inference, जिसे TGI के नाम से भी जाना जाता है, बड़े भाषा मॉडलों को डिप्लॉय और सर्व करने के लिए Rust और Python में लिखा एक फ्रेमवर्क है। यह LLMs को डिप्लॉय और सर्व करने के लिए प्रोडक्शन-रेडी टूलकिट है।

Hugging Face इसे HFOILv1.0 लाइसेंस के तहत विकसित और वितरित करता है, जो व्यावसायिक उपयोग की अनुमति देता है बशर्ते यह उत्पाद या सेवा का मुख्य फोकस न होकर सहायक टूल के रूप में कार्य करे। यह जिन मुख्य चुनौतियों को संबोधित करता है, वे हैं:

चित्र: लेखक द्वारा।

• हाई-परफ़ॉर्मेंस टेक्स्ट जनरेशन। TGI Tensor Parallelism (एक तकनीक जिससे बड़े मॉडल को कई GPUs में फिट किया जाता है) और डायनेमिक बैचिंग (सर्वर के अंदर ऑन-द-फ्लाई प्रॉम्प्ट्स को साथ में बैच करना) जैसी तकनीकों का उपयोग करता है ताकि StarCoder, BLOOM, GPT-NeoX, Llama और T5 जैसे लोकप्रिय ओपन-सोर्स LLMs के प्रदर्शन को ऑप्टिमाइज़ किया जा सके।
• संसाधनों का कुशल उपयोग। कंटीन्युअस बैचिंग, ऑप्टिमाइज़्ड कोड, और Tensor Parallelism जैसी विशेषताएं TGI को एक साथ कई अनुरोध संभालने में सक्षम बनाती हैं, वह भी न्यूनतम संसाधन उपयोग के साथ।
• लचीलापन। TGI वॉटरमार्किंग, लॉजिट वार्पिंग (विशिष्ट टोकनों के logits में बायस मान डालकर उन्हें संशोधित करना) के जरिए बायस नियंत्रण, और स्टॉप सीक्वेंस जैसी विविध सुरक्षा एवं सेफ्टी सुविधाओं का समर्थन करता है, जिससे LLM का उपयोग जिम्मेदार और नियंत्रित रहे।

Hugging Face ने कुछ LLMs की आर्किटेक्चर को इस तरह ऑप्टिमाइज़ किया है कि वे TGI के साथ तेज़ी से चलें। इसमें LLaMA, Falcon7B और Mistral जैसे लोकप्रिय मॉडल शामिल हैं। पूरी सूची उनके दस्तावेज़ में मिल सकती है।

Hugging Face TGI क्यों इस्तेमाल करें?

Hugging Face प्राकृतिक भाषा क्षमताओं वाले AI बनाने का पसंदीदा केंद्र बन गया है। यह ओपन-सोर्स के दिग्गज मॉडलों का घर है, जो इसे NLP नवाचार का पावरहाउस बनाता है। अब तक, इन मॉडलों में से अधिकांश इतने भारी थे कि उन्हें सीधे लोकल पर उपयोग नहीं किया जा सकता था; क्लाउड-आधारित सेवाओं पर निर्भरता बनी रहती थी।

हालांकि, QLoRa और GPTQ जैसी क्वांटाइज़ेशन तकनीकों में हालिया प्रगति को देखते हुए, कुछ LLMs अब हमारे रोज़मर्रा के उपकरणों—जैसे स्थानीय कंप्यूटर—पर भी संभाले जा सकते हैं।

Hugging Face TGI खास तौर पर हमारी स्थानीय मशीनों पर LLMs-एज़-ए-सर्विस उपलब्ध कराने के लिए डिज़ाइन किया गया है। इसके पीछे मुख्य कारण LLM को बूट करने की मशक्कत है।

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

TGI के बारे में जो बात मुझे सबसे अच्छी लगी, वह है इसका बिना झंझट वाला दृष्टिकोण। इस समय, TGI कई सुव्यवस्थित मॉडल आर्किटेक्चरों के साथ काम करने के लिए तैयार है, जिससे इन्हें फटाफट डिप्लॉय करना आसान हो जाता है।

और यह सिर्फ बात नहीं है; TGI पहले से ही कई लाइव प्रोजेक्ट्स का इंजन है। कुछ उदाहरण हैं:

चित्र: लेखक द्वारा। Hugging Chat (बाएँ) और OpenAssistant (दाएँ) के लोगो

• Hugging Chat, ओपन-एक्सेस मॉडलों के लिए एक ओपन-सोर्स इंटरफ़ेस।
• OpenAssistant, LLMs को प्रशिक्षित करने के लिए एक ओपन-सोर्स समुदाय प्रयास।
• nat.dev, LLMs को खोजने और तुलना करने के लिए एक प्लेग्राउंड।

हालांकि एक बड़ा अड़चन है। TGI अभी तक ARM-आधारित GPU वाले Macs, जिसमें M1 सीरीज़ और बाद के मॉडल शामिल हैं, के साथ संगत नहीं है।

Hugging Face TGI सेटअप करना

सबसे पहले, हमें अपना Hugging Face TGI एंड-पॉइंट सेटअप करना होगा।

चित्र: लेखक द्वारा।

स्थानीय रूप से Hugging Face TGI को इंस्टॉल और लॉन्च करने के लिए, पहले आपको Rust इंस्टॉल करना होगा और फिर कम से कम Python 3.9 के साथ एक Python वर्चुअल एन्वायरनमेंट बनाना होगा, उदाहरण के लिए conda का उपयोग करके:

#Installing Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh


#Creating a python virtual environment
conda create -n text-generation-inference python=3.9 
conda activate text-generation-inferenceसंचालित द्वारा

इसके अलावा, Protoc इंस्टॉलेशन आवश्यक है। सर्वोत्तम संगतता के लिए Hugging Face संस्करण 21.12 उपयोग करने का सुझाव देता है। ध्यान दें कि इस इंस्टॉलेशन के लिए आपको sudo विशेषाधिकारों की आवश्यकता होगी।

PROTOC_ZIP=protoc-21.12-linux-x86_64.zip
curl -OL https://github.com/protocolbuffers/protobuf/releases/download/v21.12/$PROTOC_ZIP
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'
rm -f $PROTOC_ZIPसंचालित द्वारा

मैं पहले इसे शुरू से इंस्टॉल करने का तरीका बताऊंगा, जो मुझे सीधा सा नहीं लगता। यदि प्रक्रिया के दौरान आपको दिक्कत आए, तो आप इस पहले हिस्से को छोड़कर सीधे Docker इमेज चला सकते हैं, जो अधिक सरल है। दोनों परिदृश्यों पर चर्चा की जाएगी।

सभी पूर्वापेक्षाएँ पूरी होने के बाद, हम TGI सेटअप के लिए तैयार हैं। शुरुआत GitHub रिपोजिटरी क्लोन करने से करें:

git clone https://github.com/huggingface/text-generation-inference.gitसंचालित द्वारा

उसके बाद, अपनी स्थानीय कंप्यूटर पर TGI के लोकेशन पर स्विच करें और निम्न कमांड्स से इसे इंस्टॉल करें:

cd text-generation-inference/
BUILD_EXTENSIONS=False make installसंचालित द्वारा

अब देखते हैं कि Docker के साथ और बिना Docker के TGI का उपयोग कैसे करें। मैं Falcon-7B मॉडल का उपयोग करूंगा, जो Apache 2.0 लाइसेंस के अंतर्गत उपलब्ध है।

Docker के बिना मॉडल लॉन्च करना

इंस्टॉलेशन ने एक नया कमांड “text-generation-launcher” बना दिया है जो TGI सर्वर शुरू करेगा। Falcon-7B मॉडल के साथ एक एंड-पॉइंट सक्रिय करने के लिए, हमें बस निम्न कमांड चलानी है:

text-generation-launcher --model-id tiiuae/falcon-7b-instruct --num-shard 1 --port 8080 --quantize bitsandbytesसंचालित द्वारा

जहाँ प्रत्येक इनपुट पैरामीटर का अर्थ है:

• model-id: Hugging Face Hub पर सूचीबद्ध मॉडल के विशिष्ट नाम को संदर्भित करता है। हमारे मामले में Falcon-7B का नाम tiiuae/falcon-7b-instruct है।
• num-shard: इसे उन GPUs की संख्या के अनुसार समायोजित करें जिन्हें आप उपयोग करना चाहते हैं। डिफ़ॉल्ट रूप से यह 1 होगा।
• port: वह पोर्ट निर्दिष्ट करता है जिस पर आप सर्वर को अनुरोधों के लिए सुनना चाहते हैं। डिफ़ॉल्ट रूप से यह 8080 होगा।
• quantize: जिन GPUs की VRAM 24 GB से कम है, उनके लिए मेमोरी ओवरलोड से बचने हेतु मॉडल क्वांटाइज़ेशन आवश्यक है। पिछले कमांड में, मैंने तात्कालिक क्वांटाइज़ेशन के लिए "bitsandbytes" चुना है। एक अन्य विकल्प GPTQ ("gptq") भी है, हालांकि मैं इसके कार्यप्रणाली से कम परिचित हूँ।

Docker के साथ मॉडल लॉन्च करना (अधिक सरल)

सुनिश्चित करें कि आपके कंप्यूटर पर Docker इंस्टॉल है और वह पहले से चल रहा है। यदि आपको Docker का अनुभव नहीं है, तो आप यह Docker for Data Science ट्यूटोरियल देख सकते हैं, जो आपको बुनियादी जानकारी देगा।

याद रखें, TGI MX-प्रोसेसर वाले Mac मॉडलों के साथ संगत नहीं है। आप सभी उपलब्ध TGI इमेजेज संबंधित TGI पैकेजेज GitHub रिपोजिटरी में देख सकते हैं। यदि आपका डिवाइस संगत है, तो Docker आपके लिए उपयुक्त इमेज खोज लेगा।

पैरामीटर्स बड़े पैमाने पर text-generation-launcher के साथ उपयोग किए गए पैरामीटर्स से मेल खाते हैं। यदि आप केवल एक GPU के साथ काम कर रहे हैं, तो "all" की जगह "0" का उपयोग करें।

volume=$PWD/data
sudo docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data ghcr.io/huggingface/text-generation-inference:0.9 --model-id tiiuae/falcon-7b-instruct --num-shard 1  --quantize bitsandbytesसंचालित द्वारा

यह सुनिश्चित करें कि जब तक आप सर्वर का उपयोग करना चाहते हैं, तब तक Docker इमेज सक्रिय बनी रहे।

एप्लिकेशनों में TGI का उपभोग

Text Generation Inference (TGI) सर्वर को अपनी एप्लिकेशनों में एकीकृत करने के कई विकल्प हैं। एक बार यह चल रहा हो, तो आप /generate एंडपॉइंट पर POST अनुरोध करके नतीजे प्राप्त कर सकते हैं।

चित्र: लेखक द्वारा।

यदि आप चाहते हैं कि TGI लगातार टोकन स्ट्रीम करे, तो इसके लिए समर्पित एंडपॉइंट का उपयोग करें, जैसा कि हम अगले खंड में देखेंगे। ये अनुरोध आपकी पसंद के टूल—जैसे curl, Python, या TypeScript—से किए जा सकते हैं। TGI द्वारा सर्व किए जा रहे मॉडल को Python स्क्रिप्ट से क्वेरी करने के लिए, आपको निम्न text-generation लाइब्रेरी इंस्टॉल करनी होगी। बस यह pip कमांड चलाना पर्याप्त है:

pip install text-generationसंचालित द्वारा

TGI सर्वर शुरू करने के बाद, InferenceClient() को उस URL से इंस्टैंशिएट करें जो मॉडल सर्व करने वाले एंडपॉइंट की ओर इशारा करता है। फिर आप Python के जरिए एंडपॉइंट को हिट करने के लिए text_generation() कॉल कर सकते हैं।

from text_generation import Client
client = Client("http://127.0.0.1:8080")
client.text_generation(prompt="Your prompt here!")संचालित द्वारा

InferenceClient के साथ स्ट्रीमिंग सक्षम करने के लिए, आपको बस stream=True सेट करना है। इससे सर्वर पर जेनरेट होते ही आपको रियल-टाइम में टोकन प्राप्त होने लगेंगे। स्ट्रीमिंग इस प्रकार उपयोग कर सकते हैं:

for token in client.text_generation("Your prompt here!", max_new_tokens=12, stream=True):
    print(token)संचालित द्वारा

TGI के माध्यम से मॉडल को प्रॉम्प्ट करना

ध्यान रखें कि आप अपने एंडपॉइंट में डिप्लॉय किए गए मॉडल के साथ काम करेंगे—हमारे मामले में, Falcon-7B। TGI का उपयोग करके, हम एक लाइव एंडपॉइंट बनाते हैं जो हमें अपनी पसंद के LLM से प्रतिक्रियाएँ प्राप्त करने देता है।

इसलिए, Python का उपयोग करते समय, हम सीधे अपने स्थानीय डिवाइस पर होस्ट किए गए क्लाइंट के माध्यम से, जो पोर्ट 8080 पर सुलभ है, LLM को प्रॉम्प्ट भेज सकते हैं। तो संबंधित Python स्क्रिप्ट कुछ इस प्रकार दिखेगी:

from text_generation import Client
client = Client("http://127.0.0.1:8080")
print(client.generate("Translate the following sentence into spanish: 'What does Large Language Model mean?'", max_new_tokens=500).generated_text)संचालित द्वारा

और हमें अपने एन्वायरनमेंट में मॉडल इंस्टॉल किए बिना मॉडल से प्रतिक्रिया मिल जाएगी। Python के बजाय, हम नीचे दिए उदाहरण की तरह CURL से भी LLM को क्वेरी कर सकते हैं:

curl 127.0.0.1:8080/generate \
    -X POST \
    -d '{"inputs":"Code in Javascript a function to remove all spaces in a string and then print the string twice.","parameters":{"max_new_tokens":500}}' \
    -H 'Content-Type: application/json'संचालित द्वारा

TGI के साथ थोड़ा प्रयोग करने पर इसकी प्रभावशाली गति दिखती है। Falcon-7B के साथ (500 टोकन सीमा पर) इसमें कुछ ही सेकंड लगते हैं। जबकि पारंपरिक इंफ़ेरेंस विधि (transformers लाइब्रेरी का उपयोग करते हुए) में लगभग 30 सेकंड लगते हैं।

OpenAI के साथ OpenAI Chat Completion का उपयोग कर एकीकरण

संस्करण 1.4.0 से आगे, TGI ने OpenAI के Chat Completion API के साथ संगत एक API पेश किया है। यह नया Messages API ग्राहकों और उपयोगकर्ताओं को OpenAI मॉडलों से ओपन-सोर्स LLMs पर सहज रूप से स्थानांतरित होने में सक्षम बनाता है। यह API OpenAI की क्लाइंट लाइब्रेरीज़ या LangChain और LlamaIndex जैसे थर्ड-पार्टी टूल्स के साथ सीधे एकीकरण के लिए डिज़ाइन किया गया है।

Messages के लिए TGI का समर्थन सुनिश्चित करता है कि इसके Inference Endpoints OpenAI Chat Completion API के साथ पूरी तरह संगत हैं। इस संगतता के माध्यम से उपयोगकर्ता OpenAI मॉडलों का उपयोग करने वाली किसी भी मौजूदा स्क्रिप्ट को बिना किसी झंझट के TGI एंडपॉइंट्स पर होस्ट किए गए ओपन LLMs से बदल सकते हैं।

यह अपग्रेड बिना बाधा के स्विच को सक्षम करता है और ओपन-सोर्स मॉडलों के व्यापक लाभों तक त्वरित पहुंच देता है, जिनमें शामिल हैं:

• मॉडलों और डेटा पर पूर्ण नियंत्रण और पारदर्शिता।
• रेट लिमिट्स की चिंताओं का निवारण।
• विशिष्ट आवश्यकताओं के अनुसार सिस्टम को अनुकूलित करने की लचीलापन।

OpenAI चैट कम्प्लीशन प्रोटोकॉल में TGI को एकीकृत करने का एक उदाहरण नीचे संलग्न है:

from openai import OpenAI

# initialize the client but point it to TGI
client = OpenAI(
    base_url="<ENDPOINT_URL>" + "/v1/",  # replace with your endpoint url
    api_key="<HF_API_TOKEN>",  # replace with your token
)
chat_completion = client.chat.completions.create(
    model="tgi",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Why is open-source software important?"},
    ],
    stream=True,
    max_tokens=500
)

# iterate and print stream
for message in chat_completion:
    print(message.choices[0].delta.content, end="")संचालित द्वारा

जैसा कि आप देख सकते हैं, openai लाइब्रेरी का उपयोग हमारे ENDPOINT और हमारे Hugging Face पासवर्ड को इंगित करने के लिए किया जा सकता है। इस एकीकरण को और समझने के लिए, आप Hugging Face TGI दस्तावेज़ देख सकते हैं।

TGI उपयोग करते समय व्यावहारिक सुझाव

LLMs के मूल सिद्धांत

HuggingFace TGI में उतरने से पहले, आपको बड़े भाषा मॉडलों से पहले से परिचित होना चाहिए। टोकनाइज़ेशन, अटेंशन मैकेनिज़्म, और ट्रांसफ़ॉर्मर आर्किटेक्चर जैसे प्रमुख सिद्धांतों से खुद को परिचित कराएँ। ये बुनियादें मॉडलों को कस्टमाइज़ करने और टेक्स्ट जनरेशन आउटपुट को परिष्कृत करने के लिए अहम हैं।

मॉडल तैयारी और ऑप्टिमाइज़ेशन — Hugging Face को समझना

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

सुनिश्चित करें कि आप समझते हैं कि HuggingFace कैसे काम करता है और NLP विकास के लिए उसके HuggingFace Hub का उपयोग कैसे किया जाता है। इसके लिए एक अच्छा शुरुआती ट्यूटोरियल है An Introduction to Using Transformers and Hugging Face।

फाइन-ट्यूनिंग भी एक ऐसा सिद्धांत है जिससे आपको वाकिफ होना चाहिए, क्योंकि अधिकांश समय मॉडलों को विशिष्ट लक्ष्यों के लिए ऑप्टिमाइज़ करना पड़ता है। आप यह सीख सकते हैं कि किसी मॉडल को कैसे फाइन-ट्यून करें: An Introductory Guide to Fine-Tuning LLMs

जनरेशन रणनीतियाँ

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

निष्कर्ष

Hugging Face का TGI टूलकिट किसी को भी AI टेक्स्ट जनरेशन का अन्वेषण करने में सक्षम बनाता है। यह उन्नत NLP एप्लिकेशनों के लिए LLMs को डिप्लॉय और होस्ट करने का आसान-से-उपयोग टूलकिट प्रदान करता है, जिनमें मानव-समान टेक्स्ट की आवश्यकता होती है।

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

यदि आप LLM क्षेत्र में लगातार बेहतर होते रहना चाहते हैं, तो मैं आपको कुछ और उन्नत ट्यूटोरियल करने की जोरदार सलाह देता हूँ। आप DataCamp के LLM Concepts कोर्स से शुरू कर सकते हैं, जो कई प्रमुख प्रशिक्षण पद्धतियों और ताज़ा शोध को कवर करता है।

कुछ अन्य अच्छे संसाधन जिन्हें फॉलो किया जा सकता है:

• An Introductory Guide to Fine-Tuning LLMs

• Building a Transformer with PyTorch

• A Step-by-Step Guide to Using and Fine-Tuning Mistral 7B।