টেনসরফ্লোতে নিয়মিতকরণ কীভাবে যুক্ত করবেন?

Question 1

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

আমার প্রশ্নগুলি হ'ল:

এটি ম্যানুয়ালি করার চেয়ে নিয়মিত করার কি আরও কোনও মার্জিত বা প্রস্তাবিত উপায় আছে?
আমি এটিরও get_variableযুক্তি পেয়েছি regularizer। এটি কীভাবে ব্যবহার করা উচিত? আমার পর্যবেক্ষণ অনুসারে, যদি আমরা এটিতে একটি নিয়ন্ত্রক পাস করি (যেমন tf.contrib.layers.l2_regularizer, নিয়ন্ত্রিত পদটি উপস্থাপনকারী একটি টেনসর গণনা করা হবে এবং নামকৃত গ্রাফ সংগ্রহের সাথে যুক্ত করা tf.GraphKeys.REGULARIZATOIN_LOSSESহবে that সেই সংগ্রহটি কি টেনসরফ্লো স্বয়ংক্রিয়ভাবে ব্যবহার করা হবে (যেমন প্রশিক্ষণের সময় অপ্টিমাইজারের সাহায্যে ব্যবহৃত হবে)) বা এটা কি আশা করা উচিত যে আমি নিজেই সেই সংগ্রহটি ব্যবহার করব?

Question 2

যেমনটি আপনি দ্বিতীয় দফায় বলেছেন, regularizerযুক্তিটি ব্যবহার করা প্রস্তাবিত উপায়। আপনি এটি ব্যবহার করতে পারেন get_variable, বা এটি একবারে সেট করতে পারেন variable_scopeএবং আপনার সমস্ত ভেরিয়েবলগুলি নিয়মিত করে তুলতে পারেন।

ক্ষয়গুলি গ্রাফটিতে সংগ্রহ করা হয় এবং আপনার নিজের ব্যয় ফাংশনে ম্যানুয়ালি এগুলি যুক্ত করতে হবে।

  reg_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
  reg_constant = 0.01  # Choose an appropriate one.
  loss = my_normal_loss + reg_constant * sum(reg_losses)

আশা করি এইটি কাজ করবে!

Question 3

বিদ্যমান উত্তরের কয়েকটি দিক আমার কাছে তাত্ক্ষণিকভাবে পরিষ্কার ছিল না, সুতরাং এখানে ধাপে ধাপে গাইড:

একটি নিয়ামক নির্ধারণ করুন। এই স্থানে নিয়মিতকরণ ধ্রুবক সেট করা যেতে পারে, যেমন:
```
regularizer = tf.contrib.layers.l2_regularizer(scale=0.1)
```
এর মাধ্যমে ভেরিয়েবলগুলি তৈরি করুন:
```
    weights = tf.get_variable(
        name="weights",
        regularizer=regularizer,
        ...
    )
```
সমানভাবে, নিয়মিত weights = tf.Variable(...)নির্মাণকারীর মাধ্যমে ভেরিয়েবলগুলি তৈরি করা যেতে পারে , তারপরে tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, weights)।
কিছু lossশব্দ সংজ্ঞায়িত করুন এবং নিয়ন্ত্রণ রেখা যুক্ত করুন:
```
reg_variables = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
reg_term = tf.contrib.layers.apply_regularization(regularizer, reg_variables)
loss += reg_term
```
দ্রষ্টব্য: দেখে মনে হচ্ছে tf.contrib.layers.apply_regularizationএটি একটি হিসাবে প্রয়োগ করা হয়েছে AddN, তাই কমবেশি সমান sum(reg_variables)।

Question 4

আমি একটি সহজ সঠিক উত্তর সরবরাহ করব যেহেতু আমি এর একটিও পাই নি। আপনার দুটি সহজ পদক্ষেপ দরকার, বাকিটি সেন্সরফ্লো যাদু দ্বারা সম্পন্ন করা হয়:

ভেরিয়েবল বা স্তর তৈরি করার সময় নিয়মিতকরণ যুক্ত করুন:

tf.layers.dense(x, kernel_regularizer=tf.contrib.layers.l2_regularizer(0.001))
# or
tf.get_variable('a', regularizer=tf.contrib.layers.l2_regularizer(0.001))

ক্ষতির সংজ্ঞা দেওয়ার সময় নিয়মিতকরণ শব্দটি যুক্ত করুন:
```
loss = ordinary_loss + tf.losses.get_regularization_loss()
```

Question 5

টেনসরফ্লু ওয়েবসাইটের ডিপ এমএনআইএসটি টিউটোরিয়াল-এর উপর contrib.learnভিত্তি করে লাইব্রেরির সাথে এটি করার জন্য আরেকটি বিকল্প । প্রথমত, ধরে নিই যে আপনি প্রাসঙ্গিক লাইব্রেরিগুলি (যেমন ) আমদানি করেছেন , আপনি একটি পৃথক পদ্ধতিতে কোনও নেটওয়ার্ককে সংজ্ঞায়িত করতে পারেন:import tensorflow.contrib.layers as layers

def easier_network(x, reg):
    """ A network based on tf.contrib.learn, with input `x`. """
    with tf.variable_scope('EasyNet'):
        out = layers.flatten(x)
        out = layers.fully_connected(out, 
                num_outputs=200,
                weights_initializer = layers.xavier_initializer(uniform=True),
                weights_regularizer = layers.l2_regularizer(scale=reg),
                activation_fn = tf.nn.tanh)
        out = layers.fully_connected(out, 
                num_outputs=200,
                weights_initializer = layers.xavier_initializer(uniform=True),
                weights_regularizer = layers.l2_regularizer(scale=reg),
                activation_fn = tf.nn.tanh)
        out = layers.fully_connected(out, 
                num_outputs=10, # Because there are ten digits!
                weights_initializer = layers.xavier_initializer(uniform=True),
                weights_regularizer = layers.l2_regularizer(scale=reg),
                activation_fn = None)
        return out

তারপরে, একটি প্রধান পদ্ধতিতে, আপনি নিম্নলিখিত কোড স্নিপেট ব্যবহার করতে পারেন:

def main(_):
    mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)
    x = tf.placeholder(tf.float32, [None, 784])
    y_ = tf.placeholder(tf.float32, [None, 10])

    # Make a network with regularization
    y_conv = easier_network(x, FLAGS.regu)
    weights = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'EasyNet') 
    print("")
    for w in weights:
        shp = w.get_shape().as_list()
        print("- {} shape:{} size:{}".format(w.name, shp, np.prod(shp)))
    print("")
    reg_ws = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES, 'EasyNet')
    for w in reg_ws:
        shp = w.get_shape().as_list()
        print("- {} shape:{} size:{}".format(w.name, shp, np.prod(shp)))
    print("")

    # Make the loss function `loss_fn` with regularization.
    cross_entropy = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
    loss_fn = cross_entropy + tf.reduce_sum(reg_ws)
    train_step = tf.train.AdamOptimizer(1e-4).minimize(loss_fn)

এটি কাজ করার জন্য আপনাকে পূর্বের সাথে লিঙ্কিত এমএনআইএসটি টিউটোরিয়ালটি অনুসরণ করতে হবে এবং প্রাসঙ্গিক গ্রন্থাগারগুলি আমদানি করতে হবে, তবে টেনসরফ্লো শেখার জন্য এটি একটি দুর্দান্ত অনুশীলন এবং কীভাবে নিয়ন্ত্রণ আউটপুটকে প্রভাবিত করে তা সহজেই বোঝা যায়। আপনি যদি একটি যুক্তি হিসাবে নিয়মিতকরণ প্রয়োগ করেন, আপনি নিম্নলিখিত দেখতে পারেন:

- EasyNet/fully_connected/weights:0 shape:[784, 200] size:156800
- EasyNet/fully_connected/biases:0 shape:[200] size:200
- EasyNet/fully_connected_1/weights:0 shape:[200, 200] size:40000
- EasyNet/fully_connected_1/biases:0 shape:[200] size:200
- EasyNet/fully_connected_2/weights:0 shape:[200, 10] size:2000
- EasyNet/fully_connected_2/biases:0 shape:[10] size:10

- EasyNet/fully_connected/kernel/Regularizer/l2_regularizer:0 shape:[] size:1.0
- EasyNet/fully_connected_1/kernel/Regularizer/l2_regularizer:0 shape:[] size:1.0
- EasyNet/fully_connected_2/kernel/Regularizer/l2_regularizer:0 shape:[] size:1.0

লক্ষ্য করুন যে নিয়মিতকরণের অংশটি উপলব্ধ আইটেমগুলির উপর ভিত্তি করে আপনাকে তিনটি আইটেম দেয়।

0, 0.0001, 0.01 এবং 1.0 এর নিয়মিতকরণের সাথে, আমি উচ্চ নিয়মিতকরণের শর্তগুলির বিপদগুলি দেখিয়ে যথাক্রমে 0.9468, 0.9476, 0.9183 এবং 0.1135 এর পরীক্ষার যথার্থ মান পেয়েছি।

Question 6

যদি কেউ এখনও সন্ধান করে থাকে তবে আমি কেবল tf.keras এ যুক্ত করতে চাইলে আপনি আপনার স্তরগুলিতে আর্গুমেন্ট হিসাবে তাদেরকে ওজন নিয়মিতকরণ যুক্ত করতে পারেন। টেনসরফ্লো কেরাস টিউটোরিয়ালস সাইট থেকে পাইকারি নেওয়া এল 2 নিয়মিতকরণ যুক্ত করার উদাহরণ:

model = keras.models.Sequential([
    keras.layers.Dense(16, kernel_regularizer=keras.regularizers.l2(0.001),
                       activation=tf.nn.relu, input_shape=(NUM_WORDS,)),
    keras.layers.Dense(16, kernel_regularizer=keras.regularizers.l2(0.001),
                       activation=tf.nn.relu),
    keras.layers.Dense(1, activation=tf.nn.sigmoid)
])

আমি জানি যতদূর জানি এই পদ্ধতিতে নিয়মিত ক্ষতিতে ম্যানুয়ালি যোগ করার দরকার নেই।

তথ্যসূত্র: https://www.tensorflow.org/tutorials/keras/overfit_and_underfit# অ্যাডডি_ওয়েট_অনুক্রমিককরণ

Question 7

আমি পরীক্ষিত tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)এবং tf.losses.get_regularization_loss()এক সঙ্গে l2_regularizerগ্রাফ, এবং দেখা গেছে যে তারা একই মান ফিরে। মানটির পরিমাণ পর্যবেক্ষণ করে, আমি অনুমান করি যে Reg_constant এর পরামিতিটি সেট করে মানটি ইতিমধ্যে উপলব্ধি করেছে tf.contrib.layers.l2_regularizer।

Question 8

আপনার সিএনএন থাকলে আপনি নিম্নলিখিতগুলি করতে পারেন:

আপনার মডেল ফাংশনে:

conv = tf.layers.conv2d(inputs=input_layer,
                        filters=32,
                        kernel_size=[3, 3],
                        kernel_initializer='xavier',
                        kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-5),
                        padding="same",
                        activation=None) 
...

আপনার ক্ষতির ফাংশনে:

onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=num_classes)
loss = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels, logits=logits)
regularization_losses = tf.losses.get_regularization_losses()
loss = tf.add_n([loss] + regularization_losses)

Question 9

কিছু উত্তর আমাকে আরও বিভ্রান্ত করে তুলেছে e এখানে এটিকে স্পষ্ট করার জন্য আমি দুটি পদ্ধতি দিই।

#1.adding all regs by hand
var1 = tf.get_variable(name='v1',shape=[1],dtype=tf.float32)
var2 = tf.Variable(name='v2',initial_value=1.0,dtype=tf.float32)
regularizer = tf.contrib.layers.l1_regularizer(0.1)
reg_term = tf.contrib.layers.apply_regularization(regularizer,[var1,var2])
#here reg_term is a scalar

#2.auto added and read,but using get_variable
with tf.variable_scope('x',
        regularizer=tf.contrib.layers.l2_regularizer(0.1)):
    var1 = tf.get_variable(name='v1',shape=[1],dtype=tf.float32)
    var2 = tf.get_variable(name='v2',shape=[1],dtype=tf.float32)
reg_losses = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
#here reg_losses is a list,should be summed

তারপরে, এটি মোট ক্ষতির সাথে যুক্ত করা যেতে পারে

Question 10

cross_entropy = tf.losses.softmax_cross_entropy(
  logits=logits, onehot_labels=labels)

l2_loss = weight_decay * tf.add_n(
     [tf.nn.l2_loss(tf.cast(v, tf.float32)) for v in tf.trainable_variables()])

loss = cross_entropy + l2_loss

Question 11

tf.GraphKeys.REGULARIZATION_LOSSES স্বয়ংক্রিয়ভাবে যুক্ত হবে না, তবে এগুলি যুক্ত করার একটি সহজ উপায় রয়েছে:

reg_loss = tf.losses.get_regularization_loss()
total_loss = loss + reg_loss

tf.losses.get_regularization_loss()উপাদান tf.add_nঅনুসারে এন্ট্রি যোগ করতে ব্যবহার করে tf.GraphKeys.REGULARIZATION_LOSSES। tf.GraphKeys.REGULARIZATION_LOSSESসাধারণত স্কেলারগুলির একটি তালিকা হবে, নিয়মিতকরণ ফাংশন ব্যবহার করে গণনা করা। এটা তোলে কল থেকে এন্ট্রি পায় tf.get_variableআছে regularizerপ্যারামিটার নির্দিষ্ট করা হয়েছে। আপনি সেই সংগ্রহটিতে ম্যানুয়ালি যোগ করতে পারেন। tf.Variableক্রিয়াকলাপ নিয়মিত বা অন্যান্য কাস্টম নিয়ামকগুলি নির্দিষ্ট করার সময় এবং এটি কার্যকর হবে । এই ক্ষেত্রে:

#This will add an activity regularizer on y to the regloss collection
regularizer = tf.contrib.layers.l2_regularizer(0.1)
y = tf.nn.sigmoid(x)
act_reg = regularizer(y)
tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, act_reg)

(এই উদাহরণে সম্ভবত এক্সকে নিয়মিতকরণের জন্য এটি আরও কার্যকর হতে পারে, যেহেতু বড় পরিমাণ এক্সের জন্য সত্যিকার অর্থে চ্যাপ্টা হয়))