CNTK - इन-मेमोरी और बड़े डेटासेट

इस अध्याय में, हम CNTK में इन-मेमोरी और बड़े डेटासेट के साथ काम करने के तरीके के बारे में जानेंगे।

स्मृति डेटासेट में छोटे के साथ प्रशिक्षण

जब हम CNTK ट्रेनर में डेटा फीड करने की बात करते हैं, तो कई तरीके हो सकते हैं, लेकिन यह डेटा के डेटासेट और प्रारूप के आकार पर निर्भर करेगा। डेटा सेट छोटे इन-मेमोरी या बड़े डेटासेट हो सकते हैं।

इस खंड में, हम इन-मेमोरी डेटासेट के साथ काम करने जा रहे हैं। इसके लिए, हम निम्नलिखित दो रूपरेखाओं का उपयोग करेंगे -

• Numpy
• Pandas

Numpy सरणियों का उपयोग करना

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

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

इसके लिए, पहले हमें लेबल का एक सेट उत्पन्न करना चाहिए जिसमें लेबल के एक-गर्म वेक्टर प्रतिनिधित्व होता है, हम भविष्यवाणी करना चाहते हैं। इसे निम्नलिखित चरणों की सहायता से किया जा सकता है -

Step 1 - आयात करें numpy पैकेज निम्नानुसार है -

import numpy as np
num_samples = 20000

Step 2 - इसके बाद, उपयोग करके एक लेबल मैपिंग जनरेट करें np.eye कार्य निम्नानुसार है -

label_mapping = np.eye(2)

Step 3 - अब उपयोग करके np.random.choice फ़ंक्शन, 20000 यादृच्छिक नमूने निम्नानुसार एकत्रित करें -

y = label_mapping[np.random.choice(2,num_samples)].astype(np.float32)

Step 4 - अब np.random.random फ़ंक्शन का उपयोग करके अंत में, यादृच्छिक फ्लोटिंग पॉइंट मानों की एक सरणी उत्पन्न करें -

x = np.random.random(size=(num_samples, 4)).astype(np.float32)

एक बार, हम यादृच्छिक फ़्लोटिंग-पॉइंट मानों की एक सरणी उत्पन्न करते हैं, हमें उन्हें 32-बिट फ़्लोटिंग पॉइंट नंबरों में बदलने की आवश्यकता है ताकि इसे CNTK द्वारा अपेक्षित प्रारूप से मिलान किया जा सके। ऐसा करने के लिए नीचे दिए गए चरणों का पालन करें -

Step 5 इस प्रकार cntk.layers मॉड्यूल से घने और अनुक्रमिक परत कार्यों को आयात करें -

from cntk.layers import Dense, Sequential

Step 6- अब, हमें नेटवर्क में परतों के लिए सक्रियण फ़ंक्शन को आयात करना होगा। आयात करते हैंsigmoid सक्रियण समारोह के रूप में -

from cntk import input_variable, default_options
from cntk.ops import sigmoid

Step 7- अब, हमें नेटवर्क को प्रशिक्षित करने के लिए नुकसान फ़ंक्शन को आयात करना होगा। आयात करते हैंbinary_cross_entropy हानि समारोह के रूप में -

from cntk.losses import binary_cross_entropy

Step 8- अगला, हमें नेटवर्क के लिए डिफ़ॉल्ट विकल्पों को परिभाषित करने की आवश्यकता है। यहां, हम प्रदान करेंगेsigmoidडिफ़ॉल्ट सेटिंग के रूप में सक्रियण फ़ंक्शन। इसके अलावा, अनुक्रमिक परत फ़ंक्शन का उपयोग करके मॉडल बनाएं:

with default_options(activation=sigmoid):
model = Sequential([Dense(6),Dense(2)])

Step 9 - अगला, इनिशियलाइज़ a input_variable नेटवर्क के लिए इनपुट के रूप में सेवारत 4 इनपुट सुविधाओं के साथ।

features = input_variable(4)

Step 10 - अब, इसे पूरा करने के लिए, हमें NN में वैरिएबल कनेक्ट करने की आवश्यकता है।

z = model(features)

तो, अब हमारे पास एक NN है, निम्नलिखित चरणों की सहायता से, हम इन-मेमोरी डेटासेट का उपयोग करके इसे प्रशिक्षित करते हैं -

Step 11 - इस एनएन को प्रशिक्षित करने के लिए, पहले हमें सीखने वाले को आयात करना होगा cntk.learnersमापांक। हम आयात करेंगेsgd शिक्षार्थी इस प्रकार है -

from cntk.learners import sgd

Step 12 - इसके साथ ही आयात करें ProgressPrinter से cntk.logging मॉड्यूल के रूप में अच्छी तरह से।

from cntk.logging import ProgressPrinter
progress_writer = ProgressPrinter(0)

Step 13 - अगला, लेबल के लिए एक नया इनपुट चर परिभाषित करें -

labels = input_variable(2)

Step 14 - एनएन मॉडल को प्रशिक्षित करने के लिए, अगले, हमें एक नुकसान का उपयोग करके परिभाषित करना होगा binary_cross_entropyसमारोह। इसके अलावा, मॉडल जेड और लेबल चर प्रदान करें।

loss = binary_cross_entropy(z, labels)

Step 15 - अगला, इनिशियलाइज़ करें sgd शिक्षार्थी इस प्रकार है -

learner = sgd(z.parameters, lr=0.1)

Step 16- अंत में, नुकसान फ़ंक्शन पर ट्रेन विधि को कॉल करें। इसके अलावा, इसे इनपुट डेटा के साथ प्रदान करें,sgd शिक्षार्थी और progress_printer.-

training_summary=loss.train((x,y),parameter_learners=[learner],callbacks=[progress_writer])

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

import numpy as np
num_samples = 20000
label_mapping = np.eye(2)
y = label_mapping[np.random.choice(2,num_samples)].astype(np.float32)
x = np.random.random(size=(num_samples, 4)).astype(np.float32)
from cntk.layers import Dense, Sequential
from cntk import input_variable, default_options
from cntk.ops import sigmoid
from cntk.losses import binary_cross_entropy
with default_options(activation=sigmoid):
   model = Sequential([Dense(6),Dense(2)])
features = input_variable(4)
z = model(features)
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_writer = ProgressPrinter(0)
labels = input_variable(2)
loss = binary_cross_entropy(z, labels)
learner = sgd(z.parameters, lr=0.1)
training_summary=loss.train((x,y),parameter_learners=[learner],callbacks=[progress_writer])

उत्पादन

Build info:
     Built time: *** ** **** 21:40:10
     Last modified date: *** *** ** 21:08:46 2019
     Build type: Release
     Build target: CPU-only
     With ASGD: yes
     Math lib: mkl
     Build Branch: HEAD
     Build SHA1:ae9c9c7c5f9e6072cc9c94c254f816dbdc1c5be6 (modified)
     MPI distribution: Microsoft MPI
     MPI version: 7.0.12437.6
-------------------------------------------------------------------
average   since   average   since examples
loss      last    metric    last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.52      1.52      0         0     32
1.51      1.51      0         0     96
1.48      1.46      0         0    224
1.45      1.42      0         0    480
1.42       1.4      0         0    992
1.41      1.39      0         0   2016
1.4       1.39      0         0   4064
1.39      1.39      0         0   8160
1.39      1.39      0         0  16352

पंडों डेटाफ्रैम का उपयोग करना

Numpy सरणियाँ वे क्या शामिल कर सकते हैं और डेटा भंडारण के सबसे बुनियादी तरीकों में से एक में बहुत सीमित हैं। उदाहरण के लिए, एक एकल n- ​​आयामी सरणी में एकल डेटा प्रकार का डेटा हो सकता है। लेकिन दूसरी तरफ, कई वास्तविक दुनिया के मामलों में हमें एक पुस्तकालय की आवश्यकता होती है जो एक डेटासेट में एक से अधिक डेटा प्रकारों को संभाल सकता है।

पंडों नामक पायथन पुस्तकालयों में से एक इस तरह के डेटासेट के साथ काम करना आसान बनाता है। यह एक DataFrame (DF) की अवधारणा का परिचय देता है और हमें DF प्रारूप के रूप में विभिन्न स्वरूपों में संग्रहीत डिस्क से डेटासेट लोड करने की अनुमति देता है। उदाहरण के लिए, हम CSV को CSV, JSON, Excel आदि के रूप में संग्रहीत पढ़ सकते हैं।

आप पायथन पंडों पुस्तकालय को और अधिक विस्तार से जान सकते हैं https://www.tutorialspoint.com/python_pandas/index.htm.

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

इस उदाहरण में, हम चार गुणों के आधार पर आईरिस फूलों की तीन संभावित प्रजातियों को वर्गीकृत करने के उदाहरण का उपयोग करने जा रहे हैं। हमने पिछले खंडों में भी इस गहन शिक्षण मॉडल को बनाया है। मॉडल इस प्रकार है -

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

उपरोक्त मॉडल में एक छिपी हुई परत और तीन न्यूरॉन्स के साथ एक आउटपुट परत है जो हम अनुमान लगा सकते हैं कि कक्षाओं की संख्या से मेल खाने के लिए है।

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

Step 1 - आयात करें numpy तथा Pandas पैकेज निम्नानुसार है -

import numpy as np
import pandas as pd

Step 2 - अगला, उपयोग करें read_csv डेटासेट को मेमोरी में लोड करने का कार्य -

df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’,
 ‘petal_length’, ‘petal_width’, ‘species’], index_col=False)

Step 3 - अब, हमें एक ऐसा शब्दकोष बनाने की जरूरत है, जो डेटासेट में लेबल को उनके संबंधित संख्यात्मक प्रतिनिधित्व के साथ मैप कर रहा हो।

label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}

Step 4 - अब, का उपयोग करके iloc सूचकांक पर DataFrame, पहले चार कॉलम निम्नानुसार चुनें -

x = df_source.iloc[:, :4].values

Step 5AsNext, हमें डेटा कॉलम को डेटासेट के लिए लेबल के रूप में चुनना होगा। इसे निम्नानुसार किया जा सकता है -

y = df_source[‘species’].values

Step 6 - अब, हमें डेटासेट में उन लेबलों को मैप करना होगा, जिनका उपयोग करके किया जा सकता है label_mapping। इसका भी प्रयोग करेंone_hot एन्कोडिंग उन्हें एक-हॉट एन्कोडिंग सरणियों में बदलने के लिए।

y = np.array([one_hot(label_mapping[v], 3) for v in y])

Step 7 - अगला, CNTK के साथ सुविधाओं और मैप किए गए लेबल का उपयोग करने के लिए, हमें उन दोनों को फ़्लोट में बदलने की आवश्यकता है -

x= x.astype(np.float32)
y= y.astype(np.float32)

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

def one_hot(index, length):
result = np.zeros(length)
result[index] = index
return result

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

Step 8- सबसे पहले, हमें नेटवर्क को प्रशिक्षित करने के लिए नुकसान फ़ंक्शन को आयात करना होगा। आयात करते हैंbinary_cross_entropy_with_softmax हानि समारोह के रूप में -

from cntk.losses import binary_cross_entropy_with_softmax

Step 9 - इस एनएन को प्रशिक्षित करने के लिए, हमें सीखने वाले को आयात करने की भी आवश्यकता है cntk.learnersमापांक। हम आयात करेंगेsgd शिक्षार्थी इस प्रकार है -

from cntk.learners import sgd

Step 10 - इसके साथ ही आयात करें ProgressPrinter से cntk.logging मॉड्यूल के रूप में अच्छी तरह से।

from cntk.logging import ProgressPrinter
progress_writer = ProgressPrinter(0)

Step 11 - अगला, लेबल के लिए एक नया इनपुट चर परिभाषित करें -

labels = input_variable(3)

Step 12 - एनएन मॉडल को प्रशिक्षित करने के लिए, अगले, हमें एक नुकसान का उपयोग करके परिभाषित करना होगा binary_cross_entropy_with_softmaxसमारोह। मॉडल z और लेबल चर भी प्रदान करें।

loss = binary_cross_entropy_with_softmax (z, labels)

Step 13 - अगला, इनिशियलाइज़ करें sgd शिक्षार्थी इस प्रकार है -

learner = sgd(z.parameters, 0.1)

Step 14- अंत में, नुकसान फ़ंक्शन पर ट्रेन विधि को कॉल करें। इसके अलावा, इसे इनपुट डेटा के साथ प्रदान करें,sgd शिक्षार्थी और progress_printer।

training_summary=loss.train((x,y),parameter_learners=[learner],callbacks=
[progress_writer],minibatch_size=16,max_epochs=5)

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

from cntk.layers import Dense, Sequential
from cntk import input_variable, default_options
from cntk.ops import sigmoid, log_softmax
from cntk.losses import binary_cross_entropy
model = Sequential([
Dense(4, activation=sigmoid),
Dense(3, activation=log_softmax)
])
features = input_variable(4)
z = model(features)
import numpy as np
import pandas as pd
df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, ‘petal_length’, ‘petal_width’, ‘species’], index_col=False)
label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}
x = df_source.iloc[:, :4].values
y = df_source[‘species’].values
y = np.array([one_hot(label_mapping[v], 3) for v in y])
x= x.astype(np.float32)
y= y.astype(np.float32)
def one_hot(index, length):
result = np.zeros(length)
result[index] = index
return result
from cntk.losses import binary_cross_entropy_with_softmax
from cntk.learners import sgd
from cntk.logging import ProgressPrinter
progress_writer = ProgressPrinter(0)
labels = input_variable(3)
loss = binary_cross_entropy_with_softmax (z, labels)
learner = sgd(z.parameters, 0.1)
training_summary=loss.train((x,y),parameter_learners=[learner],callbacks=[progress_writer],minibatch_size=16,max_epochs=5)

उत्पादन

Build info:
     Built time: *** ** **** 21:40:10
     Last modified date: *** *** ** 21:08:46 2019
     Build type: Release
     Build target: CPU-only
     With ASGD: yes
     Math lib: mkl
     Build Branch: HEAD
     Build SHA1:ae9c9c7c5f9e6072cc9c94c254f816dbdc1c5be6 (modified)
     MPI distribution: Microsoft MPI
     MPI version: 7.0.12437.6
-------------------------------------------------------------------
average    since    average   since   examples
loss        last     metric   last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.1         1.1        0       0      16
0.835     0.704        0       0      32
1.993      1.11        0       0      48
1.14       1.14        0       0     112
[………]

बड़े डेटासेट के साथ प्रशिक्षण

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

• MinibatchSource डेटा स्रोत से पढ़े गए नमूनों को स्वचालित रूप से रैंडमाइज़ करके एनएन को ओवरफिटिंग से रोक सकते हैं।

• इसमें अंतर्निहित परिवर्तन पाइपलाइन है जिसका उपयोग डेटा को बढ़ाने के लिए किया जा सकता है।

• यह प्रशिक्षण प्रक्रिया से अलग पृष्ठभूमि थ्रेड पर डेटा लोड करता है।

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

MinibatchSource उदाहरण बनाना

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

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

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

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

Step 2 - अब, का उपयोग करके StreamDef वर्ग, लेबल के लिए एक स्ट्रीम परिभाषा क्रेट करें।

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

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

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

Step 4 - अब, हमें प्रदान करने की आवश्यकता है iris.ctf इनपुट के रूप में फ़ाइल करें और आरंभ करें deserializer निम्नानुसार है -

deserializer = CTFDeserializer(‘iris.ctf’, StreamDefs(labels=
label_stream, features=features_stream)

Step 5 - अंत में, हमें उदाहरण प्रस्तुत करने की आवश्यकता है minisourceBatch का उपयोग करके deserializer निम्नानुसार है -

Minibatch_source = MinibatchSource(deserializer, randomize=True)

एक MinibatchSource उदाहरण बनाना - पूर्ण कार्यान्वयन उदाहरण

from cntk.io import StreamDef, StreamDefs, MinibatchSource, CTFDeserializer, INFINITY_REPEAT
labels_stream = StreamDef(field=’labels’, shape=3, is_sparse=False)
feature_stream = StreamDef(field=’features’, shape=4, is_sparse=False)
deserializer = CTFDeserializer(‘iris.ctf’, StreamDefs(labels=label_stream, features=features_stream)
Minibatch_source = MinibatchSource(deserializer, randomize=True)

MCTF फ़ाइल बनाना

जैसा कि आपने ऊपर देखा है, हम 'iris.ctf' फ़ाइल से डेटा ले रहे हैं। इसमें CNTK टेक्स्ट फॉर्मेट (CTF) नामक फाइल फॉर्मेट है। डेटा प्राप्त करने के लिए CTF फ़ाइल बनाना अनिवार्य हैMinibatchSourceउदाहरण हमने ऊपर बनाया है। आइए देखें कि हम सीटीएफ फाइल कैसे बना सकते हैं।

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

Step 1 - सबसे पहले, हमें निम्नानुसार पंडों और खस्ता पैकेजों को आयात करना होगा -

import pandas as pd
import numpy as np

Step 2- इसके बाद, हमें अपनी डेटा फ़ाइल, अर्थात iris.csv को मेमोरी में लोड करना होगा। फिर, इसे स्टोर करेंdf_source चर।

df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, ‘petal_length’, ‘petal_width’, ‘species’], index_col=False)

Step 3 - अब, का उपयोग करके ilocसुविधाओं के रूप में अनुक्रमणिका, पहले चार कॉलम की सामग्री लें। इसके अलावा, प्रजाति कॉलम के डेटा का उपयोग इस प्रकार करें -

features = df_source.iloc[: , :4].values
labels = df_source[‘species’].values

Step 4- अगला, हमें लेबल नाम और इसके संख्यात्मक प्रतिनिधित्व के बीच एक मानचित्रण बनाने की आवश्यकता है। इसे बनाकर किया जा सकता हैlabel_mapping निम्नानुसार है -

label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}

Step 5 - अब, लेबल को एक गर्म एन्कोडेड वैक्टर के एक सेट में इस प्रकार परिवर्तित करें -

labels = [one_hot(label_mapping[v], 3) for v in labels]

अब, जैसा कि हमने पहले किया था, एक उपयोगिता फ़ंक्शन कहा जाता है one_hotलेबल को एनकोड करने के लिए। इसे निम्नानुसार किया जा सकता है -

def one_hot(index, length):
result = np.zeros(length)
result[index] = 1
return result

जैसा कि, हमने डेटा को लोड और प्रीप्रोसेस किया है, यह CTF फ़ाइल प्रारूप में डिस्क पर संग्रहीत करने का समय है। हम इसे पायथन कोड की मदद से कर सकते हैं -

With open(‘iris.ctf’, ‘w’) as output_file:
for index in range(0, feature.shape[0]):
feature_values = ‘ ‘.join([str(x) for x in np.nditer(features[index])])
label_values = ‘ ‘.join([str(x) for x in np.nditer(labels[index])])
output_file.write(‘features {} | labels {} \n’.format(feature_values, label_values))

MCTF फ़ाइल बनाना - पूर्ण कार्यान्वयन उदाहरण

import pandas as pd
import numpy as np
df_source = pd.read_csv(‘iris.csv’, names = [‘sepal_length’, ‘sepal_width’, ‘petal_length’, ‘petal_width’, ‘species’], index_col=False)
features = df_source.iloc[: , :4].values
labels = df_source[‘species’].values
label_mapping = {‘Iris-Setosa’ : 0, ‘Iris-Versicolor’ : 1, ‘Iris-Virginica’ : 2}
labels = [one_hot(label_mapping[v], 3) for v in labels]
def one_hot(index, length):
result = np.zeros(length)
result[index] = 1
return result
With open(‘iris.ctf’, ‘w’) as output_file:
for index in range(0, feature.shape[0]):
feature_values = ‘ ‘.join([str(x) for x in np.nditer(features[index])])
label_values = ‘ ‘.join([str(x) for x in np.nditer(labels[index])])
output_file.write(‘features {} | labels {} \n’.format(feature_values, label_values))

डाटा फीड करना

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

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

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

from cntk.logging import ProgressPrinter

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

from cntk.train import Trainer,

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

minbatch_size = 16
samples_per_epoch = 150
num_epochs = 30

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

input_map = {
     features: minibatch.source.streams.features,
     labels: minibatch.source.streams.features
}

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

progress_writer = ProgressPrinter(0)

Step 6 - अंत में, हमें ट्रेन की विधि को नुकसान पर लागू करने की आवश्यकता है -

train_history = loss.train(minibatch_source,
parameter_learners=[learner],
  model_inputs_to_streams=input_map,
callbacks=[progress_writer],
epoch_size=samples_per_epoch,
max_epochs=num_epochs)

डेटा खिलाना - पूर्ण कार्यान्वयन उदाहरण

from cntk.logging import ProgressPrinter
from cntk.train import Trainer, training_session
minbatch_size = 16
samples_per_epoch = 150
num_epochs = 30
input_map = {
   features: minibatch.source.streams.features,
   labels: minibatch.source.streams.features
}
progress_writer = ProgressPrinter(0)
train_history = loss.train(minibatch_source,
parameter_learners=[learner],
model_inputs_to_streams=input_map,
callbacks=[progress_writer],
epoch_size=samples_per_epoch,
max_epochs=num_epochs)

उत्पादन

-------------------------------------------------------------------
average   since   average   since  examples
loss      last     metric   last
------------------------------------------------------
Learning rate per minibatch: 0.1
1.21      1.21      0        0       32
1.15      0.12      0        0       96
[………]