ভারসাম্যহীন ডেটার জন্য টেনসরফ্লো অ্যাডজাস্টিং ব্যয় ফাংশন

Question

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

আমি লক্ষ্য করেছি যে প্রতিটি গ্রুপের বিপরীত শতাংশের লগ আমি চেষ্টা করেছি এমন সেরা গুণক তৈরি করেছে। ব্যয় কার্যকারিতা জন্য আরও মানক হেরফের আছে? এটি কি সঠিকভাবে প্রয়োগ করা হয়েছে?

from collections import Counter
counts = Counter(category_train)
weightsArray =[]
for i in range(n_classes):
    weightsArray.append(math.log(category_train.shape[0]/max(counts[i],1))+1)

class_weight = tf.constant(weightsArray)
weighted_logits = tf.mul(pred, class_weight)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(weighted_logits, y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

Comments

আপনি কীভাবে ক্ষতির কার্যকারিতাটির জন্য ওজনকে আদর্শভাবে চয়ন করেন তার জন্য কি আপনার কোনও বৈজ্ঞানিক উল্লেখ রয়েছে? আমি আপনাকে বিশ্বাস করি না এমন নয়, তবে আমি ভেবেছিলাম আপনি অন্য কারও দ্বারা অনুপ্রাণিত?

— জেরহার্ড হ্যাজারার

এবং ডেভিডপার্কস 21 ইতিমধ্যে জিজ্ঞাসা করা হয়েছে, আপনার পদ্ধতির ফলাফলগুলি খুব আকর্ষণীয় হবে :)।

— গারহার্ড হ্যাজারার

Answer 1

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

যৌক্তিকভাবে এ সম্পর্কে চিন্তাভাবনা করে, class_weighta এক সমস্যা যদিও এখন পর্যন্ত।

আপনার কাছে যেভাবে রয়েছে তা class_weightভবিষ্যদ্বাণী মানকে প্রভাবিত করবে। তবে আপনি এটি গ্রেডিয়েন্টের স্কেলকে প্রভাবিত করতে চান। আমি যদি ভুল না করি তবে আমি মনে করি আপনি ক্রিয়াকলাপের ক্রমটি বিপরীত করতে চান:

# Take the cost like normal
error = tf.nn.softmax_cross_entropy_with_logits(pred, y)

# Scale the cost by the class weights
scaled_error = tf.mul(error, class_weight)

# Reduce
cost = tf.reduce_mean(scaled_error)

আমি এটি জানতে আগ্রহী হব যে এটি কেবল নিম্নরূপ শ্রেণীর তুলনায় কীভাবে সম্পাদন করে, যা আরও সাধারণ। সুতরাং আপনি যদি এখানে কিছু অন্তর্দৃষ্টি অর্জন করতে পারেন! :)

মজার বিষয় হ'ল আমি সম্প্রতি একটি ভিন্ন সমস্যা ডোমেইনে সফলভাবে একটি খুব অনুরূপ কৌশলটি ব্যবহার করেছি (যা আমাকে এই পোস্টে এনেছে):

মাল্টি-টাস্ক লার্নিং, কোনও ক্ষতির ফাংশন যা নির্দিষ্ট নমুনাগুলিকে "উপেক্ষা করে" সন্ধান করে

Answer 2

চেকআউট tf.nn.weighted_cross_entropy_with_logits():

একটি ওজনযুক্ত ক্রস এনট্রপি গণনা করে।

এটি সিগময়েড_ক্রস_এন্ট্রপী_ইথ_লগিটস () এর মত পোস্ট পামো ওয়েট ব্যতীত একজনকে নেতিবাচক ত্রুটির সাথে সম্পর্কিত একটি ধনাত্মক ত্রুটির ব্যয় আপ বা ডাউন-ওজন করে পুনরুদ্ধার এবং নির্ভুলতার ব্যবসায়ের অনুমতি দেয়।

এটি আপনাকে যা করতে চায় তা করতে দেওয়া উচিত।

Answer 3

আমার 2 টি আলাদা বাস্তবায়ন রয়েছে:

1. লগইট সহ 'নিয়মিত' সফটম্যাক্স সহ: tf.nn.softmax_cross_entropy_with_logits

যেখানে শ্রেণি-ওজন হ'ল একটি স্থানধারক আমি ইভেরি ব্যাচের পুনরাবৃত্তিতে পূরণ করি।

self.class_weight  = tf.placeholder(tf.float32, shape=self.batch_size,self._num_classes], name='class_weight')    
self._final_output = tf.matmul(self._states,self._weights["linear_layer"]) + self._biases["linear_layer"] 
self.scaled_logits = tf.multiply(self._final_output, self.class_weight)
self.softmax = tf.nn.softmax_cross_entropy_with_logits(logits=self.scaled_logits,labels= self._labels)

2. সঙ্গে tf.nn.softmax_cross_entropy_with_logits

যেখানে আমি প্রয়োগকৃত টেনসরফ্লো ফাংশনটি ব্যবহার করি তবে ব্যাচের জন্য আমার ওজন গণনা করা দরকার। ডক্স এটি সম্পর্কে কিছুটা বিভ্রান্ত করছে। Tf.gather এর সাথে এটি করার জন্য 2 টি উপায় রয়েছে:

self.scaled_class_weights=tf.reduce_sum(tf.multiply(self._labels,self.class_weight),1)
self.softmax = tf.losses.softmax_cross_entropy(logits=self._final_output,
                                                   onehot_labels=self._labels,weights=self.scaled_class_weights)

এখানে এটি সম্পর্কে একটি চমৎকার আলোচনা আছে

এবং অবশেষে যেহেতু আমি নিয়মিতভাবে কোনও প্রয়োগের সাথে বিয়ে করতে চাইনি আমি একটি সামান্য tf.case যুক্ত করেছি এবং আমি যে কৌশলটি ব্যবহার করতে চাই তার প্রশিক্ষণের সময়টি পাস করি।

self.sensitive_learning_strategy = tf.placeholder(tf.int32 , name='sensitive_learning_strategy')
self.softmax =tf.case([
            (tf.equal(self.sensitive_learning_strategy, 0), lambda: self.softmax_0),
            (tf.equal(self.sensitive_learning_strategy, 1), lambda: self.softmax_1),
            (tf.equal(self.sensitive_learning_strategy, 2), lambda: self.softmax_2)