• টেনসরফ্লো ব্যবহার করে একটি চিত্র শ্রেণিবদ্ধ তৈরি ।

    টেনসরফ্লো ব্যবহার করে একটি চিত্র শ্রেণিবদ্ধ তৈরি।

    পূর্বে আমরা কীভাবে আমাদের টেনসরফ্লো মডেলটিতে  dataset to feed প্রস্তুত করতে শিখেছি। সুতরাং এই টিউটোরিয়ালে, আমরা আমাদের পূর্ববর্তী পোস্টে একই dataset generator class টি ব্যবহার করব, যা ডাটাসেট ডিরেক্টরি থেকে ডেটা পেতে। আমরা কনভোলশনাল নিউরাল নেটওয়ার্ক ব্যবহার করে একটি চিত্র শ্রেণিবদ্ধ তৈরি করতে শিখব। আমরা সেই ডেটাসেটে প্রশিক্ষণ দেব।

    Prerequisites

    • Download Kaggle Cats vs Dogs dataset
    • DataSetGenerator Code that we wrote in our earlier post

    The Building Blocks

    একটি চিত্র স্বীকৃতি মডেল তৈরি করতে আমাদের কয়েকটি বেসিক বিল্ডিং ব্লক তৈরি করতে হবে se সেগুলি

    • Convolution Layer
    • Pooling Layer
    • Activation Layer
    • Fully Connected Layer
    সুতরাং আমরা একটি নেটওয়ার্ক নির্মাতা শ্রেণি তৈরি করব যা সহায়ক সহায়ক হবে এবং আমরা এই স্তরটি তৈরি করার পদ্ধতি যুক্ত করব। যাতে নেটওয়ার্ক তৈরি করার সময় এটি আমাদের কাজকে আরও সহজ করে তুলবে I আমি ব্যাখ্যা করবকোডের সংজ্ঞা দেওয়ার সময় আমি উপরের সমস্ত ব্লকটি ব্যাখ্যা করব।

    তাই NetworkBuilder class নেটওয়ার্কবিল্ডার ক্লাস তৈরি করেছে, আমাদের আরম্ভ করার মতো কিছু নেই so we are passing it for now।


    Convolution Layer Method

    আসুন আমাদের নেটওয়ার্কে একটি কনভোলশন স্তর সংযুক্ত করার জন্য একটি পদ্ধতি যুক্ত করি। কনভলিউশন স্তর হ'ল একটি বিশেষ ধরণের নিউরাল নেটওয়ার্ক স্তর যা ইনপুট স্তরের বৈশিষ্ট্য বা নিদর্শনগুলি সনাক্ত করে। এটি ইনপুটটিতে বৈশিষ্ট্য এবং নিদর্শনগুলি সনাক্ত করতে শেখে। সুতরাং আমরা আমাদের চিত্র স্বীকৃতি মডেলটিতে প্রাথমিক বৈশিষ্ট্য সনাক্তকারী হিসাবে কনভোলজিকাল স্তরগুলি ব্যবহার করব।


    class NetworkBuilder:
        :
        :
        def attach_conv_layer(self, input_layer, output_size=32, feature_size=(5, 5), strides=[1, 1, 1, 1], padding='SAME',
                              summary=False):
            with tf.name_scope("Convolution") as scope:
                input_size = input_layer.get_shape().as_list()[-1]
                weights = tf.Variable(tf.random_normal([feature_size[0], feature_size[1], input_size, output_size]), name='conv_weights')
                if summary:
                    tf.summary.histogram(weights.name, weights)
                biases = tf.Variable(tf.random_normal([output_size]),name='conv_biases')
                conv = tf.nn.conv2d(input_layer, weights, strides=strides, padding=padding)+biases
                return conv
    
    সুতরাং আমরা attach_conv_layer  নামে একটি পদ্ধতি তৈরি করেছি, আসুন আমরা এই পদ্ধতিতে কী আর্গুমেন্ট খাচ্ছি তা দেখতে দিন।

    input_layer , মডেলটিতে একটি নতুন স্তর সংযুক্ত করতে আমাদের এই নতুন স্তরের জন্য একটি ইনপুট স্তর প্রয়োজন।একটি কনভোলজিকাল স্তর তৈরি করতে আমাদের  output_size টি জানতে হবে যা আউটপুট বৈশিষ্ট্যের মানচিত্রের সংখ্যা (মূলত আমরা যে বৈশিষ্ট্যগুলি বের করতে চাই তার সংখ্যা) নিউরনের সংখ্যা নয়।

    feature_size কার্নেলের আকার। মূলত, এটি কিছু নির্দিষ্ট এলোমেলো বৈশিষ্ট্যযুক্ত এই নির্দিষ্ট আকারের পিক্সেলের কয়েকটি ছোট কার্নেল (প্যাচগুলি) তৈরি করবে এবং স্তরটি পুরো চিত্রটিতে কার্নেলটি স্লাইড করে ইনপুট চিত্রের সাথে মিলে যাওয়া অনুরূপ প্যাটার্নগুলি সন্ধান করার চেষ্টা করবে the । এবং আমরা প্রতিটি কার্নেল থেকে বৈশিষ্ট্য মানচিত্র তৈরি করি যেখানে স্থানাঙ্কগুলি নির্দেশ করে যেখানে কার্নেলগুলি ইনপুট চিত্রের সাথে মেলে।

    প্রতিটি পদক্ষেপ আমরা ইনপুট চিত্রের সাথে বৈশিষ্ট্য কার্নেলের সাথে মেলে ততবার একটি নির্দিষ্ট পদক্ষেপে পদক্ষেপ নিতে চাই
    প্রতিটি পদক্ষেপ আমরা যখন ইনপুট চিত্রের সাথে বৈশিষ্ট্য কার্নেলগুলি মেলে তখন আমরা কোনও নির্দিষ্ট দিকে এগিয়ে যেতে চাইছি সেই পদক্ষেপগুলি  i.e. [batch step, height step, width step, channel step]

    প্রতিবার আমরা যখন কোনও ইনপুট চিত্রের উপর কার্নেলটি স্লাইড করি তখন উত্পন্ন বৈশিষ্ট্য মানচিত্রের আকার ইনপুট চিত্রের আকারের চেয়ে কম হয় এবং আকার হ্রাস কার্নেলের আকারের উপর নির্ভর করে। আমরা যদি বৈশিষ্ট্য চিত্রের আকারটিকে ইনপুট চিত্রের মতো রাখতে চাই তবে আমাদের প্রান্তে শূন্যগুলি প্যাড করতে হবে। তার জন্য, আমাদের padding flag.রয়েছে।

    টেনসরবোর্ডে এই স্তরটির জন্য আমরা summary চাই কিনা তা নির্ধারণের জন্য summaryটি কেবলমাত্র একটি flag। আপনি যদি টেনসরবোর্ড ব্যবহার করতে না জানেন তবে আমার here টেনসরবোর্ডে বিশদ বিবরণ রয়েছে। তবে এটি optional এবং নেটওয়ার্ক ডিজাইনের সাথে সম্পর্কিত নয়, আপনি যদি এটিকে এড়াতে চান তবে এটি পুরোপুরি ঠিক।


    Let’s see inside the method

    কিছু করার আগে আমরা নতুন সুযোগ শুরু করেছিলাম এবং এর নাম দিয়েছিলাম “Convolution” 'কনভোলিউশন'। এটি আমাদেরকে টেনসরবোর্ডে ডিবাগ করার সময় একসাথে group করতে সহায়তা করবে।

    নতুন রূপান্তর স্তরটি তৈরি করতে আমাদের প্রথমে ইনপুট চিত্রের আকার প্রয়োজন। অথবা আরও নির্দিষ্টভাবে ইনপুট চিত্রটির চ্যানেলের সংখ্যা। RGB image জন্য, চ্যানেলের সংখ্যা 3, এটি last axis of the input tensor। সুতরাং আমরা শেষ অক্ষ, চ্যানেলগুলির আকার পেতে input_layer.get_shape().as_list()[-1] ব্যবহার করেছি।

    এর পরে, আমরা conv layer টির জন্য ওজন তৈরি করেছি। conv layer রের ওজন এই আকারে হওয়া উচিত[kernal height, kernel weight, input channel size, output channels ][কর্নাল উচ্চতা, কার্নেলের ওজন, ইনপুট চ্যানেলের আকার, আউটপুট চ্যানেল]। আমরা একটি এলোমেলো ওজন ম্যাট্রিক্স আরম্ভ করার জন্য tf.random_normal  ব্যবহার করেছি এবং তারপরে এটিকে টেনসরফ্লো ভেরিয়েবলে রূপান্তর করতে  tf.Variable  ব্যবহার করেছি।

    পরবর্তী (optional) আমরা summary flag টি পরীক্ষা করেছি এবং summary writer  জন্য একটি summary  tensor board যোগ করেছি।

    তারপরে আমরা বায়াস নিউরন তৈরি করেছি এবং কনফিউশনাল স্তর তৈরি করতে tf.nn.conv2d ব্যবহার করেছি, আমরা conv2d output  সহ বায়াস নিউরন যুক্ত করেছি এবং আমরা চূড়ান্ত conv layer. পাই।


    The Pooling Layer

    আমরা কনভলিউশন স্তরটির জন্য একটি পদ্ধতি তৈরি করেছি। আসুন আমাদের নেটওয়ার্কে একটি পুলিং স্তর সংযুক্ত করার জন্য একটি পদ্ধতি তৈরি করি। মূলত একটি পুলিং স্তর চিত্রগুলির নমুনাগুলির নিচে নামায় (resize it to smaller image) কারণ আমরা more and more convolution layers  সংযুক্ত করার সাথে number of feature maps এর সংখ্যা বাড়তে শুরু করে। আমরা বৈশিষ্ট্য মানচিত্রের নমুনা নীচে নেব যাতে এটি প্রক্রিয়া করা সহজ এবং দ্রুত হয়। আমরা পুলিংয়ের জন্য সর্বাধিক পুলিং পদ্ধতি ব্যবহার করব।

    class NetworkBuilder:
        :
        :
        def attach_pooling_layer(self, input_layer, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME'):
            with tf.name_scope("Pooling") as scope:
                return tf.nn.max_pool(input_layer, ksize=ksize, strides=strides, padding=padding)
    সুতরাং পুলিংয়ে, আমাদের পূর্ববর্তী পদ্ধতি এবং স্ট্রাইডগুলির পাশাপাশি আর্গুমেন্ট হিসাবে প্যাডিংয়ের মতো input_layer র প্রয়োজন। আমাদের আরও একটি প্যারামিটার দরকার যা ksize. ক্যাসাইজ নামে পরিচিত।

    পূর্ববর্তী পদ্ধতির মতো, আমরা এর 'pooling' নামে একটি scope স্কোপ খুললাম।

    Ksize হ'ল পুলিংয়ের আকার, যার অর্থ প্রতিটি direction দিকের মধ্যে কত পিক্সেল এক পিক্সেলে রূপান্তরিত হবে। এটি এই ফর্ম্যাটে থাকা উচিত  [batch, height, width, channel]. [ব্যাচ, উচ্চতা, প্রস্থ, চ্যানেল]। আমরা ব্যাচ এবং চ্যানেল অক্ষ থেকে কোনও পিক্সেল মার্জ করতে চাই না। সুতরাং ডিফল্ট হিসাবে, আমরা সেই অবস্থানগুলিতে 1 এবং উচ্চতা এবং প্রস্থ উভয় অবস্থানে 2 রেখেছি। 
    সুতরাং ডিফল্ট প্যারামিটারগুলির সাথে, পুল করা চিত্রটি উচ্চতা এবং প্রস্থের ইনপুট চিত্রের অর্ধেক হবে।

    আমরা উচ্চতা এবং প্রস্থে 2 টি ধাপও এগিয়ে চলেছি এবং প্যাডিংটি একই রকম যাতে kernel slidingয়ের সময় আকার একই থাকে।

    পুলিং স্তরটি তৈরি করতে আমরা tf.nn.max_pool  ব্যবহার করেছি এবং যুক্তিগুলি রেখেছি এবং এটি ফিরিয়ে দিয়েছি

    Activation Layer

    আমাদের নেটওয়ার্কে অলাইনারিটি যুক্ত করতে আমাদের কিছু অ্যাক্টিভেশন লেয়ার প্রয়োজন অন্যথায় নেটওয়ার্ক জটিল ফাংশন শিখতে সক্ষম হবে না। আমরা এই তিনটি অ্যাক্টিভেশন ফাংশন relu, sigmoid & softmax  রিলু, সিগময়েড এবং সফটম্যাক্সকে সংজ্ঞায়িত করব। তাদের সংজ্ঞায়িত করা যাক।
    class NetworkBuilder:
        :
        :
        def attach_relu_layer(self, input_layer):
            with tf.name_scope("Activation") as scope:
                return tf.nn.relu(input_layer)
    
        def attach_sigmoid_layer(self, input_layer):
            with tf.name_scope("Activation") as scope:
                return tf.nn.sigmoid(input_layer)
    
        def attach_softmax_layer(self, input_layer):
            with tf.name_scope("Activation") as scope:
                return tf.nn.softmax(input_layer)
    সুতরাং এই তিনটি পদ্ধতি এখানে আমার মনে হয় এগুলি স্ব-বর্ণনামূলক এবং আরও ব্যাখ্যা করার দরকার নেই।


    Fully Connected Layer

    এখন অবধি আমরা চিত্র বা বৈশিষ্ট্যযুক্ত মানচিত্রের সাথে কাজ করছিলাম যা কিছু আকারে একটি চিত্র এবং সমস্ত ব্যাচের অক্ষ বাদে আকারে থ্রিডি তবে সম্পূর্ণ সংযুক্ত স্তরটি কেবল 1 ডি দিয়েই কাজ করে তাই আমাদের সেই 3 ডি ইনপুটটিকে ফ্ল্যাট 1 ডি তে রূপান্তর করতে হবে ইনপুট. যে কারণে, আমাদের অন্য পদ্ধতি প্রয়োজন। আমরা এটিকে flatten বলব

    Flatten Layer

    class NetworkBuilder:
        :
        :
        def flatten(self, input_layer):
            with tf.name_scope("Flatten") as scope:
                input_size = input_layer.get_shape().as_list()
                new_size = input_size[-1]*input_size[-2]*input_size[-3]
                return tf.reshape(input_layer, [-1, new_size])
    সুতরাং উপরের কোডে, আমরা স্ক্যাপের নামটি ফ্ল্যাটেন দিয়েছি এবং ব্যাচের অক্ষটি বাদ দিয়ে ইনপুট স্তরটিতে নিউরনের মোট সংখ্যা (প্রতিটি পিক্সেলের মান উপস্থাপন করে) গণনা করেছি। সুতরাং, মোট নিউরনের সংখ্যা হবে (উচ্চতার অক্ষ বরাবর নিউরনের সংখ্যা) x (প্রস্থ অক্ষের সাথে নিউরনের সংখ্যা) x (চ্যানেল অক্ষের সাথে থাকা নিউরনের সংখ্যা)। যা মূলত ইনপুট স্তরের সর্বশেষ 3 অক্ষ। এখন যদি আমরা তাদের গুণ করি তবে আমরা একটি সংখ্যা পাই এবং এটি আমাদের সম্পূর্ণ সংযুক্ত স্তরের জন্য 1 ডি ভেক্টরের নতুন আকার হবে। সুতরাং এখন আমরা ইনপুট স্তরটিকে পুনরায় আকার দিচ্ছি [batchsize, newsize]  [ব্যাচসাইজ, নিউজাইজ] যেখানে -1 ব্যাচের আকারের যার অর্থ এটি কোনও মূল্য নিতে পারে এবং এটি আমাদের সংযুক্ত বৈশিষ্ট্যগুলির পুরো স্তরের সাথে সম্পূর্ণরূপে সংযুক্ত স্তর দ্বারা শ্রেণিবদ্ধ করার জন্য প্রস্তুত।


    Finally The Fully Connected (Dense) Layer

    সুতরাং একটি জিনিস পরিষ্কার করার জন্য, সম্পূর্ণরূপে সংযুক্ত স্তরগুলি মূলত একই ধরণের স্তর যা আমরা আমাদের পূর্ববর্তী টিউটোরিয়ালে তৈরি করেছি।
    class NetworkBuilder:
        :
        :
        def attach_dense_layer(self, input_layer, size, summary=False):
            with tf.name_scope("Dense") as scope:
                input_size = input_layer.get_shape().as_list()[-1]
                weights = tf.Variable(tf.random_normal([input_size, size]), name='dense_weigh')
                if summary:
                    tf.summary.histogram(weights.name, weights)
                biases = tf.Variable(tf.random_normal([size]), name='dense_biases')
                dense = tf.matmul(input_layer, weights) + biases
                return dense

    সুতরাং এটি যেমন আমি আগেই বলেছি, এটি পূর্ববর্তী টিউটোরিয়ালের সমান, আমরা ইনপুট স্তরের আকার পাই যা 1 ডি স্তর যা আমাদের কেবল শেষ অক্ষটিই প্রয়োজন। আমরা ব্যাচের দৈর্ঘ্যে আগ্রহী নই (বেশিরভাগ সময় আমরা কখনই ব্যাচের দৈর্ঘ্যে আগ্রহী না)। আমরা ইনপুট এবং আউটপুট আকারের সাথে ওজন তৈরি করেছি আমরা বায়াসেস নিউরন তৈরি করেছি। তারপরে আমরা ইনপুট স্তরটির সাথে ম্যাটমুল করেছি, বায়াসগুলি যুক্ত করেছি এবং আমাদের ঘন নামক একটি সম্পূর্ণ সংযুক্ত স্তর (এটি কখনও কখনও dense ঘন বলা হয়) দিয়ে সম্পন্ন করা হয়।

    This Is The Final Network Builder Class

    আমরা পুরোপুরি কোডটি পছন্দ করা উচিত নেটওয়ার্ক বিল্ডার ক্লাসটি সম্পন্ন করেছি
    class NetworkBuilder:
        def __init__(self):
            pass
    
        def attach_conv_layer(self, input_layer, output_size=32, feature_size=(5, 5), strides=[1, 1, 1, 1], padding='SAME',
                              summary=False):
            with tf.name_scope("Convolution") as scope:
                input_size = input_layer.get_shape().as_list()[-1]
                weights = tf.Variable(tf.random_normal([feature_size[0], feature_size[1], input_size, output_size]), name='conv_weights')
                if summary:
                    tf.summary.histogram(weights.name, weights)
                biases = tf.Variable(tf.random_normal([output_size]),name='conv_biases')
                conv = tf.nn.conv2d(input_layer, weights, strides=strides, padding=padding)+biases
                return conv
    
        def attach_relu_layer(self, input_layer):
            with tf.name_scope("Activation") as scope:
                return tf.nn.relu(input_layer)
    
        def attach_sigmoid_layer(self, input_layer):
            with tf.name_scope("Activation") as scope:
                return tf.nn.sigmoid(input_layer)
    
        def attach_softmax_layer(self, input_layer):
            with tf.name_scope("Activation") as scope:
                return tf.nn.softmax(input_layer)
    
        def attach_pooling_layer(self, input_layer, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],padding='SAME'):
            with tf.name_scope("Pooling") as scope:
                return tf.nn.max_pool(input_layer, ksize=ksize, strides=strides, padding=padding)
    
        def flatten(self, input_layer):
            with tf.name_scope("Flatten") as scope:
                input_size = input_layer.get_shape().as_list()
                new_size = input_size[-1]*input_size[-2]*input_size[-3]
                return tf.reshape(input_layer, [-1, new_size])
    
        def attach_dense_layer(self, input_layer, size, summary=False):
            with tf.name_scope("Dense") as scope:
                input_size = input_layer.get_shape().as_list()[-1]
                weights = tf.Variable(tf.random_normal([input_size, size]), name='dense_weigh')
                if summary:
                    tf.summary.histogram(weights.name, weights)
                biases = tf.Variable(tf.random_normal([size]), name='dense_biases')
                dense = tf.matmul(input_layer, weights) + biases
                return dense

    So What is Next?

    আমরা নেটওয়ার্ক নির্মাতা ক্লাস শেষ করেছি, এখন কী? মনে রাখবেন আমাদের মূল লক্ষ্যটি ছিল একটি নেটওয়ার্ক তৈরি করা। আমাদের প্রথম সিএনএন নেটওয়ার্ক তৈরি করার আগে আমাদের নিম্নলিখিত পদক্ষেপগুলি করা দরকার।

    • সুতরাং আসুন বর্গ নামের ঠিক নামে একটি ফাইলে এই কোড সংরক্ষণ করুন। যা NetworkBuilder.py হয়
    • আমাদের পূর্ববর্তী টিউটোরিয়ালে ডেটাসেট জেনারেটর ক্লাসের দরকার হবে need ডেটা সেট  জেনারেটর শ্রেণীর মতো ঠিক একই ফাইলটির নামের সাথে অন্য কোডে সেই কোডটি সংরক্ষণ করুন, যা ছিল DataSetGenerator.py
    • Put both of the files in the same.

    • Unzip the Cat vs Dog train.zip in the same directory in train folder
    • Create a new python file and let’s name it MyFirstCNNModel.py
    So after these steps, your working folder should look something like this.




    working directory – cnn image classifier in tensorflow


    Let’s Create a CNN Model in Tensorflow

    Let’s open the new file myFirstCNNModel.py and start building our model.

    Importing libraries

    import tensorflow as tf 
    from NetworkBuilder import NetworkBuilder 
    from DataSetGenerator import DataSetGenerator,seperateData
    import datetime 
    import numpy as np 
    import os

    এগুলি আমরা যে লাইব্রেরিগুলিতেব্যবহার করতে যাচ্ছি সেগুলি NetworkBuilderDataSetGenerator  and  seperateData  are libraries that we wrote ourselves এমন লাইব্রেরি যা আমরা নিজেরাই লিখেছি।
    with tf.name_scope("Input") as scope:
        input_img = tf.placeholder(dtype='float', shape=[None, 128, 128, 3], name="input")
    
    with tf.name_scope("Target") as scope:
        target_labels = tf.placeholder(dtype='float', shape=[None, 2], name="Targets")
    সুতরাং এগুলি ইনপুট এবং লক্ষ্য স্থানধারক। ইনপুট shape টি এই ফর্ম্যাটে  [batch size, height, width, channels] [ব্যাচের আকার, উচ্চতা, প্রস্থ, চ্যানেল] 

    Let’s Design the Model

    Now we will create NetworkBuilder object and we will start adding layers
    nb = NetworkBuilder()
    
    with tf.name_scope("ModelV2") as scope:
        model = input_img
        model = nb.attach_conv_layer(model, 32, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_conv_layer(model, 32, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_pooling_layer(model)
    
        model = nb.attach_conv_layer(model, 64, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_conv_layer(model, 64, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_pooling_layer(model)
    
        model = nb.attach_conv_layer(model, 128, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_conv_layer(model, 128, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_pooling_layer(model)
    
        model = nb.flatten(model)
        model = nb.attach_dense_layer(model, 200, summary=True)
        model = nb.attach_sigmoid_layer(model)
        model = nb.attach_dense_layer(model, 32, summary=True)
        model = nb.attach_sigmoid_layer(model)
        model = nb.attach_dense_layer(model, 2)
        prediction = nb.attach_softmax_layer(model)

    এটি আমাদের মডেল। এটি স্ব-ব্যাখ্যামূলক। আমাদের নেটওয়ার্ক নির্মাতাদের ক্লাসকে ধন্যবাদ, চিত্রের শ্রেণিবদ্ধ মডেলগুলি তৈরি করা এখন খুব সহজ।

    Now we will create the optimization and accuracy blocks

    with tf.name_scope("Optimization") as scope:
        global_step = tf.Variable(0, name='global_step', trainable=False)
        cost = tf.nn.softmax_cross_entropy_with_logits(logits=model, labels=target_labels)
        cost = tf.reduce_mean(cost)
        tf.summary.scalar("cost", cost)
    
        optimizer = tf.train.AdamOptimizer().minimize(cost,global_step=global_step)
    
    with tf.name_scope('accuracy') as scope:
        correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(target_labels, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
    এখানে আমরা গ্লোবাল_স্টেপ নামে একটি ভেরিয়েবল তৈরি করেছি যা প্রতিবার আমরা অপটিমাইজারটি চালানোর সময় একের দ্বারা আপডেট ও বর্ধিত হবে। এটি আমাদের সম্পাদিত মোট প্রশিক্ষণের ধাপগুলির উপর নজর রাখতে সহায়তা করবে, এমনকি যদি আমরা একটি সংরক্ষিত মডেল লোড করি তবে গ্লোবাল পদক্ষেপগুলিও পুনরুদ্ধার করা হবে।

    Visualize in Tensorboard

    এটি টেনসরবোর্ডের ফলাফল (যদি আপনি আমার টেনসরবোর্ড টিউটোরিয়ালটি পড়ে থাকেন তবে আপনি কীভাবে টেনসর বোর্ড ব্যবহার করবেন তা ইতিমধ্যে আপনি জানেন)।



    Tensorboard Visualization of image classifier Graph



    এবং এটি প্রসারিত হওয়ার পরে এটিই মডেল (দুঃখিত এটির দৃশ্যে এটি ফিট করার জন্য আমাকে এটি ঘোরানো হয়েছিল)







    TensorBoard visualization of image classifier model only

    We completed The CNN Image Classifier Model, let’s train it

    এখন আমরা ট্রেন ফোল্ডার থেকে মিনি ব্যাচগুলি তৈরি করতে এবং আমাদের সদ্য নির্মিত চিত্রের শ্রেণিবদ্ধ প্রশিক্ষণ দেওয়ার জন্য ডেটাসেটজেনেটর শ্রেণি ব্যবহার করব ।

    # we need to run this only once
    #seperateData("./train")
    dg = DataSetGenerator("./train")
    
    
    epochs = 10
    batchSize = 10
    
    saver = tf.train.Saver()
    model_save_path="./saved model v2/"
    model_name='model'
    
    with tf.Session() as sess:
        summaryMerged = tf.summary.merge_all()
    
        filename = "./summary_log/run" + datetime.datetime.now().strftime("%Y-%m-%d--%H-%M-%s")
        # setting global steps
        tf.global_variables_initializer().run()
    
        if os.path.exists(model_save_path+'checkpoint'):
            # saver = tf.train.import_meta_graph('./saved '+modelName+'/model.ckpt.meta')
            saver.restore(sess, tf.train.latest_checkpoint(model_save_path))
        writer = tf.summary.FileWriter(filename, sess.graph)
    
        for epoch in range(epochs):
            batches = dg.get_mini_batches(batchSize,(128,128), allchannel=False)
            for imgs ,labels in batches:
                imgs=np.divide(imgs, 255)
                error, sumOut, acu, steps,_ = sess.run([cost, summaryMerged, accuracy,global_step,optimizer],
                                                feed_dict={input_img: imgs, target_labels: labels})
                writer.add_summary(sumOut, steps)
                print("epoch=", epoch, "Total Samples Trained=", steps*batchSize, "err=", error, "accuracy=", acu)
                if steps % 100 == 0:
                    print("Saving the model")
                    saver.save(sess, model_save_path+model_name, global_step=steps)
    


    সুতরাং এটি আমাদের প্রশিক্ষণের সেটআপ। কুকুর এবং বিড়ালের চিত্র দুটি পৃথক ফোল্ডারে আলাদা করতে আমরা প্রথমবারের মতো আলাদা ডেটা ফাংশনটি চালাব। এর পরে, আমরা ডেটাসেটজেনেটর অবজেক্টটি তৈরি করেছিলাম এবং ব্যাচের আকার এবং epochs গুলির জন্য  কিছু ভেরিয়েবল তৈরি করেছি।

    কোডের বাকি অংশটি আমাদের পূর্ববর্তী টিউটোরিয়ালের মতো। পার্থক্যটি হ'ল আমরা প্রশিক্ষিত মডেলটি সংরক্ষণ এবং পুনরুদ্ধার করতে একটি saver.restore পদ্ধতি এবং saver.save যুক্ত করেছি। সুতরাং সেভার.সেভ ফাংশনটি প্রতি 100 পুনরাবৃত্তির পরে ডাকা হবে এবং এটি সেই ডিরেক্টরিতে মডেলটিকে সংরক্ষণ করবে যা আমরা Model_save_path ভেরিয়েবলটিতে মডেল_নাম ভেরিয়েবলের সাথে উল্লিখিত নামের সাথে সজ্জিত করব। যদি আমরা প্রশিক্ষণের সময় প্রোগ্রামটি বন্ধ করি এবং প্রোগ্রামটি আবার চালিত করি তবে এটি সেভার.রেস্টোর পদ্ধতিটি ব্যবহার করে সর্বশেষ সংরক্ষিত চেকপয়েন্টটি লোড করবে এবং এটি যেখানেই ছেড়ে গেছে সেখান থেকে এটি তার প্রশিক্ষণ চালিয়ে যাবে। সুতরাং প্রতিবার প্রোগ্রামটি চালানোর সময় আমাদের এটিকে scratch স্ক্র্যাচ থেকে প্রশিক্ষণ দিতে হবে না।

    So This is the complete CNN model and training setup Code

    এটি সম্পূর্ণ CNN চিত্র শ্রেণিবদ্ধ প্রশিক্ষণ সেটআপ কোড। আমরা এটি যতবার চাই চালাতে পারি এবং প্রতিবার যখন আমরা run করব , এটি সর্বশেষ সংরক্ষিত চেকপয়েন্ট থেকে এর প্রশিক্ষণ শুরু করবে .. সুতরাং আমরা যত বেশি এই শ্রেণিবদ্ধকে চালাচ্ছি এবং প্রশিক্ষণ করব এটি তত বেশি সঠিক হয়ে উঠবে।

    import tensorflow as tf
    from NetworkBuilder import NetworkBuilder
    from DataSetGenerator import DataSetGenerator, seperateData
    import datetime
    import numpy as np
    import os
    
    
    with tf.name_scope("Input") as scope:
        input_img = tf.placeholder(dtype='float', shape=[None, 128, 128, 1], name="input")
    
    with tf.name_scope("Target") as scope:
        target_labels = tf.placeholder(dtype='float', shape=[None, 2], name="Targets")
    
    with tf.name_scope("Keep_prob_input") as scope:
        keep_prob = tf.placeholder(dtype='float',name='keep_prob')
    
    nb = NetworkBuilder()
    
    with tf.name_scope("ModelV2") as scope:
        model = input_img
        model = nb.attach_conv_layer(model, 32, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_conv_layer(model, 32, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_pooling_layer(model)
    
        model = nb.attach_conv_layer(model, 64, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_conv_layer(model, 64, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_pooling_layer(model)
    
        model = nb.attach_conv_layer(model, 128, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_conv_layer(model, 128, summary=True)
        model = nb.attach_relu_layer(model)
        model = nb.attach_pooling_layer(model)
    
        model = nb.flatten(model)
        model = nb.attach_dense_layer(model, 200, summary=True)
        model = nb.attach_sigmoid_layer(model)
        model = nb.attach_dense_layer(model, 32, summary=True)
        model = nb.attach_sigmoid_layer(model)
        model = nb.attach_dense_layer(model, 2)
        prediction = nb.attach_softmax_layer(model)
    
    
    with tf.name_scope("Optimization") as scope:
        global_step = tf.Variable(0, name='global_step', trainable=False)
        cost = tf.nn.softmax_cross_entropy_with_logits(logits=model, labels=target_labels)
        cost = tf.reduce_mean(cost)
        tf.summary.scalar("cost", cost)
        optimizer = tf.train.AdamOptimizer().minimize(cost, global_step=global_step)
    
    with tf.name_scope('accuracy') as scope:
        correct_pred = tf.equal(tf.argmax(prediction, 1), tf.argmax(target_labels, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
    
    dg = DataSetGenerator("./train")
    
    
    epochs = 10
    batchSize = 10
    
    saver = tf.train.Saver()
    model_save_path="./saved model v2/"
    model_name='model'
    
    with tf.Session() as sess:
        summaryMerged = tf.summary.merge_all()
    
        filename = "./summary_log/run" + datetime.datetime.now().strftime("%Y-%m-%d--%H-%M-%s")
        # setting global steps
        tf.global_variables_initializer().run()
    
        if os.path.exists(model_save_path+'checkpoint'):
            # saver = tf.train.import_meta_graph('./saved '+modelName+'/model.ckpt.meta')
            saver.restore(sess, tf.train.latest_checkpoint(model_save_path))
        writer = tf.summary.FileWriter(filename, sess.graph)
    
        for epoch in range(epochs):
            batches = dg.get_mini_batches(batchSize,(128,128), allchannel=False)
            for imgs ,labels in batches:
                imgs=np.divide(imgs, 255)
                error, sumOut, acu, steps,_ = sess.run([cost, summaryMerged, accuracy,global_step,optimizer],
                                                feed_dict={input_img: imgs, target_labels: labels})
                writer.add_summary(sumOut, steps)
                print("epoch=", epoch, "Total Samples Trained=", steps*batchSize, "err=", error, "accuracy=", acu)
                if steps % 100 == 0:
                    print("Saving the model")
                    saver.save(sess, model_save_path+model_name, global_step=steps)


    Some Advanced Modifications

    আমি গুগল দ্বারা ইনসেপশন মডেল হিসাবে যেমন অনুরূপ মডিউল তৈরি করতে আমি নেটওয়ার্ক নির্মাতা শ্রেণিতে একটি অতিরিক্ত পদ্ধতি যুক্ত করেছি।এখানে কোড

    class NetworkBuilder:
        :
        :
        def attach_inception_module(self,input_layer, output_size):
            output_size_road1 = int(output_size*0.2)
            road1 = self.attach_conv_layer(input_layer=input_layer, output_size=output_size_road1,
                                           feature_size=(1, 1))
            road1 = self.attach_relu_layer(road1)
    
            output_size_road2 = int(output_size * 0.3)
            road2 = self.attach_conv_layer(input_layer=input_layer, output_size=output_size_road2,
                                           feature_size=(1, 1))
            road2 = self.attach_relu_layer(road2)
            road2 = self.attach_conv_layer(input_layer=road2, output_size=output_size_road2,
                                           feature_size=(3, 3))
    
            output_size_road3 = int(output_size * 0.3)
            road3 = self.attach_conv_layer(input_layer=input_layer, output_size=output_size_road3,
                                           feature_size=(1, 1))
            road3 = self.attach_relu_layer(road3)
            road3 = self.attach_conv_layer(input_layer=road3, output_size=output_size_road2,
                                           feature_size=(5, 5))
    
            output_size_road4 = output_size-(output_size_road1 + output_size_road2 + output_size_road3)
            road4 = self.attach_pooling_layer(input_layer=input_layer, strides=[1, 1, 1, 1])
            road4 = self.attach_conv_layer(input_layer=road4, output_size=output_size_road4,
                                           feature_size=(1, 1))
    
            with tf.name_scope("FilterConcat") as scope:
                concat = tf.concat([road1, road2, road3, road4], axis=3, name="FilterConcat")
                concat = self.attach_relu_layer(concat)
            return concat
    
    and this is how it looks like in TensorBoard
    Implemented Inceptio Module

    Limitations of our Image Classifier

    এই চিত্রের শ্রেণিবদ্ধটিকে ( স্ক্র্যাচ আরাম্ভ স্থান) থেকে প্রশিক্ষণের জন্য একটি ভাল ফলাফল পেতে সিপিইউতে কয়েক সপ্তাহ লাগবে। এমনকি আপনি যদি জিপিইউ ব্যবহার করছেন তবে এটি এখনও খুব সময়সাপেক্ষ হবে। সুতরাং আপনি যদি আমার মতো হন এবং হাই-এন্ড জিপিইউ সহ কোনও কম্পিউটার না থাকে তবে আপনি ধ্বংস হয়ে যাবেন।
    তবে আমাদের জন্য সুসংবাদ, আমরা এখনও জটিল টেনসরফ্লো মডেলকে প্রশিক্ষণ দিতে পারি যা এতগুলি গণনার শক্তি ব্যবহার না করেই এই জিনিসগুলি করতে পারে।

    পরবর্তী টিউটোরিয়ালে, আমরা ইনসেপশন নামে পরিচিত ইতিমধ্যে প্রশিক্ষিত চিত্র শ্রেণিবদ্ধ মডেলটি লোড করতে ট্রান্সফার শেখার ব্যবহার করব (কয়েক সপ্তাহের জন্য একাধিক জিপিইউ ব্যবহার করে গুগল প্রশিক্ষিত)। এবং আমরা এর প্রাক প্রশিক্ষিত চেকপয়েন্টটি প্রশিক্ষণের জন্য আমাদের বেস পয়েন্ট হিসাবে ব্যবহার করব, আমরা আমাদের নিজস্ব প্রয়োজন অনুসারে নেটওয়ার্ক কাঠামোটিও পরিবর্তন করব। যাতে প্রশিক্ষণ নিতে খুব কম সময় লাগবে এবং আমরা এটি সিপিইউতেও প্রশিক্ষণ দিতে পারি।




















  • 0 comments:

    Post a Comment

    New Research

    Attention Mechanism Based Multi Feature Fusion Forest for Hyperspectral Image Classification.

    CBS-GAN: A Band Selection Based Generative Adversarial Net for Hyperspectral Sample Generation.

    Multi-feature Fusion based Deep Forest for Hyperspectral Image Classification.

    ADDRESS

    388 Lumo Rd, Hongshan, Wuhan, Hubei, China

    EMAIL

    contact-m.zamanb@yahoo.com
    mostofa.zaman@cug.edu.cn

    TELEPHONE

    #
    #

    MOBILE

    +8615527370302,
    +8807171546477