Apple के ऑन-डिवाइस नॉलेज ग्राफ़ से सीखने योग्य बातें
Apple का ऑन-डिवाइस नॉलेज ग्राफ़ दिखाता है कि निजी, लोकल-फ़र्स्ट ML कैसे बनाएँ। पाँच आम गलतियाँ और उनके कारगर समाधान।

अपने Mac से कहिए “मेरे भाई को मैसेज करो” और वह बस कर देता है। कोई स्पिनर नहीं, कोई दिखने वाला लुकअप नहीं, कोई नेटवर्क राउंड-ट्रिप नहीं — उसे पहले से पता है कि आपके कॉन्टैक्ट्स के सैकड़ों लोगों में से आपका भाई कौन है। यह इसलिए मुमकिन है क्योंकि macOS Ventura के बाद से हर Mac चुपचाप एक ऑन-डिवाइस नॉलेज ग्राफ़ चला रहा है: डेमन्स की एक जोड़ी जो आपके Contacts, Photos के फ़ेस क्लस्टर, Calendar के अटेंडी, Mail और Messages के मेटाडेटा, लोकेशन पैटर्न और Screen Time डेटा को पढ़ती है, फिर इन सबको एक ऐसे क्वेरी-योग्य स्टोर में जोड़ देती है जिसमें दर्ज होता है कि आप कौन हैं, आप किसे जानते हैं, और वे लोग आपसे और एक-दूसरे से कैसे जुड़े हैं।
सुरक्षा शोधकर्ताओं ने हाल ही में दिखाया कि यह कितनी गहराई तक जाता है। दो डेमन — knowledgeconstructiond और intelligenceplatformd — ~/Library/IntelligencePlatform के अंतर्गत 51 SQLite डेटाबेस की एक डायरेक्टरी रखते हैं। इसका केंद्रबिंदु, graph.db, एक ट्रिपल स्टोर है जो 181 एंटिटी क्लास और 278 प्रेडिकेट के शब्दकोश में लिखा गया है, जिसमें रिश्तेदारी के वे अनुमानित संबंध भी शामिल हैं जिन्हें किसी ने कभी कॉन्टैक्ट कार्ड में नहीं डाला। इस खोज के आसपास सबसे ज़्यादा बहस सहमति (consent) को लेकर है, और यह एक जायज़ बहस है। लेकिन मैंने सालों तक ML फ़ीचर्स शिप करने का काम किया है, और जब मैंने यह विश्लेषण पढ़ा तो मेरी पहली प्रतिक्रिया अलग थी: यह बड़े पैमाने पर शिप हुए सबसे शिक्षाप्रद लोकल-फ़र्स्ट ML इंजीनियरिंग उदाहरणों में से एक है। इसलिए नैतिकता पर दोबारा बहस करने के बजाय, मैं उन पाँच गलतियों पर बात करना चाहता हूँ जो ऐसे सिस्टम बनाते समय लोग करते हैं, और यह भी कि Apple के इंजीनियरों ने क्या सही किया और क्या गलत, ताकि आपको यह सब कठिन तरीके से न सीखना पड़े।
गलती 1: छोटे क्लासिफ़ायर्स की जगह एक बड़ा मॉडल चुनना
जब टीमों को “OS आपके परिवार को समझता है” जैसी बात सुनाई देती है, तो ज़्यादातर पहला अनुमान यही होता है कि बीच में कोई बड़ा लैंग्वेज मॉडल काम कर रहा है। ऐसा नहीं है, और यही सबक है। रिश्तेदारी का वह अनुमान जो सुर्खियों में आया — कि यह कॉन्टैक्ट आपकी माँ है और वह आपका बॉस — संरचित सिग्नल्स पर काम करने वाले संकीर्ण, विशेषज्ञ क्लासिफ़ायर्स से होता है: Family Sharing की सदस्यता और उम्र, Contacts के संबंधित-नाम वाले फ़ील्ड्स, Calendar में साथ-साथ अटेंडी होने के पैटर्न, संवाद की आवृत्ति और दिशा, और Photos में चेहरों की सह-उपस्थिति। हर क्लासिफ़ायर एक छोटा सवाल अच्छी तरह हल करता है, और ग्राफ़ इन जवाबों को आपस में जोड़ देता है।
यह एक बेहद व्यावहारिक कारण से मायने रखता है: बजट। एक डेमन जो लगातार चलता है, बैटरी पर चलता है और OS के बाकी कामों के साथ-साथ, वह हर इवेंट पर ट्रांसफ़ॉर्मर का फ़ॉरवर्ड पास नहीं झेल सकता। छोटे क्लासिफ़ायर्स Neural Engine पर माइक्रोसेकंड में चल जाते हैं, इतने डिटरमिनिस्टिक होते हैं कि उनकी यूनिट टेस्टिंग हो सके, और जब कोई एक गलती करे तो बाकी को छुए बिना सिर्फ़ उसी को रीट्रेन किया जा सकता है। मैंने टीमों को महीनों तक एक सामान्य मॉडल से वह काम करवाने की कोशिश में खपते देखा है, जिसे तीस अच्छी तरह चुनी गई फ़ीचर्स पर चल रहा एक ग्रेडिएंट-बूस्टेड ट्री कहीं बेहतर कर देता है। यही पैटर्न विज़न में भी दिखा था: विशेषज्ञ CNN अक्सर इमेज क्लासिफ़िकेशन में फ़्रंटियर LLM को लागत के एक हिस्से में हरा देते हैं। यह पैटर्न हर जगह लागू होता है। पर्सनलाइज़ेशन फ़ीचर्स को शायद ही कभी सामान्य मॉडल की ज़रूरत होती है — उन्हें अच्छे स्कीमा और ढेर सारे उबाऊ, बेहतरीन क्लासिफ़ायर्स की ज़रूरत होती है।
एक और कम आँका गया फ़ायदा है ग्रेसफ़ुल डिग्रेडेशन। अगर यूज़र Photos इस्तेमाल नहीं करता, तो फ़ेस-रिकग्निशन पाइपलाइन कभी चलती ही नहीं, फिर भी रिश्तेदारी क्लासिफ़ायर के पास Family Sharing और Contacts का डेटा रहता है। मोनोलिथिक मॉडल तब बुरी तरह फेल होते हैं जब उनके इनपुट का डिस्ट्रीब्यूशन बदलता है; सिग्नल-विशेष क्लासिफ़ायर्स के एन्सेंबल में बस एक वोट कम होता है। अगला ऑन-डिवाइस फ़ीचर डिज़ाइन करते समय पहले स्वतंत्र सिग्नल गिनिए, फिर पूछिए कि हर सिग्नल के लिए सबसे छोटा मॉडल कैसा होगा। LLM को प्राकृतिक-भाषा इंटरैक्शन के आख़िरी चरण के लिए बचाकर रखिए, जहाँ उसकी असल जगह है।

गलती 2: बिना प्रोवेनेंस या रिट्रैक्शन के तथ्य सहेजना
विश्लेषण की एक बात ज़्यादातर कवरेज में छूट गई, और मुझे यही सबसे खूबसूरत लगती है। इस ग्राफ़ में एक एज — “यह व्यक्ति इस संगठन में काम करता है” — एक पंक्ति नहीं है। यह relationshipId साझा करने वाली दो पंक्तियाँ हैं: एक पंक्ति रिश्ते का प्रकार बताती है, दूसरी संबंधित एंटिटी की ओर इशारा करती है। ऐसे 46 रिलेशनशिप-टाइप क्लास हैं जो सिर्फ़ इसी अप्रत्यक्षता को ढोने के लिए बने हैं। इसे रिफ़िकेशन (reification) कहते हैं, और ऐसा इसलिए किया जाता है ताकि एज खुद प्रॉपर्टीज़ रख सके — कॉन्फ़िडेंस स्कोर, सोर्स, टाइमस्टैम्प — और उसे बाद में इस तरह रिट्रैक्ट किया जा सके कि यह दिखावा न करना पड़े कि वह कभी अस्तित्व में था ही नहीं।
यह वह गलती है जो मैं अपने बने पर्सनलाइज़ेशन सिस्टम्स में सबसे ज़्यादा देखता हूँ: तथ्य सपाट कॉलमों में रखना। user.employer = "Acme"। यह तब तक चलता है जब तक कोई नौकरी न बदले, तलाक़ न हो, या अनुमान ही गलत निकले — और अब या तो आप डीबगिंग के लिए ज़रूरी इतिहास मिटा रहे होते हैं, या पुराने तथ्य इसलिए छोड़ रहे होते हैं क्योंकि उन्हें हटाने से कुछ और टूट जाएगा। निजी तथ्य तेज़ी से पुराने होते हैं। लोग शहर बदलते हैं, रिश्ते खत्म होते हैं, नियोक्ता बदलते हैं। ऐसा स्टोर जो यह व्यक्त न कर सके कि “हमने इसे 0.7 कॉन्फ़िडेंस के साथ माना, यह Calendar attendees से आया था, और 3 मार्च को रिट्रैक्ट कर दिया गया”, चुपचाप भूतिया तथ्यों से भर जाएगा। इसे संभालने वाला स्कीमा कुछ इस तरह दिखता है:
-- A reified edge: two rows share one relationship id,
-- so the edge itself can carry confidence and provenance.
CREATE TABLE triples (
subject TEXT NOT NULL, -- an entity id
predicate TEXT NOT NULL, -- e.g. 'relationshipType', 'relatedEntity'
object TEXT NOT NULL, -- a value or another entity id
rel_id TEXT, -- groups the rows forming one edge
confidence REAL, -- how sure are we?
source TEXT, -- which signal produced this fact
created INTEGER NOT NULL,
retracted INTEGER -- soft delete: facts decay, history stays
);
-- One edge, two rows:
-- ('person:8f2a', 'relationshipType', 'employerOf', 'rel:91', 0.82, 'calendar', ...)
-- ('person:8f2a', 'relatedEntity', 'org:acme', 'rel:91', 0.82, 'calendar', ...)
यह अमल का चुनाव भी बताता है: यह सब सादे SQLite में रहता है। कोई विदेशी ग्राफ़ डेटाबेस नहीं, कोई कस्टम स्टोरेज इंजन नहीं — बस उन टेबल्स में, जिन्हें सबसे ज़्यादा परखे गए एम्बेडेड डेटाबेस पर क्वेरी किया जा सकता है। अगर एक डिवाइस पर कुछ मिलियन एज के लिए आप किसी समर्पित ग्राफ़ स्टोर की ओर झुकने लगें, तो रुकिए। हमने लिखा है कि एम्बेडेबल ग्राफ़ डेटाबेस SQLite से आगे कहाँ अपनी जगह बनाते हैं, और ईमानदार जवाब यह है कि ज़्यादातर एप्लिकेशन उस बिंदु तक पहुँचते ही नहीं। subject और predicate पर अनुशासित इंडेक्सिंग के साथ SQLite में ट्रिपल आपको हैरानी की हद तक दूर ले जा सकते हैं। अपनी जटिलता का बजट प्रोवेनेंस और रिट्रैक्शन के नियमों पर खर्च कीजिए — इन्हीं जगहों पर ऐसे सिस्टम असल में टूटते हैं।
गलती 3: एंटिटी रेज़ोल्यूशन को हल हुई बात मान लेना
इस तरह के सिस्टम के बारे में मैंने जितने भी डिज़ाइन डॉक्स पढ़े हैं, उन सबमें एक बुलेट पॉइंट होता है: “फिर हम एंटिटीज़ को एकीकृत करते हैं”, जैसे यह एक दोपहर का काम हो। असल में यह पूरी पाइपलाइन का सबसे कठिन हिस्सा है, और बहुत बड़े अंतर से। आपके Contacts में “James Whitfield” है। Photos में बिना नाम का एक फ़ेस क्लस्टर है। Calendar में अटेंडी “j.whitfield@company.com” है। Messages में हैंडल “+1-415-555-0142” है। ग्राफ़ की कीमत पूरी तरह इस पर टिकी है कि क्या ये चार अवलोकन एक ही व्यक्ति बनते हैं — और क्या वे सही मायनों में उस दूसरे James के साथ मर्ज नहीं होते, जो आपके रनिंग क्लब से है।
व्यावहारिक आर्किटेक्चर है असममित त्रुटि-लागत के साथ इंक्रीमेंटल क्लस्टरिंग। गलत मर्ज — यानी दो अलग लोगों को एक मान लेना — हर आगे की इन्फ़रेंस को ज़हरीला कर देता है और उसे खोलना बेहद मुश्किल होता है, क्योंकि अब दोनों असली लोगों के तथ्य एक ही नोड पर उलझ चुके हैं। गलत स्प्लिट का मतलब बस इतना है कि ग्राफ़ को और सबूत मिलने तक थोड़ा कम पता है। इसलिए मर्ज थ्रेशोल्ड ऊँचा रखिए और साझा कठोर पहचानकर्ताओं (जैसे दो स्रोतों में दिखने वाला एक फ़ोन नंबर) को ज़्यादातर काम करने दीजिए, जबकि नाम की समानता और सह-उपस्थिति जैसे नरम सिग्नल सिर्फ़ टाई तोड़ने में मदद करें। मुख्य लूप जानबूझकर उबाऊ रखा गया है:
# Incremental entity resolution: precision over recall.
# A false merge corrupts everything downstream; a false split
# just means you learn slower. So merge only on strong evidence.
HARD_SIGNALS = {"phone", "email", "contact_id"} # near-certain identity
MERGE_THRESHOLD = 0.95 # soft-signal bar, set high
def ingest(observation, graph):
candidate = find_candidate(observation, graph)
if candidate is None:
return graph.new_entity(observation)
if shares_hard_signal(observation, candidate, HARD_SIGNALS):
return graph.merge(observation, candidate, confidence=1.0)
score = soft_match_score(observation, candidate) # name sim, co-occurrence
if score >= MERGE_THRESHOLD:
return graph.merge(observation, candidate, confidence=score)
return graph.new_entity(observation) # when in doubt, split
बाद में काम आने वाले दो नियम। पहला, हर मर्ज निर्णय खुद एक तथ्य है जिसका प्रोवेनेंस होना चाहिए — रिकॉर्ड कीजिए कि किन सिग्नल्स ने उसे सही ठहराया, क्योंकि जब यूज़र कहे “वह मेरी बहन नहीं, मेरी सहकर्मी है”, तो आपको नोड मिटाने के बजाय सटीकता से अनमर्ज करना होगा। दूसरा, किसी एक क्लासिफ़ायर के आउटपुट को अकेले एंटिटीज़ मर्ज न करने दें; एक स्वतंत्र सिग्नल से पुष्टि ज़रूरी हो। Apple के डिज़ाइन की एक चुपचाप प्रभावशाली बात यही है: रिश्तेदारी, नौकरी और संचार के सभी एज हल की गई एंटिटी से जुड़े रहते हैं, इसलिए रेज़ोल्यूशन की गलती सीमित रहती है, बढ़ती नहीं — बशर्ते शुरू में रेज़ोल्यूशन सही हो। अपनी समय-सीमा का आधा हिस्सा इसके लिए रखिए। आपको उसकी ज़रूरत पड़ेगी।
गलती 4: यह मान लेना कि “ऑन-डिवाइस” का मतलब है कि प्राइवेसी का काम हो गया
अब वह हिस्सा जहाँ मैं इंजीनियरिंग की तारीफ़ रोकता हूँ। इस आर्किटेक्चर का आम बचाव — और सार्वजनिक प्रतिक्रिया पर यही हावी रहा — है “यह कभी आपके डिवाइस से बाहर नहीं जाता, तो ठीक है।” यह आधा तर्क है। लोकल-फ़र्स्ट ML डेटा-रेज़िडेंसी की समस्या को सचमुच हल करता है: कोई सर्वर-साइड कॉपी नहीं जिसे एक साथ बड़े पैमाने पर सेंध लगाकर चुराया जा सके, कोई ऐड-टेक पाइपलाइन नहीं जो आपका सोशल ग्राफ़ खींचती हो, और एक ही समय में सौ मिलियन यूज़र्स का सबपोना-लक्ष्य नहीं। हर दूसरी प्लेटफ़ॉर्म कंपनी जिस तरह पर्सनलाइज़ेशन करती है, उसकी तुलना में यह एक असली और अर्थपूर्ण जीत है, और मैं इसका बचाव करूँगा।
लेकिन एकत्रीकरण (aggregation) अपना अलग जोखिम गुणक है, और लोकल स्टोरेज उसके लिए कुछ नहीं करता। कोई भी एक स्रोत — आपके कॉन्टैक्ट्स, आपका कैलेंडर, आपके मैसेज का मेटाडेटा — एक सीमित तरीके से संवेदनशील है। फ़्यूज़्ड ग्राफ़, जो आपके नियोक्ता, उम्र के साथ आपका पारिवारिक वृक्ष, हर व्यक्ति से आपकी संचार की लय, आपके आवागमन के पैटर्न और दैनिक गतिविधियाँ जानता है, अपने किसी भी इनपुट से गुणात्मक रूप से अधिक कीमती है। और यह खास स्टोर प्लेनटेक्स्ट SQLite में रहता है, जिसे केवल Full Disk Access ही बचाता है, जो दो वाक्यों के मैन पेज के अलावा कहीं दस्तावेज़ित नहीं है, जिसमें कोई फ़ीचर-वार टॉगल नहीं है और ऑप्ट-आउट का कोई आसान तरीका नहीं है। फ़ॉरेंसिक टूलिंग पहले ही iOS की कॉपी पढ़ रही है। विश्लेषण के शोधकर्ताओं ने वह सीधा प्रयोग किया: यह स्टोर मैलवेयर को दे दीजिए, या डिवाइस पासवर्ड वाले किसी अपमानजनक साथी को, और आपके पास तैयार डोज़ियर है — आप किससे बात करते हैं, कितनी बार, आप कहाँ जाते हैं, आपके बच्चे कौन हैं।
लोकल-फ़र्स्ट डेटा-रेज़िडेंसी की समस्या हल करता है। एकत्रीकरण की समस्या पर इसका कोई असर नहीं पड़ता — डिस्क पर रखा फ़्यूज़्ड डोज़ियर फिर भी डोज़ियर ही है।

इसके उपाय विदेशी नहीं हैं, और इसीलिए उनकी गैर-मौजूदगी चुभती है। स्टोर को रेस्ट पर एन्क्रिप्ट कीजिए, ऐसी कुंजी के साथ जो यूज़र की उपस्थिति से बंधी हो। एक दिखने वाला टॉगल दीजिए — “Siri Intelligence” जैसा एक मोनोलिथ नहीं, बल्कि इस पर दानेदार नियंत्रण कि कौन-से सिग्नल ग्राफ़ में जाएँ। स्कीमा का दस्तावेज़ीकरण कीजिए। और अनुमानित तथ्यों को कच्चे तथ्यों से कम नहीं, बल्कि अधिक संवेदनशील मानिए: किसी ने यह सहमति नहीं दी कि “इस सिस्टम ने आपकी बेटी की उम्र का अनुमान लगाया”, भले ही उन्होंने उन इनपुट्स तक पहुँच दी हो जिनसे यह संभव हुआ। अगर आप लोकल-फ़र्स्ट ML बना रहे हैं, तो डिज़ाइन रिव्यू में खुद से यह वाक्य कहिए: हम डेटा नहीं देख सकते, इसका मतलब यह नहीं कि कोई और कभी नहीं देखेगा। उस दिन की योजना बनाइए जब डिवाइस से समझौता हो, वह ज़ब्त हो या बेच दिया जाए, क्योंकि आपके बेड़े के कुछ हिस्से के साथ यह ज़रूर होगा।
गलती 5: बिना निरीक्षण के मार्ग के इन्फ़रेंस शिप करना
सोचिए हमें यह पता कैसे चला कि यह मौजूद है। दस्तावेज़ से नहीं — आधिकारिक विवरण वही रूखा मैन पेज है। हमें इसलिए पता चला क्योंकि स्वतंत्र शोधकर्ताओं ने डेटाबेस को रिवर्स-इंजीनियर किया और एक ओपन-सोर्स डैशबोर्ड बनाया ताकि यूज़र अपना ग्राफ़ पढ़ सकें, और एक फ़ॉरेंसिक टूल के मेंटेनर ने अपने टूल को iOS वर्ज़न पढ़ना सिखा दिया। यूज़र्स ने अपने ही मशीनों पर तीसरे-पक्ष का कोड चलाकर अपने परिवारों के बारे में अनुमानित रिश्तेदारी लेबल खोज निकाले। यह एक विफलता का तरीका है, और इंजीनियरिंग टीमें इसमें आँखें खुली रखकर भी चली जाती हैं: सिस्टम किसी व्यक्ति के बारे में निष्कर्ष निकालता है, और उस व्यक्ति के पास उन्हें देखने, सुधारने या मिटाने का कोई पहली-पार्टी तरीका नहीं होता।
यह सिर्फ़ नैतिकता का चेकबॉक्स नहीं है; यह परिचालन का भी मुद्दा है। अगर आप ग्राफ़ नहीं देख सकते, तो उसे डीबग भी नहीं कर सकते। जब कोई यूज़र शिकायत करे कि “आपका असिस्टेंट मेरे पूर्व साथी को मेरी पत्नी समझता है”, तो यह पता करने का एकमात्र तरीका है कि प्रोवेनेंस के ज़रिए उस एज को उस सिग्नल तक वापस ट्रेस करें जिसने उसे बनाया। जो टीमें शुरू में ही रीड पाथ बनाती हैं — एक आंतरिक व्यूअर, एक एक्सपोर्ट बटन, हर अनुमानित तथ्य पर एक “इसे समझाएँ” विकल्प — वे बेहतर मॉडल शिप करती हैं, क्योंकि गलत इन्फ़रेंस चुपचाप खीझ बनने के बजाय दिखने वाली बग रिपोर्ट बन जाती हैं। जो टीमें ऐसा नहीं करतीं, उनके यूज़र्स रिवर्स-इंजीनियर किए गए डैशबोर्ड्स के स्क्रीनशॉट सोशल मीडिया पर डालने लगते हैं, जो किसी भी सेटिंग्स पेज से कहीं ज़्यादा बुरी छवि है।
मेरा एक अनुभव-सिद्ध नियम: किसी भी ऐसे फ़ीचर के लिए जो यूज़र के बारे में निष्कर्ष निकालता है, निरीक्षण UI कोई “अच्छा हो तो बेहतर” चीज़ नहीं है जो बाद के रिलीज़ में आए। वह उसी रिलीज़ में शिप होता है, या फ़ीचर शिप ही नहीं होता। लागत एक सेटिंग्स पेन और एक JSON एक्सपोर्ट है। फ़ायदा वह भरोसा है जिसके लिए प्रेस रिलीज़ में गिड़गिड़ाना नहीं पड़ता। और व्यावहारिक रूप से, रेगुलेटर ठीक इसी अंतर पर नज़र रख रहे हैं — जो सिस्टम लोगों के बारे में संवेदनशील गुण अनुमानित करते हैं, उन्हें उन लोगों के सामने पारदर्शी होना होगा, और “यह ऑन-डिवाइस है” अदृश्यता के लिए मान्य बचाव नहीं होगा।
आपके अगले लोकल-फ़र्स्ट ML फ़ीचर के लिए क्या अपनाएँ
विवाद हटा दीजिए, तो यह वह आर्किटेक्चर है जो मैं किसी भी ऐसी टीम को थमाऊँगा जो ऐसी पर्सनलाइज़ेशन बना रही है जो घर फ़ोन नहीं कर सकती — और ईमानदारी से कहूँ, ज़्यादातर पर्सनलाइज़ेशन को घर फ़ोन करने की ज़रूरत ही नहीं होनी चाहिए। संक्षेप में ब्लूप्रिंट यह है:
- एक बड़े मॉडल की जगह कई छोटे क्लासिफ़ायर्स। हर सिग्नल के लिए एक, जिसे अलग-अलग टेस्ट और रीट्रेन किया जा सके, और जो बैटरी पर हमेशा चलाने के लिए काफ़ी सस्ता हो।
- रिफ़िकेटेड एज वाला ट्रिपल स्टोर। हर तथ्य के साथ कॉन्फ़िडेंस, सोर्स और टाइमस्टैम्प हों; हर तथ्य इतिहास मिटाए बिना रिट्रैक्ट किया जा सके। SQLite काफ़ी है।
- सटीकता के लिए ट्यून की गई एंटिटी रेज़ोल्यूशन। गलत मर्ज सबसे बड़ी विफलता है; गलत स्प्लिट बस धीमा करता है। एकीकृत करने से पहले पुष्टि कीजिए।
- रेज़िडेंसी से आगे जाने वाली प्राइवेसी इंजीनियरिंग। रेस्ट पर एन्क्रिप्शन, दानेदार सहमति, रिटेंशन सीमाएँ — क्योंकि एकत्रीकरण एक ऐसा लक्ष्य बनाता है जो कोई एक इनपुट कभी नहीं था।
- पहले दिन से निरीक्षण का मार्ग। अगर सिस्टम यूज़र के बारे में निष्कर्ष निकालता है, तो यूज़र को उन निष्कर्षों को देखने, सुधारने और मिटाने का अधिकार मिले।
अगर आप सर्विंग पक्ष पर एक ठोस शुरुआती बिंदु चाहते हैं, तो हमने पूरी तरह ऑफ़लाइन काम करने वाले LLM फ़ीचर्स बनाने के बारे में लिखा है, और वही अनुशासन यहाँ भी लागू होता है — मान लीजिए नेटवर्क गायब है, पावर बजट छोटा है, और यूज़र आपका कुछ भी देनदार नहीं है। असहज समापन बात यह है कि Apple के इंजीनियरों ने वास्तव में प्रशंसनीय चीज़ बनाई और फिर उसे चुप्पी से कमज़ोर कर दिया। क्लासिफ़ायर्स, स्कीमा, डेटा सेंटर में सब कुछ भेजने के बजाय लोकल इन्फ़रेंस करने का संयम — यही वह हिस्सा है जिसकी नकल करनी चाहिए। अदृश्य, हमेशा चालू रहने वाला, और टर्मिनल कमांड से ऑप्ट-आउट होने वाला रवैया वह हिस्सा है जिससे बचना चाहिए। ग्राफ़ बनाइए। यूज़र को बताइए कि वह मौजूद है। दोनों हिस्से इंजीनियरिंग हैं, और दूसरा वाला वैकल्पिक नहीं है।


