Inference Unlimited

विभिन्न एलएलएम मॉडल्स की प्रदर्शन तुलना घरेलू हार्डवेयर पर

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

परिचय

एलएलएम मॉडल्स जैसे बीआरटी, टी5 या मिस्ट्रल महत्वपूर्ण गणनात्मक संसाधनों की आवश्यकता करते हैं। तुलना के लिए, कुछ मॉडल्स में यहां तक कि हजारों अरब पैरामीटर्स भी हो सकते हैं, जो राम मेमोरी और गणनात्मक शक्ति के उच्च उपयोग में परिणत होते हैं। इस लेख में, हम उन मॉडल्स पर ध्यान केंद्रित करेंगे जिन्हें घरेलू हार्डवेयर पर चलाया जा सकता है, जैसे:

परीक्षण हार्डवेयर

परीक्षणों के लिए, हमने निम्न हार्डवेयर का उपयोग किया:

परीक्षण विधि

मॉडल्स की प्रदर्शन की तुलना करने के लिए, हमने निम्न परीक्षण किए:

  1. मॉडल लोडिंग: मापा गया मॉडल को मेमोरी में लोड करने के लिए आवश्यक समय।
  2. टेक्स्ट जनरेशन: मापा गया 100 टोकन्स जनरेट करने के लिए आवश्यक समय।
  3. मेमोरी उपयोग: मापा गया मॉडल चलाने के दौरान राम मेमोरी का उपयोग।

परीक्षणों के लिए उपयोग की गई कोड:

from transformers import AutoModelForCausalLM, AutoTokenizer
import time
import torch

def load_model(model_name):
    start_time = time.time()
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
    end_time = time.time()
    load_time = end_time - start_time
    return model, tokenizer, load_time

def generate_text(model, tokenizer, prompt, max_length=100):
    start_time = time.time()
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
    outputs = model.generate(**inputs, max_length=max_length)
    end_time = time.time()
    generation_time = end_time - start_time
    return tokenizer.decode(outputs[0], skip_special_tokens=True), generation_time

model_name = "mistralai/Mistral-7B-v0.1"
model, tokenizer, load_time = load_model(model_name)
prompt = "जिंदगी का उद्देश्य क्या है?"
generated_text, generation_time = generate_text(model, tokenizer, prompt)
print(f"मॉडल लोडिंग का समय: {load_time:.2f} सेकंड")
print(f"टेक्स्ट जनरेशन का समय: {generation_time:.2f} सेकंड")
print(f"जनरेट की गई टेक्स्ट: {generated_text}")

परीक्षण परिणाम

1. मॉडल लोडिंग का समय

| मॉडल | लोडिंग का समय (स) | |---------------------|-------------------| | मिस्ट्रल 7बी | 120 | | लामा 2 7बी | 110 | | फाल्कन 7बी | 105 | | स्टेबलएलएम 7बी | 95 |

2. टेक्स्ट जनरेशन का समय

| मॉडल | जनरेशन का समय (स) | |---------------------|----------------------| | मिस्ट्रल 7बी | 5.2 | | लामा 2 7बी | 4.8 | | फाल्कन 7बी | 4.5 | | स्टेबलएलएम 7बी | 4.2 |

3. मेमोरी उपयोग

| मॉडल | मेमोरी उपयोग (जीबी) | |---------------------|----------------------| | मिस्ट्रल 7बी | 14.5 | | लामा 2 7बी | 14.0 | | फाल्कन 7बी | 13.8 | | स्टेबलएलएम 7बी | 13.5 |

परिणाम विश्लेषण

परीक्षणों के आधार पर, हम देख सकते हैं कि:

निष्कर्ष

उपयुक्त एलएलएम मॉडल का चयन विशिष्ट आवश्यकताओं और उपलब्ध हार्डवेयर पर निर्भर करता है। यदि प्राथमिकता लोडिंग और टेक्स्ट जनरेशन की गति है, तो स्टेबलएलएम 7बी सबसे अच्छा विकल्प है। यदि जनरेट की गई टेक्स्ट की गुणवत्ता महत्वपूर्ण है, तो मिस्ट्रल 7बी या लामा 2 7बी पर विचार करना चाहिए।

सारांश

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

Język: HI | Wyświetlenia: 7

← Powrót do listy artykułów