CNTK - तंत्रिका नेटवर्क प्रतिगमन

अध्याय CNTK के संबंध में तंत्रिका नेटवर्क प्रतिगमन को समझने में आपकी सहायता करेगा।

परिचय

जैसा कि हम जानते हैं कि, एक या एक से अधिक भविष्यवाणियों के संख्यात्मक मान का अनुमान लगाने के लिए, हम प्रतिगमन का उपयोग करते हैं। आइए 100 शहरों में से एक में एक घर के औसत मूल्य की भविष्यवाणी करने का एक उदाहरण लेते हैं। ऐसा करने के लिए, हमारे पास डेटा शामिल है -

  • प्रत्येक शहर के लिए एक अपराध आँकड़ा।

  • प्रत्येक शहर में घरों की उम्र।

  • प्रत्येक शहर से एक प्रमुख स्थान की दूरी का एक उपाय।

  • प्रत्येक कस्बे में छात्र से शिक्षक अनुपात।

  • प्रत्येक शहर के लिए एक जातीय जनसांख्यिकीय।

  • प्रत्येक शहर में मंझला घर का मूल्य।

इन पांच भविष्यवक्ता चर के आधार पर, हम मंझला गृह मूल्य की भविष्यवाणी करना चाहते हैं। और इसके लिए हम − की तर्ज पर एक रेखीय प्रतिगमन मॉडल बना सकते हैं

Y = a0+a1(crime)+a2(house-age)+(a3)(distance)+(a4)(ratio)+(a5)(racial)

उपरोक्त समीकरण में -

Y एक अनुमानित औसत मूल्य है

a0 एक स्थिर और है

a1 के माध्यम से a5 सभी स्थिरांक हैं, जिन पाँच भविष्यवक्ताओं के साथ हम ऊपर चर्चा कर चुके हैं।

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

यहां, हम CNTK का उपयोग करके एक तंत्रिका नेटवर्क प्रतिगमन मॉडल बना रहे हैं।

डेटासेट लोड हो रहा है

CNTK का उपयोग करके न्यूरल नेटवर्क रिग्रेशन को लागू करने के लिए, हम बोस्टन एरिया हाउस वैल्यू डेटासेट का उपयोग करेंगे। डेटासेट को UCI मशीन लर्निंग रिपॉजिटरी से डाउनलोड किया जा सकता है, जो यहां उपलब्ध हैhttps://archive.ics.uci.edu/ml/machine-learning-databases/housing/। इस डाटासेट में कुल 14 चर और 506 उदाहरण हैं।

लेकिन, हमारे कार्यान्वयन कार्यक्रम के लिए हम 14 चर और 100 उदाहरणों में से छह का उपयोग करने जा रहे हैं। 6 में से 5, भविष्यवक्ता के रूप में और एक मूल्य-से-पूर्वानुमान के रूप में। 100 उदाहरणों से, हम प्रशिक्षण के लिए 80 और परीक्षण उद्देश्य के लिए 20 का उपयोग करेंगे। जिस मूल्य की हम भविष्यवाणी करना चाहते हैं वह एक शहर में मंझला घर की कीमत है। आइए देखते हैं पांच भविष्यवक्ता जिनका हम उपयोग करेंगे -

  • Crime per capita in the town - हम उम्मीद करेंगे कि छोटे भविष्यवक्ता इस भविष्यवक्ता से जुड़े होंगे।

  • Proportion of owner - 1940 से पहले निर्मित कब्जे वाली इकाइयाँ - हम उम्मीद करेंगे कि छोटे मूल्य इस भविष्यवक्ता से जुड़े होंगे क्योंकि बड़े मूल्य का मतलब पुराने घर से है।

  • Weighed distance of the town to five Boston employment centers.

  • Area school pupil-to-teacher ratio.

  • An indirect metric of the proportion of black residents in the town.

प्रशिक्षण और परीक्षण फाइलें तैयार करना

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

|predictors 1.612820 96.90 3.76 21.00 248.31 |medval 13.50
|predictors 0.064170 68.20 3.36 19.20 396.90 |medval 18.90
|predictors 0.097440 61.40 3.38 19.20 377.56 |medval 20.00
. . .

अगले 20 आइटम, जिसे CNTK प्रारूप में भी परिवर्तित किया गया है, का उपयोग परीक्षण उद्देश्य के लिए किया जाएगा।

प्रतिगमन मॉडल का निर्माण

सबसे पहले, हमें डेटा फ़ाइलों को CNTK प्रारूप में संसाधित करने की आवश्यकता है और उसके लिए, हम नामांकित सहायक फ़ंक्शन का उपयोग करने जा रहे हैं create_reader निम्नानुसार है -

def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='predictors', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='medval', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_src

अगला, हमें एक सहायक फ़ंक्शन बनाने की आवश्यकता है जो CNTK मिनी-बैच ऑब्जेक्ट को स्वीकार करता है और एक कस्टम सटीकता मीट्रिक की गणना करता है।

def mb_accuracy(mb, x_var, y_var, model, delta):
   num_correct = 0
   num_wrong = 0
   x_mat = mb[x_var].asarray()
   y_mat = mb[y_var].asarray()
for i in range(mb[x_var].shape[0]):
  v = model.eval(x_mat[i])
  y = y_mat[i]
if np.abs(v[0,0] – y[0,0]) < delta:
   num_correct += 1
else:
   num_wrong += 1
return (num_correct * 100.0)/(num_correct + num_wrong)

अब, हमें अपने एनएन के लिए आर्किटेक्चर तर्क निर्धारित करने की आवश्यकता है और डेटा फ़ाइलों का स्थान भी प्रदान करना चाहिए। यह निम्नलिखित अजगर कोड की मदद से किया जा सकता है -

def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 5
hidden_dim = 20
output_dim = 1
train_file = ".\\...\\" #provide the name of the training file(80 data items)
test_file = ".\\...\\" #provide the name of the test file(20 data items)

अब निम्नलिखित कोड लाइन की मदद से हमारा कार्यक्रम अप्रशिक्षित एनएन बनाएगा -

X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
model = C.ops.alias(oLayer)

अब, जब हमने दोहरी अप्रशिक्षित मॉडल बनाया है, तो हमें एक लर्नर एल्गोरिथम ऑब्जेक्ट सेट करने की आवश्यकता है। हम SGD शिक्षार्थी और उपयोग करने जा रहे हैंsquared_error हानि समारोह -

tr_loss = C.squared_error(model, Y)
max_iter = 3000
batch_size = 5
base_learn_rate = 0.02
sch=C.learning_parameter_schedule([base_learn_rate, base_learn_rate/2], minibatch_size=batch_size, epoch_size=int((max_iter*batch_size)/2))
learner = C.sgd(model.parameters, sch)
trainer = C.Trainer(model, (tr_loss), [learner])

अब, एक बार जब हम लर्निंग एल्गोरिथम ऑब्जेक्ट के साथ समाप्त हो जाते हैं, तो हमें प्रशिक्षण डेटा को पढ़ने के लिए एक रीडर फ़ंक्शन बनाने की आवश्यकता है -

rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }

अब, हमारे एनएन मॉडल को प्रशिक्षित करने का समय आ गया है -

for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=boston_input_map) trainer.train_minibatch(curr_batch)
if i % int(max_iter/10) == 0:
mcee = trainer.previous_minibatch_loss_average
acc = mb_accuracy(curr_batch, X, Y, model, delta=3.00)
print("batch %4d: mean squared error = %8.4f, accuracy = %5.2f%% " \ % (i, mcee, acc))

एक बार जब हमने प्रशिक्षण के साथ कर लिया है, तो आइए परीक्षण डेटा आइटम का उपयोग करके मॉडल का मूल्यांकन करें -

print("\nEvaluating test data \n")
rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=boston_input_map)
acc = mb_accuracy(all_test, X, Y, model, delta=3.00)
print("Prediction accuracy = %0.2f%%" % acc)

हमारे प्रशिक्षित एनएन मॉडल की सटीकता का मूल्यांकन करने के बाद, हम इसका उपयोग अनदेखी डेटा पर एक भविष्यवाणी करने के लिए करेंगे -

np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])

पूर्ण प्रतिगमन मॉडल

import numpy as np
import cntk as C
def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='predictors', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='medval', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_src
def mb_accuracy(mb, x_var, y_var, model, delta):
num_correct = 0
num_wrong = 0
x_mat = mb[x_var].asarray()
y_mat = mb[y_var].asarray()
for i in range(mb[x_var].shape[0]):
   v = model.eval(x_mat[i])
   y = y_mat[i]
if np.abs(v[0,0] – y[0,0]) < delta:
   num_correct += 1
else:
   num_wrong += 1
return (num_correct * 100.0)/(num_correct + num_wrong)
def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 5
hidden_dim = 20
output_dim = 1
train_file = ".\\...\\" #provide the name of the training file(80 data items)
test_file = ".\\...\\" #provide the name of the test file(20 data items)
X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
model = C.ops.alias(oLayer)
tr_loss = C.squared_error(model, Y)
max_iter = 3000
batch_size = 5
base_learn_rate = 0.02
sch = C.learning_parameter_schedule([base_learn_rate, base_learn_rate/2], minibatch_size=batch_size, epoch_size=int((max_iter*batch_size)/2))
learner = C.sgd(model.parameters, sch)
trainer = C.Trainer(model, (tr_loss), [learner])
rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=boston_input_map) trainer.train_minibatch(curr_batch)
if i % int(max_iter/10) == 0:
   mcee = trainer.previous_minibatch_loss_average
   acc = mb_accuracy(curr_batch, X, Y, model, delta=3.00)
   print("batch %4d: mean squared error = %8.4f, accuracy = %5.2f%% " \ % (i, mcee, acc))
   print("\nEvaluating test data \n")
   rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
   boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
   num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=boston_input_map)
acc = mb_accuracy(all_test, X, Y, model, delta=3.00)
print("Prediction accuracy = %0.2f%%" % acc)
np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])
if __name__== ”__main__”:
   main()

उत्पादन

Using CNTK version = 2.7
batch 0: mean squared error = 385.6727, accuracy = 0.00%
batch 300: mean squared error = 41.6229, accuracy = 20.00%
batch 600: mean squared error = 28.7667, accuracy = 40.00%
batch 900: mean squared error = 48.6435, accuracy = 40.00%
batch 1200: mean squared error = 77.9562, accuracy = 80.00%
batch 1500: mean squared error = 7.8342, accuracy = 60.00%
batch 1800: mean squared error = 47.7062, accuracy = 60.00%
batch 2100: mean squared error = 40.5068, accuracy = 40.00%
batch 2400: mean squared error = 46.5023, accuracy = 40.00%
batch 2700: mean squared error = 15.6235, accuracy = 60.00%
Evaluating test data
Prediction accuracy = 64.00%
Predicting median home value for feature/predictor values:
[0.09 50. 4.5 17. 350.]
Predicted value is:
$21.02(x1000)

प्रशिक्षित मॉडल को सहेजना

इस बोस्टन होम वैल्यू डेटासेट में केवल 506 डेटा आइटम हैं (जिनमें से हमने केवल 100 पर मुकदमा किया है)। इसलिए, एनएन रजिस्ट्रार मॉडल को प्रशिक्षित करने में केवल कुछ सेकंड लगते हैं, लेकिन सौ या हजार डेटा आइटम वाले बड़े डेटासेट पर प्रशिक्षण में घंटे या दिन भी लग सकते हैं।

हम अपने मॉडल को बचा सकते हैं, ताकि हमें इसे खरोंच से बचाना न पड़े। निम्नलिखित पायथन कोड की मदद से, हम अपने प्रशिक्षित एनएन को बचा सकते हैं -

nn_regressor = “.\\neuralregressor.model” #provide the name of the file
model.save(nn_regressor, format=C.ModelFormat.CNTKv2)

ऊपर दिए गए save () फ़ंक्शन के तर्क निम्नलिखित हैं -

  • फ़ाइल नाम का पहला तर्क है save()समारोह। यह फ़ाइल के पथ के साथ भी लिखा जा सकता है।

  • एक और पैरामीटर है format पैरामीटर जिसमें एक डिफ़ॉल्ट मान है C.ModelFormat.CNTKv2।

प्रशिक्षित मॉडल लोड हो रहा है

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

import numpy as np
import cntk as C
model = C.ops.functions.Function.load(“.\\neuralregressor.model”)
np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting area median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])

सहेजे गए मॉडल का लाभ यह है कि एक बार जब आप सहेजे गए मॉडल को लोड करते हैं, तो इसका ठीक उसी तरह उपयोग किया जा सकता है जैसे कि मॉडल को अभी प्रशिक्षित किया गया था।

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved