असंतुलित डेटा के लिए टेन्सरफ्लो समायोजन लागत समारोह

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

क्या आप लोगों के पास कोई वैज्ञानिक संदर्भ है कि आप आदर्श रूप से नुकसान के कार्य के लिए वजन कैसे चुनते हैं? ऐसा नहीं है कि मुझे आप पर विश्वास नहीं है, लेकिन मुझे लगा कि आप किसी और से प्रेरित हैं?

— गेरहार्ड हैगर

और जैसा कि davidparks21 ने पहले ही पूछा था, आपके दृष्टिकोण के परिणाम बहुत दिलचस्प होंगे :)।

— गेरहार्ड हैगर

Answer 1

यह नुकसान फ़ंक्शन के लिए एक अच्छा समाधान की तरह लगता है। मुझे हाल ही में इसी तरह के दृष्टिकोण के साथ सफलता मिली है, लेकिन मुझे लगता है कि आप उस जगह को फिर से व्यवस्थित करना चाहेंगे जहां आप गुणा करेंगे class_weight।

तार्किक रूप से इसके बारे में सोचते हुए, यह class_weightएक निरंतर wrt आउटपुट होगा, इसलिए इसे साथ ले जाया जाएगा और ग्रेडिएंट पर उसी तरह से लागू किया जाएगा, जिस तरह से इसे लागत फ़ंक्शन पर लागू किया जा रहा है। हालांकि एक समस्या है।

आपके पास यह तरीका, 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():

एक भारित क्रॉस एन्ट्रापी की गणना करता है।

यह sigmoid_cross_entropy_with_logits () को छोड़कर है, जो pos_weight को छोड़कर, किसी व्यक्ति को नकारात्मक त्रुटि के सापेक्ष सकारात्मक त्रुटि की लागत को कम या कम करके याद रखने और सटीक व्यापार करने की अनुमति देता है।

यह आपको वह करना चाहिए जो आप चाहते हैं।

Answer 3

मेरे 2 अलग-अलग कार्यान्वयन हैं:

1. लॉग्स के साथ 'नियमित' सॉफ्टमैक्स के साथ: tf.nn.softmax_cross_entropy_with.logits

जहाँ class_weight एक प्लेसहोल्डर है, जिसे मैं everey बैच की पुनरावृति पर भरता हूँ।

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)