CNTK - आउट-ऑफ-मेमोरी डेटासेट्स

इस अध्याय में, आउट-ऑफ-मेमोरी डेटासेट के प्रदर्शन को कैसे मापें, इसके बारे में बताया जाएगा।

पिछले वर्गों में, हमने अपने एनएन के प्रदर्शन को मान्य करने के लिए विभिन्न तरीकों के बारे में चर्चा की है, लेकिन जिन तरीकों पर हमने चर्चा की है, वे ऐसे डेटासेट्स हैं जो मेमोरी में फिट होते हैं।

यहां, यह सवाल उठता है कि आउट-ऑफ-मेमोरी डेटासेट के बारे में क्या है, क्योंकि उत्पादन परिदृश्य में, हमें प्रशिक्षित करने के लिए बहुत सारे डेटा की आवश्यकता होती है NN। इस खंड में, हम चर्चा करने के लिए जा रहे हैं कि मिनीबच स्रोतों और मैनुअल मिनीबैच लूप के साथ काम करते समय प्रदर्शन को कैसे मापें।

न्यूनतम स्रोत

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

निम्नलिखित कार्यान्वयन चरण हैं

Step 1 - पहला, से cntk.आईआईओ मॉड्यूल निम्नानुसार मिनीबच स्रोत बनाने के लिए घटकों को आयात करता है

from cntk.io import StreamDef, StreamDefs, MinibatchSource, CTFDeserializer,
 INFINITY_REPEAT

Step 2 - इसके बाद एक नया फंक्शन बनाएं जिसका नाम है create_datasource। इस फ़ंक्शन में फ़ाइल नाम और सीमा दो मानदंड होंगे, डिफ़ॉल्ट मान के साथINFINITELY_REPEAT।

def create_datasource(filename, limit =INFINITELY_REPEAT)

Step 3 - अब, फ़ंक्शन के भीतर, का उपयोग करके StreamDefक्लास उन लेबलों के लिए एक स्ट्रीम परिभाषा बनाता है जो उन लेबल फ़ील्ड से पढ़ते हैं जिनमें तीन सुविधाएँ होती हैं। हमें भी सेट करने की जरूरत हैis_sparse सेवा False इस प्रकार

labels_stream = StreamDef(field=’labels’, shape=3, is_sparse=False)

Step 4 - इसके बाद, इनपुट फ़ाइल से दर्ज की गई विशेषताओं को पढ़ने के लिए बनाएं, का एक और उदाहरण बनाएं StreamDef निम्नलिखित नुसार।

feature_stream = StreamDef(field=’features’, shape=4, is_sparse=False)

Step 5 - अब, इनिशियलाइज़ करें CTFDeserializerउदाहरण वर्ग। फ़ाइल नाम और स्ट्रीम निर्दिष्ट करें जिन्हें हमें निम्नानुसार चित्रित करने की आवश्यकता है -

deserializer = CTFDeserializer(filename, StreamDefs(labels=
label_stream, features=features_stream)

Step 6 - इसके बाद, हमें desisializer का उपयोग करके minisourceBatch का उदाहरण बनाने की आवश्यकता है -

Minibatch_source = MinibatchSource(deserializer, randomize=True, max_sweeps=limit)
return minibatch_source

Step 7- अंत में, हमें प्रशिक्षण और परीक्षण स्रोत प्रदान करना होगा, जिसे हमने पिछले खंडों में भी बनाया था। हम आईरिस फूल डेटासेट का उपयोग कर रहे हैं।

training_source = create_datasource(‘Iris_train.ctf’)
test_source = create_datasource(‘Iris_test.ctf’, limit=1)

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

निम्नलिखित कार्यान्वयन चरण हैं

Step 1 - प्रशिक्षण सत्र के उत्पादन में प्रवेश करने के लिए, पहले आयात करें ProgressPrinter से cntk.logging मॉड्यूल इस प्रकार है -

from cntk.logging import ProgressPrinter

Step 2 - अगला, प्रशिक्षण सत्र स्थापित करने के लिए, आयात करें trainer तथा training_session से cntk.train मॉड्यूल निम्नानुसार है

from cntk.train import Trainer, training_session

Step 3 - अब, हमें स्थिरांक के कुछ सेट को परिभाषित करने की आवश्यकता है minibatch_size, samples_per_epoch तथा num_epochs इस प्रकार

minbatch_size = 16
samples_per_epoch = 150
num_epochs = 30
max_samples = samples_per_epoch * num_epochs

Step 4 - अगला, सीएनटीके में प्रशिक्षण के दौरान डेटा को पढ़ने के तरीके को जानने के लिए, हमें नेटवर्क के लिए इनपुट चर और मिनीबैच स्रोत में धाराओं के बीच एक मानचित्रण को परिभाषित करने की आवश्यकता है।

input_map = {
   features: training_source.streams.features,
   labels: training_source.streams.labels
}

Step 5 - प्रशिक्षण प्रक्रिया के आउटपुट को लॉग इन करने के लिए अगला, आरंभ करें progress_printer एक नया के साथ चर ProgressPrinterउदाहरण। इसके अलावा, इनिशियलाइज़ करेंtrainer और इसे निम्नानुसार मॉडल प्रदान करें

progress_writer = ProgressPrinter(0)
trainer: training_source.streams.labels

Step 6 - अंत में, प्रशिक्षण प्रक्रिया शुरू करने के लिए, हमें इनवॉइस करने की आवश्यकता है training_session कार्य निम्नानुसार है -

session = training_session(trainer,
   mb_source=training_source,
   mb_size=minibatch_size,
   model_inputs_to_streams=input_map,
   max_samples=max_samples,
   test_config=test_config)
session.train()

एक बार जब हम मॉडल को प्रशिक्षित कर लेते हैं, तो हम इस सेटअप को एक का उपयोग करके सत्यापन जोड़ सकते हैं TestConfig ऑब्जेक्ट और इसे असाइन करें test_config के खोजशब्द तर्क train_session समारोह।

निम्नलिखित कार्यान्वयन चरण हैं

Step 1 - सबसे पहले, हमें आयात करने की आवश्यकता है TestConfig मॉड्यूल से वर्ग cntk.train इस प्रकार

from cntk.train import TestConfig

Step 2 - अब, हमें एक नया उदाहरण बनाने की आवश्यकता है TestConfig उसके साथ test_source input as के रूप में

Test_config = TestConfig(test_source)

पूरा उदाहरण

from cntk.io import StreamDef, StreamDefs, MinibatchSource, CTFDeserializer, INFINITY_REPEAT
def create_datasource(filename, limit =INFINITELY_REPEAT)
labels_stream = StreamDef(field=’labels’, shape=3, is_sparse=False)
feature_stream = StreamDef(field=’features’, shape=4, is_sparse=False)
deserializer = CTFDeserializer(filename, StreamDefs(labels=label_stream, features=features_stream)
Minibatch_source = MinibatchSource(deserializer, randomize=True, max_sweeps=limit)
return minibatch_source
training_source = create_datasource(‘Iris_train.ctf’)
test_source = create_datasource(‘Iris_test.ctf’, limit=1)
from cntk.logging import ProgressPrinter
from cntk.train import Trainer, training_session
minbatch_size = 16
samples_per_epoch = 150
num_epochs = 30
max_samples = samples_per_epoch * num_epochs
input_map = {
   features:   training_source.streams.features,
   labels: training_source.streams.labels
 }
progress_writer = ProgressPrinter(0)
trainer: training_source.streams.labels
session = training_session(trainer,
   mb_source=training_source,
   mb_size=minibatch_size,
   model_inputs_to_streams=input_map,
   max_samples=max_samples,
   test_config=test_config)
session.train()
from cntk.train import TestConfig
Test_config = TestConfig(test_source)

उत्पादन

-------------------------------------------------------------------
average   since   average   since  examples
loss      last    metric    last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.57      1.57     0.214    0.214   16
1.38      1.28     0.264    0.289   48
[………]
Finished Evaluation [1]: Minibatch[1-1]:metric = 69.65*30;

मैनुअल मिनीबैच लूप

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

यहां, हम नीचे दिए गए मॉडल का उपयोग कर रहे हैं, पिछले इनपुट्स में भी बनाए गए Iris Flower डेटासेट से 4 इनपुट और 3 आउटपुट के साथ

from cntk import default_options, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import log_softmax, relu, sigmoid
from cntk.learners import sgd
model = Sequential([
   Dense(4, activation=sigmoid),
   Dense(3, activation=log_softmax)
])
features = input_variable(4)
labels = input_variable(3)
z = model(features)

अगला, मॉडल के लिए नुकसान को क्रॉस-एन्ट्रापी लॉस फ़ंक्शन के संयोजन के रूप में परिभाषित किया गया है, और एफ-माप मीट्रिक जैसा कि पिछले वर्गों में उपयोग किया गया है। हम इसका उपयोग करने जा रहे हैंcriterion_factory उपयोगिता, इसे CNTK फ़ंक्शन ऑब्जेक्ट के रूप में बनाने के लिए जैसा कि नीचे दिखाया गया है

import cntk
from cntk.losses import cross_entropy_with_softmax, fmeasure
@cntk.Function
def criterion_factory(outputs, targets):
   loss = cross_entropy_with_softmax(outputs, targets)
   metric = fmeasure(outputs, targets, beta=1)
   return loss, metric
loss = criterion_factory(z, labels)
learner = sgd(z.parameters, 0.1)
label_mapping = {
   'Iris-setosa': 0,
   'Iris-versicolor': 1,
   'Iris-virginica': 2
}

अब, जैसा कि हमने नुकसान फ़ंक्शन को परिभाषित किया है, हम देखेंगे कि हम ट्रेनर में इसका उपयोग कैसे कर सकते हैं, एक मैनुअल प्रशिक्षण सत्र स्थापित करने के लिए।

कार्यान्वयन चरण निम्नलिखित हैं -

Step 1 - पहले, हमें आवश्यक पैकेजों को आयात करना होगा numpy तथा pandas डेटा को लोड और प्रीप्रोसेस करना।

import pandas as pd
import numpy as np

Step 2 - अगला, प्रशिक्षण के दौरान जानकारी लॉग करने के लिए, आयात करें ProgressPrinter निम्नानुसार वर्ग

from cntk.logging import ProgressPrinter

Step 3 - फिर, हमें cntk.train मॉड्यूल से ट्रेनर मॉड्यूल को निम्नानुसार आयात करना होगा -

from cntk.train import Trainer

Step 4 - अगला, का एक नया उदाहरण बनाएँ ProgressPrinter निम्नानुसार है -

progress_writer = ProgressPrinter(0)

Step 5 - अब, हमें नुकसान, सीखने वाले और मापदंडों के साथ ट्रेनर को इनिशियलाइज़ करना होगा progress_writer निम्नानुसार है -

trainer = Trainer(z, loss, learner, progress_writer)

Step 6WeNext, मॉडल को प्रशिक्षित करने के लिए, हम एक लूप बनाएंगे जो तीस बार डेटासेट पर प्रसारित होगा। यह बाहरी प्रशिक्षण लूप होगा।

for _ in range(0,30):

Step 7- अब, हमें पंडों का उपयोग करके डिस्क से डेटा लोड करने की आवश्यकता है। फिर, डाटासेट को लोड करने के लिएmini-batches, ठीक chunksize कीवर्ड तर्क 16 के लिए।

input_data = pd.read_csv('iris.csv',
names=['sepal_length', 'sepal_width','petal_length','petal_width', 'species'],
index_col=False, chunksize=16)

Step 8 - अब, लूप के लिए एक आंतरिक प्रशिक्षण बनाएं mini-batches।

for df_batch in input_data:

Step 9 - अब इस लूप के अंदर, पहले चार कॉलम को पढ़ें iloc अनुक्रमणिका, के रूप में features से ट्रेन करने के लिए और उन्हें float32 में बदलने के लिए -

feature_values = df_batch.iloc[:,:4].values
feature_values = feature_values.astype(np.float32)

Step 10 - अब, अंतिम कॉलम को पढ़े जाने वाले लेबल के रूप में निम्नानुसार पढ़ें -

label_values = df_batch.iloc[:,-1]

Step 11 - अगला, हम एक-गर्म वैक्टर का उपयोग लेबल स्ट्रिंग्स को उनकी संख्यात्मक प्रस्तुति में परिवर्तित करने के लिए निम्नानुसार करेंगे -

label_values = label_values.map(lambda x: label_mapping[x])

Step 12- उसके बाद, लेबलों की सांख्यिक प्रस्तुति लें। इसके बाद, उन्हें एक सुपीरियर सरणी में बदलें, इसलिए उनके साथ काम करना आसान है -

label_values = label_values.values

Step 13 - अब, हमें एक नई संख्या बनाने की आवश्यकता है जिसमें लेबल मानों के समान पंक्तियाँ हैं जिन्हें हमने परिवर्तित किया है।

encoded_labels = np.zeros((label_values.shape[0], 3))

Step 14 - अब, एक-हॉट एन्कोडेड लेबल बनाने के लिए, संख्यात्मक लेबल मानों के आधार पर कॉलम चुनें।

encoded_labels[np.arange(label_values.shape[0]), label_values] = 1.

Step 15 - अंत में, हमें आह्वान करने की आवश्यकता है train_minibatch ट्रेनर पर विधि और मिनीबैच के लिए संसाधित फीचर्स और लेबल प्रदान करें।

trainer.train_minibatch({features: feature_values, labels: encoded_labels})

पूरा उदाहरण

from cntk import default_options, input_variable
from cntk.layers import Dense, Sequential
from cntk.ops import log_softmax, relu, sigmoid
from cntk.learners import sgd
model = Sequential([
   Dense(4, activation=sigmoid),
   Dense(3, activation=log_softmax)
])
features = input_variable(4)
labels = input_variable(3)
z = model(features)
import cntk
from cntk.losses import cross_entropy_with_softmax, fmeasure
@cntk.Function
def criterion_factory(outputs, targets):
   loss = cross_entropy_with_softmax(outputs, targets)
   metric = fmeasure(outputs, targets, beta=1)
   return loss, metric
loss = criterion_factory(z, labels)
learner = sgd(z.parameters, 0.1)
label_mapping = {
   'Iris-setosa': 0,
   'Iris-versicolor': 1,
   'Iris-virginica': 2
}
import pandas as pd
import numpy as np
from cntk.logging import ProgressPrinter
from cntk.train import Trainer
progress_writer = ProgressPrinter(0)
trainer = Trainer(z, loss, learner, progress_writer)
for _ in range(0,30):
   input_data = pd.read_csv('iris.csv',
      names=['sepal_length', 'sepal_width','petal_length','petal_width', 'species'],
      index_col=False, chunksize=16)
for df_batch in input_data:
   feature_values = df_batch.iloc[:,:4].values
   feature_values = feature_values.astype(np.float32)
   label_values = df_batch.iloc[:,-1]
label_values = label_values.map(lambda x: label_mapping[x])
label_values = label_values.values
   encoded_labels = np.zeros((label_values.shape[0], 3))
   encoded_labels[np.arange(label_values.shape[0]), 
label_values] = 1.
   trainer.train_minibatch({features: feature_values, labels: encoded_labels})

उत्पादन

-------------------------------------------------------------------
average    since    average   since  examples
loss       last      metric   last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.45       1.45     -0.189    -0.189   16
1.24       1.13     -0.0382    0.0371  48
[………]

उपरोक्त आउटपुट में, हमें प्रशिक्षण के दौरान नुकसान और मीट्रिक दोनों के लिए आउटपुट मिला। ऐसा इसलिए है क्योंकि हमने एक फ़ंक्शन ऑब्जेक्ट में एक मीट्रिक और हानि को संयोजित किया और ट्रेनर कॉन्फ़िगरेशन में प्रगति प्रिंटर का उपयोग किया।

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

from cntk import Evaluator
evaluator = Evaluator(loss.outputs[1], [progress_writer])
input_data = pd.read_csv('iris.csv',
   names=['sepal_length', 'sepal_width','petal_length','petal_width', 'species'],
index_col=False, chunksize=16)
for df_batch in input_data:
   feature_values = df_batch.iloc[:,:4].values
   feature_values = feature_values.astype(np.float32)
   label_values = df_batch.iloc[:,-1]
   label_values = label_values.map(lambda x: label_mapping[x])
   label_values = label_values.values
   encoded_labels = np.zeros((label_values.shape[0], 3))
   encoded_labels[np.arange(label_values.shape[0]), label_values] = 1.
   evaluator.test_minibatch({ features: feature_values, labels:
      encoded_labels})
evaluator.summarize_test_progress()

अब, हम आउटपुट को निम्न की तरह कुछ प्राप्त करेंगे

उत्पादन

Finished Evaluation [1]: Minibatch[1-11]:metric = 74.62*143;