जड़ता (SGDm) का विचार, स्केलिंग का विचार (अडगार्ड) और वर्गीकरण समस्या का उपयोग करके मशीन लर्निंग में नियमितीकरण एक उदाहरण है।

इसके बाद उपयोग किए जाने वाले डेटासेट यहां से पहले से ही पारित कागल प्रतियोगिता से लिया जाता है ।
डेटा टैब पर, आप सभी फ़ील्ड का विवरण पढ़ सकते हैं।

सभी स्रोत कोड यहां लैपटॉप प्रारूप में हैं ।

हम डेटा लोड करते हैं, जांचें कि हमारे पास आम तौर पर है:

import numpy as np import pandas as pd dataset = pd.read_csv('../input/ghouls-goblins-and-ghosts-boo/train.csv') #   X_test = pd.read_csv('../input/ghouls-goblins-and-ghosts-boo/test.csv') #   print(dataset.shape) print(dataset[:10]) 

प्रकार फ़ील्ड (Ghoul, भूत, भूत) के मूल्यों को केवल 0, 1 और 2 द्वारा प्रतिस्थापित किया जाता है।

रंग - को भी पूर्व-संसाधित करने की आवश्यकता है (हमें मॉडल बनाने के लिए केवल संख्यात्मक मूल्यों की आवश्यकता है)। हम इसके लिए LabelEncoder और OneHotEncoder का उपयोग करेंगे। अधिक जानकारी ।

 from sklearn.preprocessing import LabelEncoder, OneHotEncoder labelencoder_X_1 = LabelEncoder() X_train[:, 4] = labelencoder_X_1.fit_transform(X_train[:, 4]) labelencoder_X_2 = LabelEncoder() X_test[:, 4] = labelencoder_X_2.fit_transform(X_test[:, 4]) labelencoder_Y_2 = LabelEncoder() Y_train = labelencoder_Y_2.fit_transform(Y_train) one_hot_encoder = OneHotEncoder(categorical_features = [4]) X_train = one_hot_encoder.fit_transform(X_train).toarray() X_test = one_hot_encoder.fit_transform(X_test).toarray() 

खैर, इस बिंदु पर हमारा डेटा तैयार है। यह हमारे मॉडल को प्रशिक्षित करने के लिए बनी हुई है।

सबसे पहले अडगार्ड लागू करें :

संक्षेप में, यह स्टोकेस्टिक क्रमिक वंश का एक संशोधन है, जिसके बारे में मैंने पिछली बार लिखा था: habr.com/en/post/472300

यह विधि प्रत्येक व्यक्तिगत पैरामीटर (स्केलिंग के विचार) के लिए सभी पिछले ग्रेडिएंट के इतिहास को ध्यान में रखती है। यह आपको बड़े ग्रेडिएंट वाले मापदंडों के लिए सीखने के चरण के आकार को कम करने की अनुमति देता है:



जी स्केलिंग पैरामीटर है (g0 = 0)
weight - पैरामीटर (वजन)
एप्सिलॉन शून्य द्वारा विभाजन को रोकने के लिए एक छोटा सा स्थिरांक है

डेटासेट को 2 भागों में विभाजित करें:
प्रशिक्षण नमूना (ट्रेन) और सत्यापन (वैल):

 from sklearn.model_selection import train_test_split x_train, x_val, y_train, y_val = train_test_split(X_train, Y_train, test_size = 0.2) 

मॉडल प्रशिक्षण के लिए थोड़ी तैयारी:

 import torch import numpy as np device = 'cuda' if torch.cuda.is_available() else 'cpu' def make_train_step(model, loss_fn, optimizer): def train_step(x, y): model.train() yhat = model(x) loss = loss_fn(yhat, y) loss.backward() optimizer.step() optimizer.zero_grad() return loss.item() return train_step 

स्व प्रशिक्षण मॉडल:

 from torch import optim, nn model = torch.nn.Sequential( nn.Linear(10, 270), nn.ReLU(), nn.Linear(270, 3)) lr = 0.01 n_epochs = 500 loss_fn = torch.nn.CrossEntropyLoss() optimizer = optim.Adagrad(model.parameters(), lr=lr) train_step = make_train_step(model, loss_fn, optimizer) from sklearn.utils import shuffle for epoch in range(n_epochs): x_train, y_train = shuffle(x_train, y_train) #    X = torch.FloatTensor(x_train) y = torch.LongTensor(y_train) loss = train_step(X, y) print(loss) 

मॉडल रेटिंग:

 #  : test_var = torch.FloatTensor(x_val) with torch.no_grad(): result = model(test_var) values, labels = torch.max(result, 1) num_right = np.sum(labels.data.numpy() == y_val) print(' {:.2f}'.format(num_right / len(y_val))) 

यहां, परतों के अलावा, हमारे पास केवल 2 कॉन्फ़िगर करने योग्य पैरामीटर हैं (अभी के लिए):
सीखने की दर और n_epochs (युगों की संख्या)।

हम इन दो मापदंडों को कैसे जोड़ते हैं, इसके आधार पर, 3 स्थितियां उत्पन्न हो सकती हैं:

1 - सब ठीक है, अर्थात मॉडल प्रशिक्षण नमूने पर कम नुकसान और सत्यापन पर उच्च सटीकता दिखाता है।

2 - अंडरफ़िटिंग - प्रशिक्षण के नमूने पर बड़ा नुकसान और सत्यापन पर कम सटीकता।

3 - ओवरफिटिंग - प्रशिक्षण नमूने पर कम नुकसान, लेकिन सत्यापन पर कम सटीकता।

पहले के साथ, सब कुछ स्पष्ट है :)

दूसरे के साथ, यह भी लगता है - सीखने की दर और n_epochs के साथ प्रयोग करने के लिए।

और तीसरे के साथ क्या करना है? उत्तर सरल है - नियमितीकरण!

पहले, हमारे पास फ़ॉर्म का नुकसान कार्य था:
अतिरिक्त शर्तों के बिना एल = एमएसई (वाई, वाई)
नियमितीकरण का सार ठीक यही है कि, उद्देश्य फ़ंक्शन में एक शब्द जोड़ते हुए, "ठीक" ग्रेडिएंट यदि यह बहुत बड़ा है। दूसरे शब्दों में, हम अपने उद्देश्य समारोह पर प्रतिबंध लगाते हैं।

कई नियमितीकरण के तरीके हैं। L1 और L2 के बारे में अधिक जानकारी - नियमितीकरण: craftappmobile.com/l1-vs-l2- अनियमितकरण / ##1322

Adagrad विधि L2 नियमितीकरण को लागू करता है, चलो इसे लागू करें!

सबसे पहले, स्पष्टता के लिए, हम नियमितीकरण के बिना मॉडल के संकेतकों को देखते हैं:

lr = 0.01, n_epochs = 500:
हानि = 0.44 ...
सटीकता: 0.71

lr = 0.01, n_epochs = 1000:
हानि = 0.41 ...
सटीकता: 0.75

lr = 0.01, n_epochs = 2000:
हानि = 0.39 ...
सटीकता: 0.75

lr = 0.01, n_epochs = 3000:
हानि = 0.367 ...
सटीकता: 0.76

lr = 0.01, n_epochs = 4000:
हानि = 0.355 ...
सटीकता: 0.72

lr = 0.01, n_epochs = 10000:
हानि = 0.285 ...
सटीकता: 0.69

यहां आप देख सकते हैं कि 4k + युग में - मॉडल पहले से ही ओवरफिट है। अब इससे बचने की कोशिश करते हैं:

ऐसा करने के लिए, हमारे अनुकूलन विधि के लिए weight_decay पैरामीटर जोड़ें:

 optimizer = optim.Adagrad(model.parameters(), lr=lr, weight_decay = 0.001) 

Lr = 0.01 के साथ, m_epochs = 10000:
हानि = 0.367 ...
सटीकता: 0.73

4000 युगों में:
हानि = 0.389 ...
सटीकता: 0.75

यह बहुत बेहतर निकला, लेकिन हमने ऑप्टिमाइज़र में केवल 1 पैरामीटर जोड़ा :)

अब SGDm पर विचार करें (यह एक छोटे से विस्तार के साथ एक स्टोकेस्टिक ढाल वंश है - यदि आप चाहें, तो आंकड़े)।

लब्बोलुआब यह है कि SGD प्रत्येक पुनरावृत्ति के बाद मापदंडों को काफी मजबूती से अपडेट करता है। पिछले पुनरावृत्तियों (जड़ता के विचार) से ग्रेडिएंट का उपयोग करते हुए ढाल को "सुचारू" करना तर्कसंगत होगा:



weight - पैरामीटर (वजन)
ia - जड़ता हाइपरपरमीटर

बिना गति पैरामीटर के



गति पैरामीटर के साथ SGD:



यह बहुत बेहतर नहीं निकला, लेकिन यहां मुद्दा यह है कि ऐसे तरीके हैं जो तुरंत स्केलिंग और जड़ता के विचारों का उपयोग करते हैं। उदाहरण के लिए, एडम या अडाल्टा, जो अब अच्छे परिणाम दिखाते हैं। खैर, इन तरीकों को समझने के लिए, मुझे लगता है कि सरल तरीकों में इस्तेमाल किए जाने वाले कुछ बुनियादी विचारों को समझना आवश्यक है।

ध्यान देने के लिए आप सभी का धन्यवाद!