एक केरस मॉडल के MSE को अधिकतम करें

Question

मेरे पास एक जेनेरेटर का प्रतिकूल नेटवर्क है, जहां एमएसई के साथ भेदभाव कम हो जाता है और जनरेटर को अधिकतम होना चाहिए। क्योंकि दोनों विरोधी हैं जो विपरीत लक्ष्य का पीछा करते हैं।

generator = Sequential()
generator.add(Dense(units=50, activation='sigmoid', input_shape=(15,)))
generator.add(Dense(units=1, activation='sigmoid'))
generator.compile(loss='mse', optimizer='adam')

generator.train_on_batch(x_data, y_data)

जेनरेटर मॉडल प्राप्त करने के लिए मुझे क्या अनुकूलित करना होगा, जो कि उच्च एमएसई मूल्य से लाभ हो?

Comments

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

— a_guest

मेरे पास एक जेनेरेटर का प्रतिकूल नेटवर्क है, जहां एमएसई के साथ भेदभाव कम हो जाता है और जनरेटर को अधिकतम होना चाहिए। क्योंकि दोनों विरोधी हैं जो विपरीत लक्ष्य का पीछा करते हैं।

— एम्मा

ठीक है आपका प्रश्न काफी भ्रामक था। कृपया इसे स्पष्ट करने के लिए अपडेट करें।

— जीकोड

@Geeocode मैंने किया, धन्यवाद। क्या आपको लगता है कि नकारात्मक संकेत के साथ मार्को का समाधान सही है?

— एम्मा

मेरा अपडेट मिनटों में देखें

— गीकोकोड

Answer 1

अपडेट करें:

मूल MSE कार्यान्वयन इस प्रकार है:

def mean_squared_error(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return K.mean(K.square(y_pred - y_true), axis=-1)

मुझे लगता है कि सही अधिकतम हानि समारोह:

def mean_squared_error_max(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return K.mean(K.square(1 / (y_pred - y_true)), axis=-1)

इस तरह हमें हमेशा एक सकारात्मक हानि मूल्य मिलता है, जैसे कि एमएसई फ़ंक्शन के मामले में, लेकिन उलटा प्रभाव के साथ।

अद्यतन 2: शुरू में मैंने लिखा, कि करने के लिए सहज ज्ञान युक्त पहला विचार से ये सिर्फ नकारना नुकसान होगा नहीं परिणाम क्या हम क्योंकि अनुकूलन तरीकों के आधार अवधारणा की उम्मीद दे (आप एक दिलचस्प चर्चा पढ़ सकते हैं यहाँ )। जब मैंने एक विशेष शिक्षण कार्य में परिणाम को सिर करने के लिए दोनों विधि सिर की जाँच की (नोट: मैंने एक ऑल-आउट परीक्षण नहीं किया था) यह था कि दोनों विधि ने नुकसान को अधिकतम किया, हालांकि -lossदृष्टिकोण थोड़ा तेज हो गया। मुझे यकीन नहीं है कि यह हमेशा यहां बताए गए संभावित मुद्दे के कारण सबसे अच्छा समाधान या कोई समाधान देता है । अगर किसी को अन्य अनुभव है, तो कृपया मुझे बताएं।

तो अगर किसी को -lossभी एक कोशिश देना चाहते हैं:

def mean_squared_error(y_true, y_pred):
    if not K.is_tensor(y_pred):
        y_pred = K.constant(y_pred)
    y_true = K.cast(y_true, y_pred.dtype)
    return - K.mean(K.square(y_pred - y_true), axis=-1)

अतिरिक्त जानकारिया:

ओपी ने लिखा:

मेरे पास एक जेनेरेटर का प्रतिकूल नेटवर्क है, जहां एमएसई के साथ भेदभाव कम हो जाता है और जनरेटर को अधिकतम होना चाहिए। क्योंकि दोनों विरोधी हैं जो विपरीत लक्ष्य का पीछा करते हैं।

Ibragil द्वारा दिए गए लिंक से:

इस बीच, जनरेटर नई, सिंथेटिक छवियां बना रहा है जो कि विवेचक को पास करता है। यह आशाओं में ऐसा करता है कि वे, नकली होने पर भी, प्रामाणिक माने जाएंगे। जनरेटर का लक्ष्य निष्क्रिय हाथ से लिखे अंकों को उत्पन्न करना है: बिना पकड़े जाने के लिए झूठ बोलना। विवेचक का लक्ष्य जनरेटर से आने वाली छवियों को नकली के रूप में पहचानना है।

तो यह एक बीमार समस्या है:

में GAN हमारे अंतिम लक्ष्य हमारे दो प्रतिपक्षों को प्रशिक्षित करने के discriminator और जनरेटर एक दूसरे के खिलाफ संभव के रूप में अच्छा के रूप में प्रदर्शन करने के लिए। इसका मतलब है, कि दो आधार सीखने algorythm विभिन्न कार्यों लेकिन नुकसान समारोह जिसके साथ वे प्राप्त कर सकते हैं इष्टतम समाधान एक ही है यानी binary_crossentropy, इसलिए मॉडल 'कार्य इस खो कम करने के लिए कर रहे हैं।

एक भेदभाव मॉडल का संकलन विधि:

self.discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)

एक जनरेटर मॉडल का संकलन विधि:

self.generator.compile(loss='binary_crossentropy', optimizer=optimizer)

यह दो रनर के लक्ष्य की तरह ही होता है, जिसे पूरा करने के अपने समय को कम से कम किया जाना चाहिए, भले ही वे इस कार्य में प्रतिस्पर्धी हों।

तो "विपरीत लक्ष्य" का अर्थ विपरीत कार्य नहीं है अर्थात नुकसान को कम करना (यानी धावक के उदाहरण में समय कम से कम करना)।

मुझे उम्मीद है यह मदद करेगा।

Answer 2

मेरे लिए सवाल बहुत स्पष्ट नहीं है। मुझे लगता है कि आप MSE की कसौटी का उपयोग करते हुए, न्यूनतम के बजाय अधिकतम करना चाहते हैं।

आप अपने स्वयं के कस्टम लॉस फ़ंक्शन को लागू कर सकते हैं, जो -MSE की गणना करता है; नुकसान के संकेत flipping, और इस तरह ढाल वंश दिशा में एक फ्लिप प्राप्त करने।

def negative_mse(y,yhat): 
    return - K.mean(K.sum(K.square(y-yhat)))

model.compile(loss=negative_mse, optimizer='adam')

एक अन्य विकल्प केवल एक नकारात्मक सीखने के कदम की आपूर्ति करना है - लेकिन मुझे यकीन नहीं है कि केरेस आपको ऐसा करने की अनुमति देता है। एक कोशिश के काबिल है।

Comments

क्या आप अपने कार्य में नकारात्मक संकेत भूल गए हैं?

— एम्मा

वास्तव में मेरे पास है। बस जवाब संपादित किया।

— मानो