CNTK - प्रतिगमन मॉडल

यहां, हम प्रतिगमन मॉडल के संबंध में प्रदर्शन को मापने के बारे में अध्ययन करेंगे।

एक प्रतिगमन मॉडल को मान्य करने की मूल बातें

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

यहां, हम विभिन्न त्रुटि दर कार्यों का उपयोग करके प्रतिगमन के लिए उपयोग किए जाने वाले एनएन के प्रदर्शन को मापने जा रहे हैं।

त्रुटि मार्जिन की गणना

जैसा कि पहले चर्चा की गई थी, एक प्रतिगमन मॉडल को मान्य करते समय, हम यह नहीं कह सकते कि कोई भविष्यवाणी सही है या गलत। हम चाहते हैं कि हमारी भविष्यवाणी वास्तविक मूल्य के जितना करीब हो सके। लेकिन, यहां एक छोटी सी त्रुटि मार्जिन स्वीकार्य है।

त्रुटि मार्जिन की गणना करने का सूत्र इस प्रकार है -

यहाँ,

Predicted value = एक टोपी द्वारा संकेत y

Real value = y द्वारा भविष्यवाणी की गई

सबसे पहले, हमें अनुमानित और वास्तविक मूल्य के बीच की दूरी की गणना करने की आवश्यकता है। फिर, एक समग्र त्रुटि दर प्राप्त करने के लिए, हमें इन चुकता दूरी को योग करने और औसत की गणना करने की आवश्यकता है। इसे कहते हैंmean squared त्रुटि समारोह।

लेकिन, यदि हम प्रदर्शन के आंकड़े चाहते हैं जो एक त्रुटि मार्जिन व्यक्त करते हैं, तो हमें एक सूत्र की आवश्यकता होती है जो पूर्ण त्रुटि को व्यक्त करता है। के लिए सूत्रmean absolute त्रुटि समारोह इस प्रकार है -

उपर्युक्त सूत्र अनुमानित और वास्तविक मूल्य के बीच की पूर्ण दूरी तय करता है।

प्रतिगमन प्रदर्शन को मापने के लिए CNTK का उपयोग करना

यहां, हम देखेंगे कि विभिन्न मैट्रिक्स का उपयोग कैसे करें, हमने CNTK के साथ संयोजन में चर्चा की। हम एक प्रतिगमन मॉडल का उपयोग करेंगे, जो नीचे दिए गए चरणों का उपयोग करके कारों के लिए मील प्रति गैलन की भविष्यवाणी करता है।

क्रियान्वयन चरण−

Step 1 - सबसे पहले, हमें आवश्यक घटकों को आयात करना होगा cntk पैकेज निम्नानुसार है -

from cntk import default_option, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import relu

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

with default_options(activation=relu):
model = Sequential([Dense(64),Dense(64),Dense(1,activation=None)])

Step 3- नेटवर्क बन जाने के बाद, हमें एक इनपुट फीचर बनाने की जरूरत है। हमें यह सुनिश्चित करने की आवश्यकता है कि, इसमें वैसी ही विशेषताएं हैं जैसी कि हम प्रशिक्षण के लिए उपयोग करने जा रहे हैं।

features = input_variable(X.shape[1])

Step 4 - अब, हमें एक और बनाने की आवश्यकता है input_variable आकार के साथ 1. इसका उपयोग एनएन के लिए अपेक्षित मूल्य को संग्रहीत करने के लिए किया जाएगा।

target = input_variable(1)
z = model(features)

अब, हमें मॉडल को प्रशिक्षित करने की आवश्यकता है और ऐसा करने के लिए, हम डेटासेट को विभाजित करने और निम्नलिखित कार्यान्वयन चरणों का उपयोग करके प्रीप्रोसेसिंग करने जा रहे हैं -

Step 5LFirst, -1 और +1 के बीच मान प्राप्त करने के लिए sklearn.preprocessing से StandardScaler आयात करें। इससे हमें NN में धीरे-धीरे होने वाली समस्याओं का पता लगाने में मदद मिलेगी।

from sklearn.preprocessing import StandardScalar

Step 6 - इसके बाद, sklearn.model_selection से निम्न के रूप में import_test_split आयात करें

from sklearn.model_selection import train_test_split

Step 7 - ड्रॉप करें mpg का उपयोग करके डेटासेट से स्तंभ dropतरीका। अंतिम बार डेटासेट का उपयोग करके एक प्रशिक्षण और सत्यापन सेट में विभाजित करेंtrain_test_split कार्य निम्नानुसार है -

x = df_cars.drop(columns=[‘mpg’]).values.astype(np.float32)
y=df_cars.iloc[: , 0].values.reshape(-1, 1).astype(np.float32)
scaler = StandardScaler()
X = scaler.fit_transform(x)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Step 8 - अब, हमें आकार के साथ एक और input_variable बनाने की आवश्यकता है। इसका उपयोग NN के लिए अपेक्षित मान को संग्रहीत करने के लिए किया जाएगा।

target = input_variable(1)
z = model(features)

हमने डेटा को प्रीप्रोसेस करने के साथ-साथ विभाजित किया है, अब हमें एनएन को प्रशिक्षित करने की आवश्यकता है। जैसा कि प्रतिगमन मॉडल बनाते समय पिछले वर्गों में किया गया था, हमें नुकसान के संयोजन को परिभाषित करने की आवश्यकता है औरmetric मॉडल को प्रशिक्षित करने के लिए कार्य करते हैं।

import cntk
def absolute_error(output, target):
   return cntk.ops.reduce_mean(cntk.ops.abs(output – target))
@ cntk.Function
def criterion_factory(output, target):
   loss = squared_error(output, target)
   metric = absolute_error(output, target)
   return loss, metric

अब, आइए नजर डालें कि प्रशिक्षित मॉडल का उपयोग कैसे करें। हमारे मॉडल के लिए, हम नुकसान और मीट्रिक संयोजन के रूप में मानदंड_सक्रिय का उपयोग करेंगे।

from cntk.losses import squared_error
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_printer = ProgressPrinter(0)
loss = criterion_factory (z, target)
learner = sgd(z.parameters, 0.001)
training_summary=loss.train((x_train,y_train),parameter_learners=[learner],callbacks=[progress_printer],minibatch_size=16,max_epochs=10)

पूरा कार्यान्वयन उदाहरण

from cntk import default_option, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import relu
with default_options(activation=relu):
model = Sequential([Dense(64),Dense(64),Dense(1,activation=None)])
features = input_variable(X.shape[1])
target = input_variable(1)
z = model(features)
from sklearn.preprocessing import StandardScalar
from sklearn.model_selection import train_test_split
x = df_cars.drop(columns=[‘mpg’]).values.astype(np.float32)
y=df_cars.iloc[: , 0].values.reshape(-1, 1).astype(np.float32)
scaler = StandardScaler()
X = scaler.fit_transform(x)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
target = input_variable(1)
z = model(features)
import cntk
def absolute_error(output, target):
   return cntk.ops.reduce_mean(cntk.ops.abs(output – target))
@ cntk.Function
def criterion_factory(output, target):
loss = squared_error(output, target)
metric = absolute_error(output, target)
return loss, metric
from cntk.losses import squared_error
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_printer = ProgressPrinter(0)
loss = criterion_factory (z, target)
learner = sgd(z.parameters, 0.001)
training_summary=loss.train((x_train,y_train),parameter_learners=[learner],callbacks=[progress_printer],minibatch_size=16,max_epochs=10)

उत्पादन

-------------------------------------------------------------------
average  since   average   since  examples
loss     last    metric    last
------------------------------------------------------
Learning rate per minibatch: 0.001
690       690     24.9     24.9       16
654       636     24.1     23.7       48
[………]

हमारे प्रतिगमन मॉडल को मान्य करने के लिए, हमें यह सुनिश्चित करने की आवश्यकता है कि, मॉडल नए डेटा को संभालता है और साथ ही साथ यह प्रशिक्षण डेटा के साथ भी करता है। इसके लिए हमें इनवाइट करना होगाtest पर विधि loss तथा metric परीक्षण डेटा के साथ संयोजन निम्नानुसार है -

loss.test([X_test, y_test])

आउटपुट

{'metric': 1.89679785619, 'samples': 79}