गहरी सीख। लर्निंग फेडरेटेड

हाय, हब्रोज़ितेली! हमने हाल ही में एंड्रयू डब्लू। टस्क को एक पुस्तक सौंपी, जो गहन शिक्षण प्रौद्योगिकी की आगे की महारत की नींव रखता है। यह तंत्रिका नेटवर्क की मूल बातें के विवरण के साथ शुरू होता है और फिर अतिरिक्त परतों और आर्किटेक्चर की विस्तार से जांच करता है।

हम "फेडरेटेड लर्निंग" पास की समीक्षा की पेशकश करते हैं

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

फेडरेटेड लर्निंग एक मॉडल को एक सुरक्षित वातावरण में संलग्न करने और इसे कहीं भी डेटा स्थानांतरित किए बिना सिखाने के लिए एक तकनीक है। एक उदाहरण पर विचार करें।

import numpy as np from collections import Counter import random import sys import codecsnp.random.seed(12345) with codecs.open('spam.txt',"r",encoding='utf-8',errors='ignore') as f: ←     http://www2.aueb.gr/users/ion/data/enron-spam/ raw = f.readlines() vocab, spam, ham = (set(["<unk>"]), list(), list()) for row in raw: spam.append(set(row[:-2].split(" "))) for word in spam[-1]: vocab.add(word) with codecs.open('ham.txt',"r",encoding='utf-8',errors='ignore') as f: raw = f.readlines() for row in raw: ham.append(set(row[:-2].split(" "))) for word in ham[-1]: vocab.add(word) vocab, w2i = (list(vocab), {}) for i,w in enumerate(vocab): w2i[w] = i def to_indices(input, l=500): indices = list() for line in input: if(len(line) < l): line = list(line) + ["<unk>"] * (l - len(line)) idxs = list() for word in line: idxs.append(w2i[word]) indices.append(idxs) return indices 

स्पैम का पता लगाना सीखना।

मान लीजिए कि हमें लोगों के ईमेल से स्पैम का पता लगाने के लिए एक मॉडल को प्रशिक्षित करने की आवश्यकता है

इस मामले में, हम ईमेल वर्गीकरण के बारे में बात कर रहे हैं। हम एनरॉन नामक सार्वजनिक डेटासेट पर अपने पहले मॉडल को प्रशिक्षित करेंगे। यह एनरॉन सुनवाई (अब एक मानक ईमेल विश्लेषणात्मक निकाय) के दौरान प्रकाशित ईमेल का एक विशाल निकाय है। एक दिलचस्प तथ्य: मैं ऐसे लोगों से परिचित था, जिन्हें उनकी गतिविधियों की प्रकृति से, इस डेटा सेट पर पढ़ना / टिप्पणी करना था, और वे ध्यान दें कि लोगों ने एक दूसरे को इन पत्रों में कई प्रकार की जानकारी (अक्सर बहुत व्यक्तिगत) भेजी थी। लेकिन चूंकि परीक्षण के दौरान इस लाश को सार्वजनिक किया गया था, इसलिए अब इसे बिना किसी प्रतिबंध के इस्तेमाल किया जा सकता है।

पहले और इस खंड में कोड केवल प्रारंभिक संचालन को लागू करता है। इनपुट फाइलें (हैमटेक्स और स्पैमटैक्स) पुस्तक के वेब पेज पर उपलब्ध हैं: www.manning.com/books/grokking-deep-learning और GitHub रिपॉजिटरी में: github.com/iamtrask/Gotkking-Deep-Learning । हमें इसे अध्याय 13 से एंबेडिंग क्लास में स्थानांतरित करने के लिए तैयार करने के लिए पूर्व-प्रक्रिया करने की आवश्यकता है, जहां हमने अपने गहन शिक्षण ढांचे का निर्माण किया। पहले की तरह, इस कॉर्पस के सभी शब्द इंडेक्स लिस्ट में बदल दिए गए हैं। इसके अलावा, हम सभी अक्षरों को 500 शब्दों की समान लंबाई में लाते हैं, या तो उन्हें ट्रिम कर रहे हैं या टोकन जोड़ रहे हैं। इसके लिए धन्यवाद, हमें एक आयताकार डेटा सेट मिलता है।

 spam_idx = to_indices(spam) ham_idx = to_indices(ham) train_spam_idx = spam_idx[0:-1000] train_ham_idx = ham_idx[0:-1000] test_spam_idx = spam_idx[-1000:] test_ham_idx = ham_idx[-1000:] train_data = list() train_target = list() test_data = list() test_target = list() for i in range(max(len(train_spam_idx),len(train_ham_idx))): train_data.append(train_spam_idx[i%len(train_spam_idx)]) train_target.append([1]) train_data.append(train_ham_idx[i%len(train_ham_idx)]) train_target.append([0]) for i in range(max(len(test_spam_idx),len(test_ham_idx))): test_data.append(test_spam_idx[i%len(test_spam_idx)]) test_target.append([1]) test_data.append(test_ham_idx[i%len(test_ham_idx)]) test_target.append([0]) def train(model, input_data, target_data, batch_size=500, iterations=5): n_batches = int(len(input_data) / batch_size) for iter in range(iterations): iter_loss = 0 for b_i in range(n_batches): #         model.weight.data[w2i['<unk>']] *= 0 input = Tensor(input_data[b_i*bs:(b_i+1)*bs], autograd=True) target = Tensor(target_data[b_i*bs:(b_i+1)*bs], autograd=True) pred = model.forward(input).sum(1).sigmoid() loss = criterion.forward(pred,target) loss.backward() optim.step() iter_loss += loss.data[0] / bs sys.stdout.write("\r\tLoss:" + str(iter_loss / (b_i+1))) print() return model def test(model, test_input, test_output): model.weight.data[w2i['<unk>']] *= 0 input = Tensor(test_input, autograd=True) target = Tensor(test_output, autograd=True) pred = model.forward(input).sum(1).sigmoid() return ((pred.data > 0.5) == target.data).mean() 

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

 model = Embedding(vocab_size=len(vocab), dim=1) model.weight.data *= 0 criterion = MSELoss() optim = SGD(parameters=model.get_parameters(), alpha=0.01) for i in range(3): model = train(model, train_data, train_target, iterations=1) print("% Correct on Test Set: " + \ str(test(model, test_data, test_target)*100)) ______________________________________________________________________________ Loss:0.037140416860871446 % Correct on Test Set: 98.65 Loss:0.011258669226059114 % Correct on Test Set: 99.15 Loss:0.008068268387986223 % Correct on Test Set: 99.45 

चलो मॉडल को संघीय बनाते हैं

ऊपर, सबसे आम गहरी शिक्षा हुई थी। अब गोपनीयता जोड़ें

पिछले अनुभाग में, हमने ईमेल विश्लेषण का एक उदाहरण लागू किया। अब सभी ईमेल को एक जगह पर रख दें। यह एक अच्छा पुराना काम करने का तरीका है (जो अभी भी दुनिया भर में व्यापक रूप से उपयोग किया जाता है)। शुरू करने के लिए, हम संघीय शिक्षा के वातावरण की नकल करेंगे, जिसमें पत्रों के कई अलग-अलग संग्रह हैं:

 bob = (train_data[0:1000], train_target[0:1000]) alice = (train_data[1000:2000], train_target[1000:2000]) sue = (train_data[2000:], train_target[2000:]) 

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

 for i in range(3): print("Starting Training Round...") print("\tStep 1: send the model to Bob") bob_model = train(copy.deepcopy(model), bob[0], bob[1], iterations=1) print("\n\tStep 2: send the model to Alice") alice_model = train(copy.deepcopy(model), alice[0], alice[1], iterations=1) print("\n\tStep 3: Send the model to Sue") sue_model = train(copy.deepcopy(model), sue[0], sue[1], iterations=1) print("\n\tAverage Everyone's New Models") model.weight.data = (bob_model.weight.data + \ alice_model.weight.data + \ sue_model.weight.data)/3 print("\t% Correct on Test Set: " + \ str(test(model, test_data, test_target)*100)) print("\nRepeat!!\n") 

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

 Starting Training Round... Step 1: send the model to Bob Loss:0.21908166249699718 ...... Step 3: Send the model to Sue Loss:0.015368461608470256 Average Everyone's New Models % Correct on Test Set: 98.8 

एक फ़ेडरेटेड मॉडल को हैक करें

आइए एक सरल उदाहरण देखें कि प्रशिक्षण डेटासेट से जानकारी कैसे निकालें।

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

लेकिन चलो खुद से आगे नहीं। आइए देखें कि एक पैकेज पर उपयोगकर्ता के वजन के अपडेट के बाद आप क्या पता लगा सकते हैं:

 import copy bobs_email = ["my", "computer", "password", "is", "pizza"] bob_input = np.array([[w2i[x] for x in bobs_email]]) bob_target = np.array([[0]]) model = Embedding(vocab_size=len(vocab), dim=1) model.weight.data *= 0 bobs_model = train(copy.deepcopy(model), bob_input, bob_target, iterations=1, batch_size=1) 

बॉब अपने इनबॉक्स में ईमेल द्वारा मॉडल बनाता और प्रशिक्षित करता है। लेकिन ऐसा हुआ कि उसने खुद को टेक्स्ट के साथ एक पत्र भेजकर अपना पासवर्ड बचाया: "मेरा कंप्यूटर पासवर्ड पिज्जा है।" भोले बाबा! यह देखने के बाद कि कौन सा वज़न बदल गया है, हम बॉब के पत्र का शब्दकोष (और अर्थ समझ सकते हैं):

 for i, v in enumerate(bobs_model.weight.data - model.weight.data): if(v != 0): print(vocab[i]) 

इस तरह के एक सरल तरीके से, हमने बॉब के टॉप-सीक्रेट पासवर्ड (और संभवतः उसकी पाक वरीयताओं) का पता लगाया। और क्या करना है? फ़ेडरेटेड लर्निंग पर भरोसा कैसे करें अगर यह पता लगाना बहुत आसान हो कि किस ट्रेनिंग डेटा के कारण वज़न में बदलाव आया?

 is pizza computer password my 

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर पाई जा सकती है
» सामग्री
» अंश

एक कूपन पर Habrozhiteli पूर्व-ऑर्डर पुस्तकों के लिए 30% छूट - ग्रॉकिंग डीप लर्निंग