# LFM2-24B-A2B

> LFM2-24B-A2B द्रव AI (Liquid AI) के हाइब्रिड के माध्यम से कुशल भाषा मॉडलिंग में एक महत्वपूर्ण प्रगति का प्रतिनिधित्व करता है। **स्टेट स्पेस मॉडल + अटेंशन** आर्किटेक्चर। कुल 24B पैरामीटर होने पर प्रत्येक टोकन पर केवल 2B सक्रिय पैरामीटर होने के कारण यह प्रभावशाली प्रदर्शन देता है और FP16 इंफरेंस के लिए केवल \~6GB VRAM की आवश्यकता होती है। यह मॉडल RTX 4090 पर \~350 टोक/सेकंड प्राप्त करता है, जिससे यह उपलब्ध तेज़ बड़े भाषा मॉडलों में से एक बनता है।

## संक्षेप में

* **मॉडल आकार**: 24B कुल / 2B सक्रिय पैरामीटर (हाइब्रिड SSM+Attention)
* **लाइसेंस**: Liquid AI ओपन लाइसेंस (गैर-व्यावसायिक नि:शुल्क, व्यावसायिक लाइसेंस उपलब्ध)
* **संदर्भ**: 32K टोकन
* **प्रदर्शन**: 7B-13B डेंस मॉडलों के साथ प्रतिस्पर्धी
* **VRAM**: \~6GB FP16, \~3GB INT8
* **गति**: RTX 4090 पर \~350 टोक/सेक, RTX 3090 पर \~200 टोक/सेक

## क्यों LFM2-24B-A2B?

**क्रांतिकारी आर्किटेक्चर**: LFM2-24B-A2B स्टेट स्पेस मॉडलों (SSMs) को चयनात्मक अटेंशन मैकेनिज्म के साथ जोड़ता है। SSM अनुक्रमिक प्रसंस्करण को कुशलता से संभालते हैं जबकि अटेंशन लेयर्स जटिल तर्क पर ध्यान केंद्रित करती हैं। यह हाइब्रिड दृष्टिकोण छोटे मॉडल की दक्षता के साथ बड़े मॉडल की गुणवत्ता प्राप्त करता है।

**उत्कृष्ट गति**: 2B सक्रिय पैरामीटर डिज़ाइन तीव्र-गति वाला इंफरेंस सक्षम करता है। पारंपरिक मॉडलों के विपरीत जहाँ सभी पैरामीटर सक्रिय होते हैं, LFM2 केवल आवश्यक घटकों को ही चयनित रूप से सक्रिय करता है, जिसके परिणामस्वरूप उपभोक्ता हार्डवेयर पर 350+ टोकन/सेकंड मिलता है।

**मेमोरी कुशल**: केवल 6GB FP16 VRAM होने पर, LFM2-24B-A2B मध्यम श्रेणी के GPU पर आराम से चलता है। यह इसे एज पर परिनियोजन, विकास परिवेशों और लागत-सचेत उत्पादन सेटअप के लिए आदर्श बनाता है।

**Liquid AI नवाचार**: Liquid AI (जिसकी स्थापना MIT शोधकर्ताओं ने की थी) द्वारा विकसित, LFM2 न्यूरल आर्किटेक्चर में अत्याधुनिक अनुसंधान का प्रतिनिधित्व करता है। हाइब्रिड SSM+Attention डिज़ाइन कुशल भाषा मॉडलिंग का भविष्य हो सकता है।

**लाइसेंसिंग नोट**: Liquid AI ओपन लाइसेंस गैर-व्यावसायिक उपयोग की अनुमति देता है। व्यावसायिक परिनियोजन के लिए Liquid AI से अलग लाइसेंस की आवश्यकता होती है। यह **नहीं** MIT — उत्पादन उपयोग से पहले लाइसेंस की शर्तों की पुष्टि करें।

## GPU सिफारिशें

| GPU             | VRAM | प्रदर्शन          | दैनिक लागत\* |
| --------------- | ---- | ----------------- | ------------ |
| RTX 3060 12GB   | 12GB | \~180 टोक/सेक     | \~$0.80      |
| RTX 3070        | 8GB  | \~220 टोक/सेक     | \~$0.90      |
| **RTX 4060 Ti** | 16GB | \~300 टोक/सेक     | \~$1.20      |
| **RTX 4090**    | 24GB | **\~350 टोक/सेक** | \~$2.10      |
| RTX 3090        | 24GB | \~200 टोक/सेक     | \~$1.10      |
| A100 40GB       | 40GB | \~400 टोक/सेक     | \~$3.50      |

**सर्वोत्तम मूल्य**: RTX 4060 Ti 16GB प्रति डॉलर उत्कृष्ट प्रदर्शन प्रदान करता है। **अधिकतम गति**: RTX 4090 LFM2 की पूरी क्षमता जारी करता है।

\*Clore.ai मार्केटप्लेस कीमतों का अनुमानित मान

## vLLM के साथ परिनियोजित करें

### vLLM इंस्टॉल करें

```bash
pip install vllm>=0.6.0
# या नवीनतम
pip install git+https://github.com/vllm-project/vllm.git
```

### सिंगल GPU सेटअप

```bash
vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --tensor-parallel-size 1 \
  --dtype float16 \
  --max-model-len 32768 \
  --served-model-name lfm2-24b \
  --trust-remote-code \
  --disable-log-stats
```

### सर्वर से प्रश्न पूछें

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1", 
    api_key="EMPTY"
)

response = client.chat.completions.create(
    model="lfm2-24b",
    messages=[
        {"role": "system", "content": "आप तकनीकी व्याख्याओं में विशेषज्ञ एक सहायक AI हैं।"},
        {"role": "user", "content": "State Space Models और पारंपरिक Transformers के बीच अंतर समझाइए"}
    ],
    max_tokens=1024,
    temperature=0.7
)

print(response.choices[0].message.content)
```

## Ollama के साथ परिनियोजित करें

Ollama सबसे सरल परिनियोजन मार्ग प्रदान करता है:

```bash
# Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# LFM2 मॉडल पुल करें
ollama pull liquid-ai/lfm2:24b

# इंटरैक्टिव रूप से चलाएं
ollama run liquid-ai/lfm2:24b

# API मोड
ollama serve
```

### Ollama API उपयोग

```python
import requests

# सरल पूर्णता
response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'prompt': 'मेमोइज़ेशन का उपयोग करके फ़िबोनैचि संख्याएँ निकालने के लिए एक Python फ़ंक्शन लिखें',
        'stream': False
    }
)

print(response.json()['response'])

# चैट प्रारूप
chat_response = requests.post('http://localhost:11434/api/chat',
    json={
        'model': 'liquid-ai/lfm2:24b',
        'messages': [
            {'role': 'user', 'content': 'क्वांटम एंटैन्गलमेंट को सरल शब्दों में समझाइए'}
        ],
        'stream': False
    }
)

print(chat_response.json()['message']['content'])
```

## डॉकर टेम्पलेट

```dockerfile
FROM nvidia/cuda:12.1-devel-ubuntu22.04

# Python 3.10 इंस्टॉल करें
RUN apt-get update && apt-get install -y \
    python3.10 python3-pip curl && \
    rm -rf /var/lib/apt/lists/*

# vLLM इंस्टॉल करें
RUN pip install vllm>=0.6.0 transformers

# परिवेश सेट करें
ENV PYTHONUNBUFFERED=1

# मॉडल पूर्व-डाउनलोड (वैकल्पिक)
# RUN python3 -c "from transformers import AutoModel; AutoModel.from_pretrained('liquid-ai/LFM2-24B-A2B', trust_remote_code=True)"

EXPOSE 8000

CMD ["vllm", "serve", "liquid-ai/LFM2-24B-A2B", \
     "--host", "0.0.0.0", \
     "--port", "8000", \
     "--dtype", "float16", \
     "--max-model-len", "16384", \
     "--trust-remote-code"]
```

बिल्ड और चलाएँ:

```bash
docker build -t lfm2-24b .
docker run --gpus all -p 8000:8000 lfm2-24b
```

## गति बेंचमार्क

LFM2 की असाधारण इंफरेंस गति का परीक्षण करें:

```python
import time
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

def speed_test():
    prompts = [
        "मशीन लर्निंग को एक पैराग्राफ में समझाइए",
        "एक त्वरित Python सॉर्टिंग एल्गोरिथ्म लिखें",
        "नवीकरणीय ऊर्जा के लाभों का विवरण दें",
        "फ्रांस की राजधानी क्या है और यह क्यों महत्वपूर्ण है?",
        "एक सरल HTML पेज संरचना बनाइए"
    ]
    
    total_tokens = 0
    total_time = 0
    
    for prompt in prompts:
        start_time = time.time()
        
        response = client.chat.completions.create(
            model="lfm2-24b",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=200,
            temperature=0.1
        )
        
        end_time = time.time()
        
        tokens = len(response.choices[0].message.content.split())
        duration = end_time - start_time
        
        total_tokens += tokens
        total_time += duration
        
        print(f"Prompt: {prompt[:30]}...")
        print(f"Tokens: {tokens}, Time: {duration:.2f}s, Speed: {tokens/duration:.1f} tok/s\n")
    
    avg_speed = total_tokens / total_time
    print(f"Average speed: {avg_speed:.1f} tokens/second")
    return avg_speed

# गति परीक्षण चलाएँ
speed_test()
```

## कम VRAM के लिए क्वांटाइज़ेशन

सीमित VRAM वाले GPU के लिए, क्वांटाइज़्ड संस्करणों का उपयोग करें:

### GPTQ क्वांटाइज़ेशन

```bash
# auto-gptq इंस्टॉल करें
pip install auto-gptq

# क्वांटाइज़्ड मॉडल का उपयोग करें (लगभग ~3GB VRAM तक घटाता है)
vllm serve liquid-ai/LFM2-24B-A2B-GPTQ \
  --model liquid-ai/LFM2-24B-A2B-GPTQ \
  --quantization gptq \
  --dtype float16 \
  --max-model-len 16384
```

### AWQ क्वांटाइज़ेशन

```bash
# autoawq इंस्टॉल करें
pip install autoawq

# AWQ क्वांटाइज़्ड मॉडल का उपयोग करें
vllm serve liquid-ai/LFM2-24B-A2B-AWQ \
  --model liquid-ai/LFM2-24B-A2B-AWQ \
  --quantization awq \
  --dtype float16
```

## उन्नत विन्यास

### मेमोरी-अनुकूलित सेटअप

8GB GPU के लिए:

```bash
vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --dtype float16 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.85 \
  --swap-space 4 \
  --trust-remote-code
```

### उच्च-थ्रूपुट सेटअप

उत्पादन वर्कलोड के लिए:

```bash
vllm serve liquid-ai/LFM2-24B-A2B \
  --model liquid-ai/LFM2-24B-A2B \
  --tensor-parallel-size 1 \
  --max-num-seqs 32 \
  --max-num-batched-tokens 8192 \
  --dtype float16 \
  --trust-remote-code
```

## SSM आर्किटेक्चर लाभ

LFM2 का हाइब्रिड SSM+Attention अनूठे लाभ प्रदान करता है:

**रैखिक स्केलिंग**: SSM अनुक्रम लंबाई के साथ रैखिक रूप से स्केल करते हैं, जबकि पारंपरिक ट्रांसफॉर्मर द्विघात रूप से स्केल करते हैं। यह लंबे-संदर्भ प्रसंस्करण को कुशल बनाता है।

**चयनात्मक अटेंशन**: केवल महत्वपूर्ण टोकन ही पूर्ण अटेंशन मैकेनिज्म को सक्रिय करते हैं, जिससे गणनात्मक ओवरहेड कम होता है।

**मेमोरी दक्षता**: 2B सक्रिय पैरामीटर डिज़ाइन का अर्थ है कि 24B में से अधिकांश पैरामीटर इंफरेंस के दौरान निष्क्रिय रहते हैं, जिससे मेमोरी बैंडविड्थ आवश्यकताएँ काफी घट जाती हैं।

**तेज़ अनुक्रमिक प्रसंस्करण**: SSM पाठ जनरेशन जैसे अनुक्रमिक कार्यों में उत्कृष्ट हैं, और शुद्ध अटेंशन मैकेनिज्म की तुलना में अधिक थ्रूपुट प्राप्त करते हैं।

## Clore.ai उपयोगकर्ताओं के लिए सुझाव

* **सिंगल GPU केंद्रित**: LFM2-24B-A2B सिंगल-GPU परिनियोजन के लिए अनुकूलित है। मल्टी-GPU सेटअप महत्वपूर्ण लाभ प्रदान नहीं करते।
* **संदर्भ लंबाई**: अधिकतम गति के लिए छोटे संदर्भ (8K-16K) का उपयोग करें। लंबे संदर्भ SSM की दक्षता लाभ को घटाते हैं।
* **टेम्परेचर सेटिंग्स**: कम तापमान (0.1-0.3) अनिश्चितता कम करके इंफरेंस स्पीड को अधिकतम करते हैं।
* **बैच आकार**: कई समवर्ती अनुरोधों के लिए बहु-GPU के बजाय बैच साइज बढ़ाएँ।
* **लाइसेंस अनुपालन**: उत्पादन परिनियोजन से पहले व्यावसायिक लाइसेंसिंग आवश्यकताओं के लिए Liquid AI से सत्यापित करें।

## समस्या निवारण

| समस्या                             | समाधान                                                                                      |
| ---------------------------------- | ------------------------------------------------------------------------------------------- |
| `ImportError: liquid_transformers` | इंस्टॉल करें: `pip install git+https://github.com/LiquidAI-project/liquid-transformers.git` |
| धीमी शुरुआत                        | पूर्व-डाउनलोड: `huggingface-cli download liquid-ai/LFM2-24B-A2B`                            |
| `OutOfMemoryError`                 | क्वांटाइज़्ड संस्करण का उपयोग करें या घटाएँ `max-model-len`                                 |
| कम गुणवत्ता वाले उत्तर             | लाइसेंस प्रतिबंधों की जाँच करें — कुछ मॉडल संस्करणों की सीमित क्षमताएँ हो सकती हैं          |
| SSM लेयर त्रुटियाँ                 | transformers अपडेट करें: `pip install transformers>=4.45.0`                                 |

## प्रदर्शन तुलना

| मॉडल             | सक्रिय पैरामीटर | VRAM (FP16) | गति (RTX 4090)    |
| ---------------- | --------------- | ----------- | ----------------- |
| Llama 3.2 3B     | 3B              | \~6GB       | \~280 टोक/सेक     |
| Qwen2.5 7B       | 7B              | \~14GB      | \~180 टोक/सेक     |
| **LFM2-24B-A2B** | **2B**          | **\~6GB**   | **\~350 टोक/सेक** |
| Mistral 7B       | 7B              | \~14GB      | \~200 टोक/सेक     |
| Phi-3.5 3.8B     | 3.8B            | \~8GB       | \~250 टोक/सेक     |

LFM2-24B-A2B अपनी श्रेणी में सर्वश्रेष्ठ स्पीड-पर-VRAM अनुपात प्राप्त करता है।

## संसाधन

* [Hugging Face पर LFM2-24B-A2B](https://huggingface.co/liquid-ai/LFM2-24B-A2B)
* [Liquid AI कंपनी](https://liquid.ai/)
* [SSM आर्किटेक्चर पेपर](https://arxiv.org/abs/2312.00752)
* [Liquid AI लाइसेंसिंग](https://liquid.ai/licensing)
* [vLLM SSM समर्थन](https://docs.vllm.ai/en/latest/models/supported_models.html#liquid-ai)