CNTK - अनुक्रम वर्गीकरण

इस अध्याय में, हम CNTK और उसके वर्गीकरण के क्रमों के बारे में विस्तार से जानेंगे।

tensors

जिस अवधारणा पर CNTK काम करता है tensor। मूल रूप से, CNTK निविष्टियाँ, आउटपुट और साथ ही मापदंडों को व्यवस्थित किया जाता हैtensors, जिसे अक्सर सामान्यीकृत मैट्रिक्स के रूप में सोचा जाता है। हर टेनर एक हैrank -

  • रैंक 0 का टेंसर एक अदिश राशि है।

  • रैंक 1 का टेंसर एक वेक्टर है।

  • रैंक 2 का टेंसर अमेट्रिक्स है।

यहाँ, इन विभिन्न आयामों को संदर्भित किया गया है axes.

स्थैतिक कुल्हाड़ियों और गतिशील कुल्हाड़ियों

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

डायनेमिक ऐक्सिस स्टैटिक ऐक्स की तरह होते हैं क्योंकि वे टेंसर में निहित संख्याओं के सार्थक समूहन को भी परिभाषित करते हैं।

उदाहरण

इसे स्पष्ट करने के लिए, आइए देखें कि CNTK में लघु वीडियो क्लिप का एक छोटा भाग कैसे दिखाया जाता है। मान लीजिए कि वीडियो क्लिप का रिज़ॉल्यूशन सभी 640 * 480 है। और, क्लिप को रंग में भी शूट किया जाता है, जो आमतौर पर तीन चैनलों के साथ एन्कोडेड होता है। इसका आगे मतलब है कि हमारे मिनीबच के निम्नलिखित हैं -

  • लंबाई 640, 480 और 3 की क्रमशः 3 स्थिर कुल्हाड़ियों।

  • दो गतिशील कुल्हाड़ियों; वीडियो की लंबाई और मिनीबैच कुल्हाड़ियों।

इसका मतलब है कि अगर एक मिनीबैच में 16 वीडियो हैं, जिनमें से प्रत्येक 240 फ्रेम लंबा है, तो इसका प्रतिनिधित्व किया जाएगा 16*240*3*640*480 tensors।

CNTK में दृश्यों के साथ काम करना

हमें लोंग-शॉर्ट टर्म मेमोरी नेटवर्क के बारे में पहले सीखकर CNTK में अनुक्रम को समझें।

लॉन्ग-शॉर्ट टर्म मेमोरी नेटवर्क (LSTM)

Hochreiter & Schmidhuber द्वारा दीर्घकालिक अल्पकालिक मेमोरी (LSTM) नेटवर्क पेश किए गए थे। इसने चीजों को लंबे समय तक याद रखने के लिए एक मूल आवर्तक परत प्राप्त करने की समस्या को हल किया। LSTM की वास्तुकला आरेख में ऊपर दी गई है। जैसा कि हम देख सकते हैं कि इसमें इनपुट न्यूरॉन्स, मेमोरी सेल्स और आउटपुट न्यूरॉन्स हैं। लुप्त होती क्रमिक समस्या से निपटने के लिए, दीर्घकालिक अल्पकालिक मेमोरी नेटवर्क एक स्पष्ट मेमोरी सेल (पिछले मूल्यों को संग्रहीत करता है) और निम्न गेट्स का उपयोग करता है -

  • Forget gate- जैसा कि नाम से ही स्पष्ट है कि यह मेमोरी सेल को पिछले मूल्यों को भूल जाने के लिए कहता है। मेमोरी सेल मानों को तब तक स्टोर करता है जब तक कि गेट 'गेट न भूलें' उन्हें यह बताना भूल जाता है।

  • Input gate - जैसा कि नाम से ही स्पष्ट है, यह सेल में नया सामान जोड़ता है।

  • Output gate - जैसा कि नाम से पता चलता है, आउटपुट गेट तय करता है कि सेल से वैक्टर के साथ अगले छिपे हुए राज्य में कब जाया जाए।

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

import sys
import os
from cntk import Trainer, Axis
from cntk.io import MinibatchSource, CTFDeserializer, StreamDef, StreamDefs,\
   INFINITELY_REPEAT
from cntk.learners import sgd, learning_parameter_schedule_per_sample
from cntk import input_variable, cross_entropy_with_softmax, \
   classification_error, sequence
from cntk.logging import ProgressPrinter
from cntk.layers import Sequential, Embedding, Recurrence, LSTM, Dense
def create_reader(path, is_training, input_dim, label_dim):
   return MinibatchSource(CTFDeserializer(path, StreamDefs(
      features=StreamDef(field='x', shape=input_dim, is_sparse=True),
      labels=StreamDef(field='y', shape=label_dim, is_sparse=False)
   )), randomize=is_training,
   max_sweeps=INFINITELY_REPEAT if is_training else 1)
def LSTM_sequence_classifier_net(input, num_output_classes, embedding_dim,
LSTM_dim, cell_dim):
   lstm_classifier = Sequential([Embedding(embedding_dim),
      Recurrence(LSTM(LSTM_dim, cell_dim)),
      sequence.last,
      Dense(num_output_classes)])
return lstm_classifier(input)
def train_sequence_classifier():
   input_dim = 2000
   cell_dim = 25
   hidden_dim = 25
   embedding_dim = 50
   num_output_classes = 5
   features = sequence.input_variable(shape=input_dim, is_sparse=True)
   label = input_variable(num_output_classes)
   classifier_output = LSTM_sequence_classifier_net(
   features, num_output_classes, embedding_dim, hidden_dim, cell_dim)
   ce = cross_entropy_with_softmax(classifier_output, label)
   pe =      classification_error(classifier_output, label)
   rel_path = ("../../../Tests/EndToEndTests/Text/" +
      "SequenceClassification/Data/Train.ctf")
   path = os.path.join(os.path.dirname(os.path.abspath(__file__)), rel_path)
   reader = create_reader(path, True, input_dim, num_output_classes)
input_map = {
   features: reader.streams.features,
   label: reader.streams.labels
}
lr_per_sample = learning_parameter_schedule_per_sample(0.0005)
progress_printer = ProgressPrinter(0)
trainer = Trainer(classifier_output, (ce, pe),
sgd(classifier_output.parameters, lr=lr_per_sample),progress_printer)
minibatch_size = 200
for i in range(255):
   mb = reader.next_minibatch(minibatch_size, input_map=input_map)
trainer.train_minibatch(mb)
   evaluation_average = float(trainer.previous_minibatch_evaluation_average)
   loss_average = float(trainer.previous_minibatch_loss_average)
return evaluation_average, loss_average
if __name__ == '__main__':
   error, _ = train_sequence_classifier()
   print(" error: %f" % error)
average  since  average  since  examples
loss     last   metric   last
------------------------------------------------------
1.61    1.61    0.886     0.886     44
1.61     1.6    0.714     0.629    133
 1.6    1.59     0.56     0.448    316
1.57    1.55    0.479      0.41    682
1.53     1.5    0.464     0.449   1379
1.46     1.4    0.453     0.441   2813
1.37    1.28     0.45     0.447   5679
 1.3    1.23    0.448     0.447  11365

error: 0.333333

उपरोक्त कार्यक्रम का विस्तृत विवरण अगले खंडों में कवर किया जाएगा, खासकर जब हम रिकरंट न्यूरल नेटवर्क का निर्माण करेंगे।