लोकल AI के लिए 8GB Mac सर्वाइवल गाइड

laptop_mac macOS Sonoma Intermediate schedule 8 min read

by Alex Rivera • May 14, 2024

Step 1 8GB यूनिफाइड मेमोरी की वास्तविकता

आइए इस मिथक को तुरंत खत्म करते हैं: 8GB यूनिफाइड मेमोरी लोकल AI के लिए वह "मौत की सजा" नहीं है जो अधिकांश लोग दावा करते हैं। हालांकि, यह एक ऐसा कठोर वातावरण जरूर है जो गलत मॉडल चुनाव को बर्दाश्त नहीं करता और सटीक निर्णयों को पुरस्कृत करता है। यह क्यों है — इसे समझने के लिए हमें Apple Silicon की मेमोरी आर्किटेक्चर को संक्षेप में समझना होगा।

यूनिफाइड मेमोरी "सिर्फ RAM" नहीं है

Intel युग की मशीनों में, आपके CPU के पास सिस्टम RAM होती थी और GPU के पास अपनी अलग VRAM — दो अलग-अलग पूल जो संसाधन साझा नहीं कर सकते थे। Apple Silicon की यूनिफाइड मेमोरी आर्किटेक्चर (UMA) इस सीमा को पूरी तरह समाप्त कर देती है। CPU, GPU और Neural Engine सभी एक ही भौतिक मेमोरी पूल से काम करते हैं। यही कारण है कि 8GB वाला Mac, inference कार्यों में 16GB DDR4 वाले PC को पीछे छोड़ सकता है — मॉडल को compute संसाधनों तक पहुंचने के लिए कभी PCIe बस को पार नहीं करना पड़ता।

┌─────────────────────────────────────────────┐
│           Unified Memory (8GB)              │
│                                             │
│   ┌─────────┐  ┌─────────┐  ┌───────────┐  │
│   │   CPU   │  │   GPU   │  │  Neural   │  │
│   │  Cores  │  │  Cores  │  │  Engine   │  │
│   └─────────┘  └─────────┘  └───────────┘  │
│        ↑            ↑             ↑         │
│        └────────────┴─────────────┘         │
│              Shared Memory Bus              │
└─────────────────────────────────────────────┘

यह zero-copy आर्किटेक्चर का मतलब है कि मेमोरी में लोड किए गए मॉडल weights पूर्ण मेमोरी बैंडविड्थ पर सभी compute units को तुरंत उपलब्ध होते हैं — M2 चिप्स पर यह 100 GB/s तक होती है। इसकी तुलना एक mid-range discrete GPU से करें जो 16x PCIe Gen 4 स्लॉट के जरिए लगभग 32 GB/s की दर से डेटा स्थानांतरित करता है।

असली बजट का विश्लेषण

यहीं पर सच्चाई थोड़ी असहज हो जाती है। वह 8GB पूरी तरह AI inference के लिए आपकी नहीं है। macOS स्वयं एक मेमोरी-निवासी ऑपरेटिंग सिस्टम है, और उसकी अपनी जरूरतें हैं:

इसका मतलब है कि आपका वास्तविक inference बजट यथार्थ रूप से 4–5.5GB है, न कि 8GB। हर byte मायने रखता है। एक मॉडल जो कागज पर तकनीकी रूप से फिट बैठता है, फिर भी आपके सिस्टम को swap की समस्या में धकेल सकता है — यदि आपके पास Slack, एक ब्राउज़र और Spotify एक साथ चल रहे हों।

मॉडल मेमोरी फुटप्रिंट को समझना

किसी मॉडल की मेमोरी आवश्यकता केवल डिस्क पर उसके फ़ाइल आकार के बराबर नहीं होती। Inference के दौरान, आपको इन बातों का हिसाब रखना होता है:

• Model weights — सबसे बड़ा घटक, parameter count और quantization के साथ बढ़ता है
• KV cache — key-value attention cache जो context window के आकार के साथ बढ़ता है
• Runtime overhead — framework buffers, computation graphs, activation memory

weights मेमोरी का अनुमान लगाने के लिए एक सरल सूत्र:

Memory (GB) ≈ (Parameters × Bits_per_weight) / (8 × 1024³)

Example: 7B model at 4-bit quantization
= (7,000,000,000 × 4) / (8 × 1,073,741,824)
≈ 3.26 GB

यह बताता है कि 7B मॉडल जिसे Q4 पर क्वांटाइज़ किया गया है, वह लगभग 3.5–4.2GB के आसपास होता है — तकनीकी रूप से 8GB हार्डवेयर पर संभव है, लेकिन आप लंबे कॉन्टेक्स्ट में KV cache के लिए अनिवार्य रूप से शून्य हेडरूम के साथ काम करेंगे।

7B मॉडल के बारे में सच्चाई

8GB Mac पर 7B मॉडल प्रोडक्शन वर्कफ़्लो के लिए आरामदायक रूप से उपयोग करने योग्य नहीं हैं। वे काम करते हैं। लेकिन "काम करना" और "अच्छी तरह काम करना" अलग-अलग चीज़ें हैं।

2048-टोकन कॉन्टेक्स्ट विंडो पर, एक 7B Q4 मॉडल आपका पूरा उपलब्ध इन्फरेंस बजट खा जाएगा। 4096 टोकन तक जाएं और आप निश्चित रूप से स्वैप से टकराएंगे। अनुभव सुगम इन्फरेंस से एक रुक-रुक कर चलने वाले, थर्मली-थ्रॉटल्ड संघर्ष में बदल जाता है जो मेमोरी प्रेशर मैनेजमेंट में एक उत्कृष्ट सबक के रूप में काम करता है।

वे इंजीनियर और पावर यूज़र जो वास्तव में लोकल AI के लिए 8GB Mac के साथ फलते-फूलते हैं, उन्होंने एक अलग मानसिक मॉडल को आत्मसात किया है: छोटा, तेज़ और उद्देश्य-अनुकूल हर बार बड़े और सामान्य को मात देता है। अगले अनुभाग आपको दिखाएंगे कि वह स्टैक कैसे बनाया जाए।

Step 2 स्वैप मेमोरी क्या है और इससे क्यों बचें

जब आपका Mac भौतिक यूनिफाइड मेमोरी से बाहर हो जाता है, तो macOS क्रैश नहीं होता — यह चुपचाप कुछ और अधिक हानिकारक करता है: यह आपके SSD को ओवरफ़्लो मेमोरी के रूप में उपयोग करना शुरू कर देता है। इस तंत्र को स्वैप मेमोरी (या वर्चुअल मेमोरी पेजिंग) कहा जाता है, और हालांकि यह एक सुरक्षा जाल की तरह लगता है, लोकल AI इन्फरेंस के लिए यह प्रभावी रूप से एक परफॉर्मेंस क्लिफ है जिससे आप पूरी गति से टकराते हैं।

स्वैप कैसे काम करता है

macOS एक तकनीक का उपयोग करता है जिसे मेमोरी कम्प्रेशन और स्वैपिंग कहा जाता है। OS पहले RAM में अधिक डेटा फिट करने के लिए निष्क्रिय मेमोरी पेजों को कम्प्रेस करने का प्रयास करता है। जब वह भी पर्याप्त नहीं होता, तो यह पेजिंग शुरू करता है — मेमोरी सामग्री को आपके SSD पर स्वैप फ़ाइल नामक आरक्षित स्थान पर लिखना, फिर जरूरत पड़ने पर उन्हें वापस पढ़ना।

Physical Unified Memory (8GB)
        │
        ▼
┌───────────────────────┐
│  Active Data (in RAM) │  ← Lightning fast (400 GB/s bandwidth)
└───────────────────────┘
        │ overflow
        ▼
┌───────────────────────┐
│  Swap on SSD          │  ← ~3,000–7,000 MB/s (NVMe)
└───────────────────────┘

गति का अंतर ही समस्या है। Apple Silicon की यूनिफाइड मेमोरी लगभग 400 GB/s बैंडविड्थ पर काम करती है। यहां तक कि Apple के सबसे तेज़ NVMe SSD उच्च अंत पर लगभग 7 GB/s तक सीमित हैं — यह स्वैप में जाने वाले किसी भी डेटा के लिए ~57 गुना धीमा थ्रूपुट है।

LLM इन्फरेंस के लिए इसका क्या मतलब है

बड़े भाषा मॉडल सामान्य एप्लिकेशन की तरह नहीं होते। इन्फरेंस के दौरान, प्रत्येक टोकन की गणना करने के लिए मॉडल वेट्स को मेमोरी के माध्यम से लगातार स्ट्रीम किया जाना चाहिए। 4-बिट क्वांटाइज़ेशन में एक 7B पैरामीटर मॉडल लगभग 4–5GB मेमोरी घेरता है। जब आप पहले से ही macOS सिस्टम प्रोसेस, अपना ब्राउज़र और अन्य बैकग्राउंड ऐप्स चला रहे होते हैं, तो 8GB से आगे जाने में बहुत कम लगता है।

जिस क्षण मॉडल वेट्स स्वैप में फैलने लगते हैं, प्रत्येक टोकन जनरेशन के लिए आपके SSD से डेटा पढ़ना आवश्यक हो जाता है। परिणाम एक सहज मंदी नहीं है — यह एक पतन है:

छिपी हुई SSD घिसाव की समस्या

कच्चे प्रदर्शन से परे, swap को गंभीरता से लेने का एक और कारण है: SSD की स्थायित्व। swap पर प्रत्येक लिखावट आपके SSD के NAND flash storage पर एक लिखावट है। बड़े inference jobs चलाना जो लगातार swap को thrash करते हैं, महीनों और वर्षों के उपयोग में ड्राइव घिसाव को सार्थक रूप से तेज़ कर सकते हैं।

Apple MacBook SSDs को बदलना आसान (या सस्ता) नहीं बनाता। अपने SSD की सुरक्षा करना अपने हार्डवेयर निवेश की सुरक्षा करना है।

वास्तविक समय में Swap की निगरानी कैसे करें

किसी भी मॉडल को लोड करने से पहले, अपनी memory pressure जांचने की आदत डालें। Activity Monitor → Memory टैब खोलें, या अपने terminal में यह चलाएं:

# Check current swap usage
vm_stat | grep "Swapouts"

# Real-time memory pressure monitoring
sudo memory_pressure

आप त्वरित snapshot के लिए इस one-liner का भी उपयोग कर सकते हैं:

sysctl vm.swapusage

एक स्वस्थ output इस तरह दिखता है:

vm.swapusage: total = 2048.00M  used = 0.00M  free = 2048.00M

यदि used किसी मॉडल को चलाते समय बढ़ रहा है, तो आपकी configuration गलत है। इस गाइड का बाकी हिस्सा यह सुनिश्चित करने के लिए समर्पित है कि वह संख्या शून्य पर बनी रहे।

स्वर्णिम नियम: यदि आपका मॉडल एक lean macOS वातावरण के साथ 8GB unified memory में पूरी तरह फिट नहीं होता, तो आप एक प्रदर्शन दंड चुकाएंगे जिसे कोई भी हार्डवेयर तरकीब पार नहीं कर सकती। समाधान हमेशा छोटा, स्मार्ट, या हल्का जाना है — कभी भी swap को अंतर को अवशोषित न करने दें।

Step 3 8GB Mac के लिए सर्वश्रेष्ठ छोटे मॉडल (Gemma 2B, Phi-3, Qwen)

8GB unified memory सिस्टम के लिए सही मॉडल चुनना समझौता करने के बारे में नहीं है — यह सटीक चयन के बारे में है। sub-4B parameter मॉडलों का परिदृश्य नाटकीय रूप से परिपक्व हो गया है, और कई दावेदार वास्तव में प्रभावशाली reasoning, coding, और instruction-following क्षमताएं प्रदान करते हैं जो आपको आश्चर्यचकित कर देंगी। कुंजी यह जानना है कि कौन से मॉडल कुशलतापूर्वक इंजीनियर किए गए हैं बनाम कौन से केवल संयोग से छोटे हैं।

यहाँ कठिन नियम है: आपके मॉडल weights + KV cache + macOS overhead को 8GB के भीतर आराम से फिट होना चाहिए। इसका मतलब आमतौर पर quantized मॉडलों को लक्षित करना है जो disk/RAM पर 1.5GB और 4GB के बीच आते हैं, सिस्टम को सांस लेने के लिए headroom छोड़ते हैं।

एक नज़र में दावेदार

Gemma 2 2B — Google का कुशल कार्यघोड़ा

Google का Gemma 2 2B अपनी श्रेणी से काफी ऊपर प्रदर्शन करता है। यह एक sliding window attention mechanism और logit soft-capping का उपयोग करता है, जो इसे पुराने 2B-श्रेणी के मॉडलों की तुलना में उल्लेखनीय रूप से अधिक सुसंगत बनाता है। 8GB Mac के लिए, यह एक सुरक्षित दैनिक उपयोग का विकल्प है।

# Pull and run Gemma 2 2B via Ollama
ollama pull gemma2:2b
ollama run gemma2:2b

विशेषताएं: बेहतरीन सारांशीकरण, स्वाभाविक बातचीत का प्रवाह, अच्छा निर्देश पालन। कमज़ोरियां: कोडिंग गुणवत्ता Phi-3 से पीछे है; 2B वेरिएंट में सीमित context window।

Phi-3 Mini — The Reasoning Specialist

Microsoft का Phi-3 Mini (3.8B) इस स्तर पर तकनीकी रूप से सबसे परिष्कृत विकल्प है। भारी रूप से क्यूरेटेड "textbook quality" डेटासेट पर प्रशिक्षित, यह reasoning और coding बेंचमार्क हासिल करता है जो बहुत बड़े मॉडलों को टक्कर देते हैं। यदि आप code generation, logic problems, या structured output के लिए local AI का उपयोग कर रहे हैं, तो Phi-3 Mini आपकी पसंद है।

# Run Phi-3 Mini with Ollama
ollama pull phi3:mini
ollama run phi3:mini

# Or target the 128K context variant explicitly
ollama pull phi3:3.8b-mini-instruct-4k-q4_K_M

Q4_K_M quantization पर, Phi-3 Mini लगभग 2.4GB का होता है, जो 8GB सिस्टम पर पर्याप्त जगह छोड़ता है। आप इसे 4K–8K context window के साथ आराम से चला सकते हैं बिना swap को ट्रिगर किए।

विशेषताएं: sub-4B के लिए सर्वश्रेष्ठ reasoning, उत्कृष्ट code output, structured JSON generation। कमज़ोरियां: थोड़ा verbose; कभी-कभी सरल उत्तरों को अधिक विस्तार से समझाता है।

Qwen2.5 — The Multilingual Speed Demon

Alibaba की Qwen2.5 series 8GB Mac के लिए दो आकर्षक विकल्प प्रदान करती है: कच्ची गति के लिए 1.5B और बेहतर गुणवत्ता के लिए 3B। Qwen आर्किटेक्चर को विशेष रूप से दक्षता के लिए अनुकूलित किया गया है, और इसका बहुभाषी प्रशिक्षण डेटा इसे गैर-अंग्रेज़ी कार्यभार के लिए विशिष्ट रूप से मज़बूत बनाता है।

# Qwen2.5 1.5B — fastest option
ollama pull qwen2.5:1.5b
ollama run qwen2.5:1.5b

# Qwen2.5 3B — better quality, still comfortable on 8GB
ollama pull qwen2.5:3b
ollama run qwen2.5:3b

1.5B वेरिएंट automation pipelines के लिए विशेष रूप से रोचक है — यह बिना किसी ध्यान देने योग्य विलंबता के local classifier, router, या lightweight data transformation tool के रूप में उपयोग करने के लिए पर्याप्त तेज़ है।

विशेषताएं: तीव्र inference गति, मज़बूत बहुभाषी समर्थन, agentic/tool-use patterns के लिए उत्कृष्ट। कमज़ोरियां: 1.5B जटिल reasoning कार्यों में बारीकियां खो देता है; गंभीर उपयोग के लिए 3B न्यूनतम है।

व्यावहारिक अनुशंसा मैट्रिक्स

केवल एक मॉडल न चुनें — कार्य के अनुसार मॉडल का मिलान करें:

• Coding & debugging → phi3:mini
• General Q&A and chat → gemma2:2b
• Automation, classification, pipelines → qwen2.5:1.5b
• Balanced everyday use → qwen2.5:3b
• Multilingual work → qwen2.5:3b

एक साथ कई मॉडल चलाना भी कोई समस्या नहीं है — Ollama मांग पर मॉडल लोड करता है और निष्क्रिय होने पर उन्हें मेमोरी से हटा देता है। आप बिना कुछ पुनः आरंभ किए इनके बीच स्वतंत्र रूप से स्विच कर सकते हैं, जब तक आप एक साथ दो नहीं चला रहे हों।

नीचे की बात: 8GB कोई सीमा नहीं है अगर आप समझदारी से चुनते हैं। ये मॉडल कोई समझौता नहीं हैं — ये एक अलग वर्ग के टूल हैं, जो ठीक उसी वातावरण के लिए अनुकूलित हैं जिसमें आप इन्हें चला रहे हैं।

Step 4 Quantization समझाया गया: Q4_K_M आपका सबसे अच्छा दोस्त क्यों है

अगर आपने Hugging Face या Ollama की मॉडल लाइब्रेरी में कुछ समय बिताया है, तो आप अनिवार्य रूप से suffixes की एक हैरान करने वाली alphabet soup से मिले होंगे: Q4_K_M, Q8_0, Q5_K_S, F16, IQ3_XS। ये मनमाने naming conventions नहीं हैं — ये एक ही मॉडल के मूलभूत रूप से अलग संस्करणों को दर्शाते हैं, और 8GB मशीन पर गलत एक चुनना एक उपयोगी टूल और एक ऐसे सिस्टम के बीच का अंतर है जो रुक-रुक कर चलता है।

Quantization वास्तव में क्या करता है

एक neural network मॉडल, अपने मूल में, संख्यात्मक weights का एक विशाल संग्रह है — अरबों floating-point numbers जो परिभाषित करते हैं कि मॉडल कैसे सोचता है। अपने मूल रूप (F32 या F16) में, ये weights पूर्ण या आधी precision के साथ संग्रहीत होते हैं, जो भारी मात्रा में memory का उपभोग करते हैं।

Quantization इन weights की संख्यात्मक precision को कम करने की प्रक्रिया है, जो memory footprint और inference speed में नाटकीय कमी के लिए थोड़ी सी accuracy का व्यापार करती है।

इसे इस तरह सोचें: 3.14159265358979 संख्या को संग्रहीत करने के बजाय, quantization इसे 3.14 या यहाँ तक कि सिर्फ 3 के रूप में संग्रहीत कर सकता है। मॉडल कुछ granularity खो देता है, लेकिन यह अपनी तर्क क्षमता का विशाल बहुमत बनाए रखता है।

Naming Convention को समझना

GGUF quantization naming scheme (llama.cpp और Ollama द्वारा उपयोग किया जाता है) एक संरचित pattern का पालन करता है:

Q[bits]_[variant]_[size]
│        │         └── S = Small, M = Medium, L = Large (parameter mixture)
│        └──────────── K = K-quants (newer, smarter algorithm)
└───────────────────── Number of bits per weight

Q4_K_M Sweet Spot क्यों है

Q4_K_M में "K" महत्वपूर्ण है। K-quants एक समझदार, non-uniform quantization strategy का उपयोग करते हैं — वे हर weight पर समान precision reduction लागू नहीं करते। इसके बजाय, वे पहचानते हैं कि कौन से weights मॉडल output के लिए अधिक महत्वपूर्ण हैं और उन्हें उच्च fidelity के साथ संरक्षित करते हैं, जबकि कम महत्वपूर्ण weights को आक्रामक रूप से quantize करते हैं।

परिणाम यह है कि Q4_K_M कुछ उल्लेखनीय हासिल करता है: यह एक 7B पैरामीटर मॉडल को लगभग 4GB तक संपीड़ित करता है, जिससे आपके पास 4GB की अतिरिक्त जगह बचती है: - macOS सिस्टम प्रक्रियाओं के लिए (~2GB आधार रेखा) - आपका सक्रिय एप्लिकेशन संदर्भ - KV कैश (अनुमान के दौरान मॉडल की "कार्यशील स्मृति") - स्वैप को रोकने के लिए ओवरहेड बफर

व्यावहारिक स्तर पर, बेंचमार्क लगातार दिखाते हैं कि Q4_K_M मानक रीज़निंग बेंचमार्क पर पूर्ण-परिशुद्धता मॉडल के प्रदर्शन का 95–98% बनाए रखता है। अधिकांश वास्तविक कार्यों के लिए — कोडिंग सहायता, टेक्स्ट जनरेशन, प्रश्नोत्तर — आप अंतर नहीं देखेंगे।

Ollama के साथ इसे व्यवहार में देखना

जब आप Ollama के साथ कोई मॉडल पुल करते हैं, तो आप स्पष्ट रूप से क्वांटाइज़ेशन स्तरों को लक्षित कर सकते हैं:

# Default pull (Ollama chooses, usually Q4_K_M)
ollama pull llama3.2:3b

# Explicit quantization targeting
ollama pull qwen2.5:7b-instruct-q4_K_M

# Check what you have loaded
ollama list

NAME                              ID              SIZE    MODIFIED
qwen2.5:7b-instruct-q4_K_M      a8b3c2d1e0f9    4.7 GB  2 hours ago
gemma2:2b-instruct-q4_K_M       f1e2d3c4b5a6    1.6 GB  1 day ago

llama.cpp के माध्यम से मैनुअल GGUF प्रबंधन के लिए, क्वांटाइज़ेशन निर्दिष्ट करना समान रूप से सीधा है:

./llama-cli \
  -m ./models/mistral-7b-instruct-q4_K_M.gguf \
  -n 512 \
  --ctx-size 4096 \
  -ngl 99          # Offload all layers to GPU (Metal)

कब नीचे जाएं (और कब नहीं)

ऐसे परिदृश्य हैं जहाँ Q3_K_M या IQ3_XS पर जाना समझ में आता है — विशेष रूप से जब आप बड़े, अधिक सक्षम मॉडल (जैसे 13B पैरामीटर मॉडल) चला रहे हों और कुछ गुणवत्ता में गिरावट को स्वीकार करते हुए उसे मेमोरी में फिट कर रहे हों। एक स्मार्ट मॉडल का आक्रामक क्वांटाइज़ेशन फिर भी हल्के क्वांटाइज़्ड कमज़ोर मॉडल से बेहतर प्रदर्शन कर सकता है।

हालाँकि, Q4 से नीचे जाने पर, आप ये देखना शुरू करेंगे: - हेलुसिनेशन दरों में वृद्धि - निर्देश-पालन व्यवहार में गिरावट - असंगत रीज़निंग श्रृंखलाएं - संरचित आउटपुट कार्यों (JSON, कोड) पर उल्लेखनीय रूप से खराब प्रदर्शन

8GB मशीनों के लिए स्वर्णिम नियम: हर बार पहले Q4_K_M का चयन करें। केवल तभी नीचे जाएं जब मॉडल फिट न हो, और केवल तभी ऊपर जाएं (Q6_K, Q8_0) जब आप पर्याप्त मेमोरी हेडरूम के साथ 4B से कम पैरामीटर वाला मॉडल चला रहे हों।

Step 5 macOS बैकग्राउंड कार्यों को अनुकूलित करना

यहाँ तक कि सबसे आक्रामक रूप से क्वांटाइज़्ड मॉडल भी रुकेगा और स्वैप करेगा यदि macOS चुपचाप उन प्रक्रियाओं के लिए 2–3GB यूनिफाइड मेमोरी समर्पित कर रहा है जिन्हें आपने कभी सचेत रूप से लॉन्च नहीं किया। Ollama या LM Studio शुरू करने से पहले, अपने Mac को उस समर्पित अनुमान मशीन की तरह मानें जिसे उसे अस्थायी रूप से बनने की आवश्यकता है।

समझें कि आपकी RAM क्या खा रही है

macOS एक सुंदर, विचारशील ऑपरेटिंग सिस्टम है जो मानता है कि आप हमेशा iCloud सिंकिंग, Spotlight इंडेक्सिंग, और समानांतर में चलने वाले दर्जनों मेनू-बार डेमन चाहते हैं। स्थानीय AI वर्कलोड के लिए, हर मेगाबाइट मायने रखता है। अपनी मेमोरी दबाव की बेरहमी से ईमानदार तस्वीर पाने के लिए पहले यह कमांड चलाएं:

# Real-time memory breakdown
sudo memory_pressure

शीर्ष RAM उपभोक्ताओं को रेजिडेंट साइज़ के अनुसार क्रमबद्ध करके देखें

ps aux --sort=-%mem | head -20

अभी swap उपयोग जांचें

sysctl vm.swapusage

अगर `vm.swapusage` में `0.00B used` के अलावा कुछ और दिखता है, तो inference शुरू होने से पहले ही आप मुसीबत में हैं।

---

### Pre-Inference अनुष्ठान: एक चेकलिस्ट

किसी भी मॉडल को लोड करने से पहले इसे अनिवार्य pre-flight चेकलिस्ट के रूप में मानें:

| कार्य | कमांड / स्थान | मुक्त की गई मेमोरी (अनुमानित) |
|---|---|---|
| अप्रयुक्त ऐप्स बंद करें | Cmd+Q (केवल close नहीं) | 200MB–1.5GB |
| Spotlight इंडेक्सिंग बंद करें | `sudo mdutil -a -i off` | 150–400MB |
| iCloud Drive sync रोकें | System Settings → Apple ID → iCloud | 100–300MB |
| ब्राउज़र टैब बंद करें | अधिकतम 0–2 टैब खुले रखें | 500MB–2GB |
| Time Machine स्नैपशॉट बंद करें | `sudo tmutil disablelocal` | Background I/O |
| मेल और कैलेंडर ऐप्स बंद करें | मैन्युअल | 100–250MB |

---

### सबसे ज़्यादा समस्या पैदा करने वाले प्रोग्रामों को प्रोग्रामेटिक रूप से बंद करना

हर सत्र में यह मैन्युअल रूप से न करें। किसी भी गंभीर inference कार्य से पहले चलाने के लिए एक shell script बनाएं:

```bash
#!/bin/zsh
# ai-mode.sh — Free up memory before local LLM sessions

echo "🧠 Entering AI Mode..."

# Pause Spotlight indexing
sudo mdutil -a -i off

# Purge inactive memory (forces disk cache to flush)
sudo purge

# Stop unnecessary launch agents
launchctl unload -w ~/Library/LaunchAgents/com.google.keystone.agent.plist 2>/dev/null
launchctl unload -w /Library/LaunchAgents/com.adobe.AdobeCreativeCloud.plist 2>/dev/null

# Disable WindowServer-heavy features (optional, aggressive)
# defaults write com.apple.universalaccess reduceMotion -bool true

echo "✅ Done. Current swap usage:"
sysctl vm.swapusage

echo "✅ Available memory:"
memory_pressure | grep "System Memory Pressure"

इसे executable बनाएं: chmod +x ai-mode.sh और हर inference सत्र से पहले sudo ./ai-mode.sh के साथ चलाएं।

थर्मल और परफॉर्मेंस स्थितियों को नियंत्रित करना

Apple Silicon पर, CPU और GPU एक ही unified memory pool साझा करते हैं, लेकिन performance cores काफी अधिक बिजली की खपत करते हैं और गर्मी उत्पन्न करते हैं जो inference के बीच में thermal throttling को ट्रिगर कर सकती है — जो अनियमित token generation गति के रूप में दिखाई देती है।

# Check current CPU frequency and thermal state
sudo powermetrics --samplers cpu_power -i 1000 -n 3

# Force high-performance mode (plugged in only)
sudo pmset -c gpuswitch 2
sudo pmset -c highstandbythreshold 95

प्रो टिप: inference बिजली से जुड़े रहते हुए चलाएं। बैटरी पर, macOS आक्रामक efficiency-core शेड्यूलिंग लागू करता है जो आपकी tokens-per-second थ्रूपुट को आधा कर सकता है।

Activity Monitor को Kill Switch के रूप में उपयोग करना

GUI-आधारित वर्कफ़्लो के लिए, Activity Monitor को इस प्रकार कॉन्फ़िगर करें कि वह आपको महत्वपूर्ण जानकारी दिखाए:

1. Activity Monitor → Memory टैब खोलें
2. Memory के अनुसार घटते क्रम में क्रमबद्ध करें
3. नीचे Memory Pressure ग्राफ देखें — इसे हरा रखें
4. अगर यह पीला या लाल हो जाए, तो inference तुरंत रोकें और swap बढ़ने से पहले प्रक्रियाओं को बंद करें

सुनहरा नियम: यदि आप कोई मॉडल लोड करने से पहले Memory Pressure हरे रंग के अलावा कुछ भी है, तो आप स्वैप करेंगे। 8GB मशीन पर, inference के दौरान स्वैपिंग न केवल चीज़ों को धीमा करती है — यह गड़बड़, अधूरे, या पूरी तरह से विफल आउटपुट भी उत्पन्न कर सकती है क्योंकि मॉडल का KV cache डिस्क रीड्स के पार थ्रैश होता है।

एक सेशन के बाद मेमोरी पुनः प्राप्त करना

macOS हमेशा LLM प्रक्रिया बंद करने के बाद मेमोरी को साफ़ तरीके से रिलीज़ नहीं करता। इसे ज़बरदस्ती करें:

# After closing Ollama or LM Studio
sudo purge

# Verify swap cleared
sysctl vm.swapusage
# Target: vm.swapusage: total = 0.00B  used = 0.00B  free = 0.00B

ollama सर्विस को रीस्टार्ट करें न कि केवल ऐप विंडो बंद करें — अन्यथा मॉडल वेट्स अक्सर मेमोरी में बने रहते हैं:

ollama stop          # Stop any running model
pkill -f ollama      # Kill the background daemon
# Relaunch fresh when ready
ollama serve &

अपने 8GB Mac की मेमोरी को एक सर्जिकल थिएटर की तरह मानें — बाँझ, नियंत्रित, और जो भी वहाँ नहीं होना चाहिए उससे निर्दयतापूर्वक साफ़।

Continue Reading

Performance

Mistral 7B vs Llama 3 on Apple Silicon

Tools

Best GUI clients for Local LLMs

Advanced

Quantization 101: Speed up your Inference