Ghaznix

फेडरेटेड लर्निंग (Federated Learning): अपना डेटा साझा किए बिना AI को प्रशिक्षित करना

फेडरेटेड लर्निंग अवधारणा आरेख

पारंपरिक मशीन लर्निंग पाइपलाइन में, डेटा संग्रह पहला और अक्सर सबसे महंगा कदम होता है। एक मॉडल को प्रशिक्षित करने के लिए, आपको उपयोगकर्ताओं का कच्चा डेटा—जैसे फोटो, संदेश, स्वास्थ्य रिकॉर्ड, या वित्तीय लेनदेन—एकत्र करना होगा और इसे एक केंद्रीकृत क्लाउड सर्वर पर अपलोड करना होगा।

हालांकि इस केंद्रीकृत दृष्टिकोण ने एआई क्रांति को संचालित किया है, लेकिन इसे बड़ी चुनौतियों का सामना करना पड़ता है:

  1. गोपनीयता की चिंताएं: उपयोगकर्ता अपने निजी डेटा को तीसरे पक्ष के सर्वर पर अपलोड करने में संकोच करते हैं।
  2. डेटा नियम: जीडीपीआर (GDPR) और हिप्पा (HIPAA) जैसे नियम कड़ाई से प्रतिबंधित करते हैं कि व्यक्तिगत डेटा को कैसे स्थानांतरित और संग्रहीत किया जा सकता है।
  3. बैंडविड्थ लागत: लाखों एज उपकरणों (जैसे स्मार्टफोन) से गीगाबाइट कच्चे डेटा को अपलोड करना अत्यधिक अक्षम है।

फेडरेटेड लर्निंग (Federated Learning - FL) पारंपरिक प्रतिमान को बदलकर इन समस्याओं का समाधान करती है। डेटा को मॉडल के पास ले जाने के बजाय, यह मॉडल को डेटा के पास लाती है।

मूल अवधारणा: विकेंद्रीकृत प्रशिक्षण

फेडरेटेड लर्निंग में, केंद्रीय सर्वर एक ग्लोबल मॉडल (global model) बनाए रखता है। इस मॉडल को प्रशिक्षित करने के लिए कच्चे डेटा को इकट्ठा करने के बजाय, सर्वर एज उपकरणों (जैसे स्मार्टफोन, स्मार्ट होम डिवाइस या क्षेत्रीय अस्पताल डेटाबेस) के नेटवर्क पर एक सहयोगात्मक प्रशिक्षण प्रक्रिया का समन्वय करता है।

फेडरेटेड लर्निंग का मूल नियम यह है:

कच्चा डेटा कभी भी स्थानीय उपकरण से बाहर नहीं जाता है। केवल गणितीय मॉडल अपडेट साझा किए जाते हैं।

चरण-दर-चरण मार्गदर्शिका: यह कैसे काम करता है

एक विशिष्ट फेडरेटेड लर्निंग प्रशिक्षण चक्र (जिसे कम्युनिकेशन राउंड के रूप में जाना जाता है) में पांच मुख्य चरण शामिल हैं:

sequenceDiagram
    participant Server as केंद्रीय सर्वर (ग्लोबल मॉडल)
    participant ClientA as क्लाइंट A (निजी डेटा A)
    participant ClientB as क्लाइंट B (निजी डेटा B)
    
    rect rgb(240, 248, 255)
        Note over Server: चरण 1: ग्लोबल मॉडल को प्रारंभ करना
    end
    Server->>ClientA: चरण 2: ग्लोबल वेट्स भेजें (W_t)
    Server->>ClientB: चरण 2: ग्लोबल वेट्स भेजें (W_t)
    rect rgb(245, 245, 245)
        Note over ClientA: चरण 3: निजी डेटा पर स्थानीय प्रशिक्षण
        Note over ClientB: चरण 3: निजी डेटा पर स्थानीय प्रशिक्षण
    end
    ClientA->>Server: चरण 4: स्थानीय अपडेट भेजें (W_t^A)
    ClientB->>Server: चरण 4: स्थानीय अपडेट भेजें (W_t^B)
    rect rgb(240, 255, 240)
        Note over Server: चरण 5: औसत अपडेट (FedAvg)<br/>ग्लोबल मॉडल अपडेट करें (W_t+1)
    end

1. प्रारंभ करना (Initialization)

केंद्रीय सर्वर शुरुआती वेट्स ($W_0$) के साथ ग्लोबल मॉडल को शुरू करता है। ये वेट्स यादृच्छिक हो सकते हैं या किसी सार्वजनिक डेटासेट पर पूर्व-प्रशिक्षित हो सकते हैं।

2. वितरण (मॉडल प्रसारण)

सर्वर उपलब्ध क्लाइंट उपकरणों के एक सबसेट का चयन करता है (उदाहरण के लिए, वे फोन जो चार्ज हो रहे हैं, वाई-फाई से जुड़े हैं और खाली हैं) और उन्हें वर्तमान ग्लोबल मॉडल वेट्स ($W_t$) प्रसारित करता है।

3. स्थानीय प्रशिक्षण

प्रत्येक चयनित क्लाइंट अपने स्थानीय, निजी डेटासेट पर प्राप्त ग्लोबल मॉडल को प्रशिक्षित करता है। यह स्टोकेस्टिक ग्रेडिएंट डिसेंट (SGD) जैसे मानक अनुकूलन एल्गोरिदम का उपयोग करके किया जाता है। कुछ अवधियों (epochs) के बाद, प्रत्येक क्लाइंट $i$ स्थानीय मॉडल वेट्स ($W_t^i$) का एक नया सेट तैयार करता है।

4. स्थानीय अपडेट अपलोड करना

निजी प्रशिक्षण डेटा भेजने के बजाय, क्लाइंट केवल अपने नए स्थानीय मॉडल वेट्स (या अंतर $\Delta W_t^i = W_t^i - W_t$) को केंद्रीय सर्वर पर वापस भेजते हैं। इन अपडेट को आमतौर पर क्रिप्टोग्राफिक प्रोटोकॉल का उपयोग करके सुरक्षित किया जाता है।

5. वैश्विक एकत्रीकरण (Aggregation)

केंद्रीय सर्वर सभी भाग लेने वाले क्लाइंट्स से अपडेट एकत्र करता है। यह एक नया ग्लोबल मॉडल ($W_{t+1}$) बनाने के लिए उनका औसत (आमतौर पर प्रत्येक क्लाइंट के पास मौजूद स्थानीय डेटा की मात्रा के आधार पर भारित) निकालता है। इसके लिए सबसे आम एल्गोरिदम फेडरेटेड एवरेजिंग (FedAvg) है:

$$W_{t+1} = \sum_{i=1}^{K} \frac{n_i}{N} W_t^i$$

जहाँ:

  • $K$ भाग लेने वाले क्लाइंट्स की संख्या है।
  • $n_i$ क्लाइंट $i$ पर डेटा नमूनों की संख्या है।
  • $N$ सभी भाग लेने वाले क्लाइंट्स में कुल डेटा नमूनों की संख्या है ($N = \sum n_i$)।

यह चक्र कई राउंड तक दोहराया जाता है जब तक कि ग्लोबल मॉडल वांछित सटीकता प्राप्त नहीं कर लेता।

कोड उदाहरण: एक सरल पायथन सिमुलेशन

फेडरेटेड लर्निंग को व्यावहारिक रूप से समझने के लिए, आइए NumPy का उपयोग करके एक सरल पायथन सिमुलेशन लिखें।

इस परिदृश्य में, हम रैखिक प्रतिगमन (linear regression) का उपयोग करके घर की कीमतों ($y = w \cdot x$) की भविष्यवाणी करने के लिए एक मॉडल को प्रशिक्षित करना चाहते हैं। हमारे पास एक केंद्रीय सर्वर और 3 क्लाइंट हैं, जिनमें से प्रत्येक के पास अपने निजी घर के आकार ($x$) और कीमतें ($y$) हैं।

import numpy as np

# 1. क्लाइंट निजी डेटा सेट करें (सर्वर के साथ साझा नहीं किया जा सकता)
# प्रत्येक क्लाइंट के पास स्थानीय नमूनों (n_i) की संख्या अलग है
clients_data = {
    "Client_1": {"x": np.array([1.0, 1.5, 2.0]), "y": np.array([110.0, 160.0, 210.0])}, # वास्तविक संबंध: y = 100x + 10
    "Client_2": {"x": np.array([0.8, 1.2]),       "y": np.array([90.0, 130.0])},       # वास्तविक संबंध: y = 100x + 10
    "Client_3": {"x": np.array([2.5, 3.0, 3.5]), "y": np.array([260.0, 310.0, 360.0])}  # वास्तविक संबंध: y = 100x + 10
}

# सभी क्लाइंट्स में कुल डेटा अंक (N)
total_samples = sum(len(data["x"]) for data in clients_data.values())

# 2. सर्वर प्रारंभिक वेट्स (ग्लोबल मॉडल: W_t)
global_weight = 10.0  # प्रारंभिक अनुमान (वास्तविक मूल्य 100.0 से बहुत दूर)
learning_rate = 0.05
epochs = 5  # प्रति राउंड स्थानीय प्रशिक्षण अवधि
communication_rounds = 3

print(f"प्रारंभिक ग्लोबल वेट्स: {global_weight:.2f}\n")

# फेडरेटेड लर्निंग लूप
for round_idx in range(communication_rounds):
    print(f"--- कम्युनिकेशन राउंड {round_idx + 1} ---")
    local_weights = []
    client_sample_sizes = []
    
    # चरण 2 और 3: मॉडल वितरण और क्लाइंट उपकरणों पर स्थानीय प्रशिक्षण
    for client_name, data in clients_data.items():
        x = data["x"]
        y = data["y"]
        n_i = len(x)
        
        # क्लाइंट ग्लोबल वेट्स प्राप्त करता है
        w_local = global_weight
        
        # क्लाइंट कुछ epochs के लिए स्थानीय रूप से प्रशिक्षित करता है
        for epoch in range(epochs):
            # भविष्यवाणी की गणना करें: y_pred = w * x
            y_pred = w_local * x
            # सरल रैखिक प्रतिगमन के लिए ग्रेडिएंट की गणना करें
            gradient = -2 * np.mean(x * (y - y_pred))
            # स्थानीय वेट्स अपडेट करें
            w_local -= learning_rate * gradient
            
        print(f"  {client_name} ने स्थानीय वेट्स को प्रशिक्षित किया: {w_local:.2f} (नमूने: {n_i})")
        
        # एकत्रीकरण के लिए स्थानीय वेट्स और नमूना आकार सहेजें
        local_weights.append(w_local)
        client_sample_sizes.append(n_i)
        
    # चरण 4 और 5: फेडरेटेड एवरेजिंग (FedAvg) का उपयोग करके सर्वर-साइड एकत्रीकरण
    weighted_sum = 0.0
    for w, n in zip(local_weights, client_sample_sizes):
        weighted_sum += w * n
        
    global_weight = weighted_sum / total_samples
    print(f"=> सर्वर एकीकृत ग्लोबल वेट्स: {global_weight:.2f}\n")

print(f"FL के बाद अंतिम ग्लोबल मॉडल वेट्स: {global_weight:.2f}")

यह कोड फेडरेटेड लर्निंग का प्रतिनिधित्व क्यों करता है:

  • डिक्शनरी clients_data पृथक डेटाबेस का प्रतिनिधित्व करती है। सर्वर कभी भी उन तक नहीं पहुँचता है।
  • प्रशिक्षण लूप में, क्लाइंट से सर्वर तक पारित एकमात्र चर w_local है।
  • सर्वर नमूना आकारों (client_sample_sizes) के आधार पर भारित औसत निकालता है, जो FedAvg के गणितीय सूत्र को लागू करता है।

केंद्रीकृत शिक्षा बनाम फेडरेटेड लर्निंग

विशेषता केंद्रीकृत मशीन लर्निंग फेडरेटेड लर्निंग
डेटा का स्थान केंद्रीकृत क्लाउड/सर्वर वितरित एज उपकरण
गोपनीयता कच्चा डेटा क्लाउड पर अपलोड होता है डेटा उपकरण पर रहता है
बैंडविड्थ उच्च (कच्चे डेटासेट अपलोड करता है) कम (मॉडल वेट्स अपलोड करता है)
डेटा विविधता केवल अपलोड किए गए डेटासेट तक सीमित अत्यधिक उच्च (वास्तविक दुनिया का डेटा)
नियामक अनुपालन कठिन (GDPR/HIPAA जैसी बाधाएं) अंतर्निहित अनुपालन (प्रारूप से ही)

सुरक्षा संवर्द्धन: गोपनीयता और एन्क्रिप्शन

यद्यपि फेडरेटेड लर्निंग स्वाभाविक रूप से केंद्रीकृत प्रशिक्षण की तुलना में अधिक सुरक्षित है, फिर भी सर्वर को वेट्स भेजना गोपनीयता जोखिम का कारण बन सकता है (क्योंकि वेट्स से कभी-कभी डेटा का पता लगाया जा सकता है)। इससे निपटने के लिए, फेडरेटेड लर्निंग को दो प्रमुख सुरक्षा तकनीकों के साथ जोड़ा जाता है:

  1. सुरक्षित एकत्रीकरण (Secure Aggregation - SecAgg): एक क्रिप्टोग्राफिक प्रोटोकॉल जो सर्वर को किसी व्यक्तिगत क्लाइंट के अपडेट को देखे बिना सभी स्थानीय मॉडल अपडेट के योग की गणना करने की अनुमति देता है। सर्वर केवल एकीकृत परिणाम देखता है।
  2. डिफरेंशियल प्राइवेसी (Differential Privacy - DP): अपलोड करने से पहले स्थानीय वेट्स में गणितीय “शोर (noise)” जोड़ना। यह सुनिश्चित करता है कि वैश्विक मॉडल द्वारा किसी व्यक्तिगत उपयोगकर्ता के डेटा की पहचान न की जा सके।

वास्तविक दुनिया के उदाहरण

फेडरेटेड लर्निंग आज आपके उपकरणों पर पहले से ही चुपचाप चल रहा है:

  • Google Gboard: Google अगले शब्द की भविष्यवाणी और खोज सुझावों को प्रशिक्षित करने के लिए फेडरेटेड लर्निंग का उपयोग करता है। आपका कीबोर्ड आपकी टाइपिंग आदतों को Google के सर्वर पर भेजे बिना सीखता है।
  • Apple QuickType: Apple सीधे iPhones पर ऑटो-करेक्शन और सिरी आवाज़ पहचान सुझावों को बेहतर बनाने के लिए विकेंद्रीकृत प्रशिक्षण का उपयोग करता है.
  • स्वास्थ्य सेवा (MELLODDY प्रोजेक्ट): अग्रणी दवा कंपनियां प्रतिस्पर्धियों के सामने अपनी खोजों को उजागर किए बिना, निजी रासायनिक डेटाबेस पर दवाओं की खोज के लिए संयुक्त रूप से मॉडल प्रशिक्षित करने के लिए फेडरेटेड लर्निंग का उपयोग करती हैं।

सारांश

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

ग़ज़्निक्स ब्लॉग पर विकेंद्रीकृत तकनीक के बारे में अधिक जानकारी प्राप्त करें →

Tags

मशीन लर्निंग गोपनीयता एआई वितरित कंप्यूटिंग डेटा सुरक्षा