बाइनरी वर्गीकरण समस्या में लॉगरिदमिक लॉस फंक्शन (लॉगलॉस) के लिए स्टोचैस्टिक ग्रेडिएंट डिसेंट (SGD)

पिछला भाग (लीनियर रिग्रेशन, ग्रेडिएंट डिसेंट और यह सब कैसे काम करता है) के बारे में - habr.com/en/post/471458

इस लेख में, मैं वर्गीकरण समस्या का समाधान पहले दिखाऊंगा, जैसा कि वे कहते हैं, "पेन", बिना थर्ड पार्टी लाइब्रेरी के लिए SGD, लॉगलॉस और ग्रेडिएंट्स की गणना, और फिर PyTorch लाइब्रेरी का उपयोग करना।

उद्देश्य: पीलापन और समरूपता का वर्णन करने वाली दो स्पष्ट विशेषताओं के लिए, यह निर्धारित करें कि ऑब्जेक्ट किस श्रेणी (सेब या नाशपाती) से संबंधित है (ऑब्जेक्ट को वर्गीकृत करने के लिए मॉडल सिखाएं)।

आरंभ करने के लिए, हमारे डेटासेट अपलोड करें:

import pandas as pd data = pd.read_csv("https://raw.githubusercontent.com/DLSchool/dlschool_old/master/materials/homeworks/hw04/data/apples_pears.csv") data.head(10) 

आज्ञा देना: X1 - पीलापन, x2 - समरूपता, y = तार

हम फ़ंक्शन y = w1 * X1 + w2 * x2 + w0 बनाते हैं
(w0 को पूर्वाग्रह माना जाएगा (संलग्न। - पूर्वाग्रह))

अब हमारा काम वज़न w1, w2 और w0 खोजने के लिए कम हो गया है, जो कि X1 और x2 पर y की निर्भरता का सबसे सटीक वर्णन करता है।

हम लघुगणक हानि समारोह का उपयोग करते हैं:



फ़ंक्शन का बायां पैरामीटर वर्तमान भार w1, w2, w0 के साथ भविष्यवाणी है

फ़ंक्शन का सही पैरामीटर सही मान है (वर्ग 0 या 1 है)

σ (x) x का सिग्मॉइड एक्टिवेशन फंक्शन है

log (x) - x का प्राकृतिक लघुगणक

यह स्पष्ट है कि नुकसान फ़ंक्शन का मूल्य जितना छोटा होता है, उतना ही बेहतर है कि हमने वजन 1, डब्ल्यू 2, डब्ल्यू 0 को चुना है। ऐसा करने के लिए, स्टोचैस्टिक ग्रेडिएंट वंश चुनें ।

मैं ध्यान देता हूं कि LogLoss के लिए सूत्र इस तथ्य को ध्यान में रखते हुए एक अलग रूप लेगा कि हम एक तत्व का चयन करते हैं, न कि एक पूरे चयन (या एक सबमिशन, जैसा कि मिनी-बैच ढाल मूल के मामले में):


समाधान प्रगति:

प्रारंभिक भार w1, w2, w0 को यादृच्छिक मान दिए गए हैं

हम अपने डेटासेट के कुछ i-th ऑब्जेक्ट लेते हैं (उदाहरण के लिए, यादृच्छिक), इसके लिए LogLoss की गणना करें (हमारे w1, w2 और w0 के साथ, जिसे हमने शुरू में यादृच्छिक मान सौंपा है), फिर हम प्रत्येक वजन 1, w2 और w0 के लिए आंशिक डेरिवेटिव की गणना करते हैं। फिर प्रत्येक भार को अपडेट करें।

थोड़ी तैयारी:

 import pandas as pd import numpy as np X = data.iloc[:,:2].values #  - y = data['target'].values.reshape((-1, 1)) #  (    ) x1 = X[:, 0] x2 = X[:, 1] def sigmoid(x): return 1 / (1 + np.exp(-x)) 

कार्यान्वयन:

 import random np.random.seed(62) w1 = np.random.randn(1) w2 = np.random.randn(1) w0 = np.random.randn(1) print(w1, w2, w0) # form range 0..999 idx = np.arange(1000) # random shuffling np.random.shuffle(idx) x1, x2, y = x1[idx], x2[idx], y[idx] # learning rate lr = 0.001 # number of epochs n_epochs = 10000 for epoch in range(n_epochs): i = random.randint(0, 999) yhat = w1 * x1[i] + w2 * x2[i] + w0 w1_grad = -((y[i] - sigmoid(yhat)) * x1[i]) w2_grad = -((y[i] - sigmoid(yhat)) * x2[i]) w0_grad = -(y[i] - sigmoid(yhat)) w1 -= lr * w1_grad w2 -= lr * w2_grad w0 -= lr * w0_grad print(w1, w2, w0) 

[0.49671415] [-0.1382643] [0.64768854]
[0.87991625] [-1.14098372] [0.22355905]

* _ग्रेड इसी वजन का व्युत्पन्न है। मैं सामान्य सूत्र लिखूंगा:



मुक्त शब्द w0 के लिए - कारक x को छोड़ दिया जाता है (एक के बराबर लिया जाता है)।

व्युत्पन्न के अंतिम सूत्र का उपयोग करते हुए, हम देख सकते हैं कि हमें नुकसान फ़ंक्शन की स्पष्ट रूप से गणना करने की आवश्यकता नहीं है (हमें केवल आंशिक डेरिवेटिव की आवश्यकता है)।

आइए देखें कि प्रशिक्षण से हमारे ऑब्जेक्ट सेट किए गए कितने ऑब्जेक्ट सही उत्तर देते हैं, और कितने - गलत हैं।

 i = 0 correct = 0 incorrect = 0 for item in y: if(np.around(x1[i] * w1 + x2[i] * w2 + w0) == item): correct += 1 else: incorrect += 1 i = i + 1 print(correct, incorrect) 

925 75

np.ेशन (x) - x के मान को गोल करता है। हमारे लिए: यदि x> 0.5 है, तो मान 1 है। यदि x then 0.5 है, तो मान 0 है।

और वस्तु की सुविधाओं की संख्या 5 होने पर हम क्या करेंगे? 10? 100? और हमारे पास उचित मात्रा में वजन (पूर्वाग्रह के लिए एक प्लस) होगा। यह स्पष्ट है कि प्रत्येक वजन के साथ मैन्युअल रूप से काम करना, इसके लिए ग्रेडिएंट्स की गणना करना असुविधाजनक है।

हम लोकप्रिय PyTorch लाइब्रेरी का उपयोग करेंगे।

PyTorch = NumPy + CUDA + ऑटोग्राद (ग्रेडिएंट्स की स्वचालित गणना)

PyTorch कार्यान्वयन:

 import torch import numpy as np from torch.nn import Linear, Sigmoid 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 X = torch.FloatTensor(data.iloc[:,:2].values) y = torch.FloatTensor(data['target'].values.reshape((-1, 1))) from torch import optim, nn neuron = torch.nn.Sequential( Linear(2, out_features=1), Sigmoid() ) print(neuron.state_dict()) lr = 0.1 n_epochs = 10000 loss_fn = nn.MSELoss(reduction="mean") optimizer = optim.SGD(neuron.parameters(), lr=lr) train_step = make_train_step(neuron, loss_fn, optimizer) for epoch in range(n_epochs): loss = train_step(X, y) print(neuron.state_dict()) print(loss) 

ऑर्डरडीडिक्ट ([(weight ०.वेट ’, टेंसर ([- ०.४१४ -0, ०.०५38३]]])), (), 0.bias’, टेंसर ([०.५४४]])]]]
ऑर्डरडीडिक्ट ([(weight ०.वेट ’, टेंसर ([[५.४ ९ १५, -१.२१५६]])), () ias 0.bias’, टेनॉर ([- १.११३०])]]]
.03930133953690529

परीक्षण नमूने पर काफी अच्छा नुकसान।

यहां, MSELoss को एक हानि फ़ंक्शन के रूप में चुना गया है।

रैखिक पर अधिक

संक्षेप में: हम इनपुट को 2 पैरामीटर देते हैं (हमारे एक्स 1 और एक्स 2 पिछले उदाहरण के अनुसार) और हमें आउटपुट के लिए एक पैरामीटर (वाई) मिलता है, जो बदले में, सक्रियण फ़ंक्शन के इनपुट को खिलाया जाता है। और फिर उन्हें पहले से ही गणना की जाती है: त्रुटि फ़ंक्शन, ग्रेडिएंट्स का मूल्य। अंत में - वजन अपडेट किए जाते हैं।

लेख में प्रयुक्त सामग्री