बाइनरी_क्रोसेंट्रॉपी और श्रेणीबद्ध_क्रोसेंट्रोपी एक ही समस्या के लिए अलग-अलग प्रदर्शन क्यों देते हैं?

160

मैं विषय द्वारा पाठ को वर्गीकृत करने के लिए एक सीएनएन को प्रशिक्षित करने की कोशिश कर रहा हूं। जब मैं बाइनरी क्रॉस-एंट्रोपी का उपयोग करता हूं तो मुझे ~ 80% सटीकता मिलती है, श्रेणीगत क्रॉस-एंट्रोपी के साथ मुझे ~ 50% सटीकता प्राप्त होती है।

मुझे समझ नहीं आता कि यह क्यों है। यह एक बहुविकल्पी समस्या है, इसका मतलब यह नहीं है कि मुझे श्रेणीबद्ध-एन्ट्रापी का उपयोग करना है और बाइनरी क्रॉस-एंट्रोपी के साथ परिणाम अर्थहीन हैं?

model.add(embedding_layer)
model.add(Dropout(0.25))
# convolution layers
model.add(Conv1D(nb_filter=32,
                    filter_length=4,
                    border_mode='valid',
                    activation='relu'))
model.add(MaxPooling1D(pool_length=2))
# dense layers
model.add(Flatten())
model.add(Dense(256))
model.add(Dropout(0.25))
model.add(Activation('relu'))
# output layer
model.add(Dense(len(class_id_index)))
model.add(Activation('softmax'))

फिर मैं इसे या तो इस तरह से संकलित करता हूं जैसे categorical_crossentropyकि हानि फ़ंक्शन का उपयोग करना:

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

या

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

सहज रूप से यह समझ में आता है कि मैं श्रेणीबद्ध क्रॉस-एंट्रोपी का उपयोग क्यों करना चाहता हूं, मुझे समझ में नहीं आता है कि मुझे बाइनरी के साथ अच्छे परिणाम क्यों मिलते हैं, और श्रेणीबद्ध के साथ खराब परिणाम।

— डैनियल मेसियस
स्रोत

10

यदि यह एक बहु-विषयक समस्या है, तो आपको इसका उपयोग करना होगा categorical_crossentropy। इसके अलावा लेबल को श्रेणीबद्ध प्रारूप में परिवर्तित करने की आवश्यकता है। to_categoricalऐसा करने के लिए देखें । इसके अलावा यहाँ श्रेणीबद्ध और द्विआधारी क्रॉसेंट्रोपियों की परिभाषाएँ देखें ।

— स्वायत्त

मेरे लेबल श्रेणीबद्ध हैं, जो of_categorical (प्रत्येक वर्ग के लिए एक गर्म वैक्टर) का उपयोग करके बनाया गया है। क्या इसका मतलब है कि द्विआधारी क्रॉसेंट्रोपी से ~ 80% सटीकता सिर्फ एक फर्जी संख्या है?

— डैनियल मेसियस

मुझे ऐसा लगता है। यदि आप श्रेणीबद्ध लेबल यानी एक गर्म वैक्टर का उपयोग करते हैं, तो आप चाहते हैं categorical_crossentropy। यदि आपके पास दो कक्षाएं हैं, तो उन्हें 0, 1बाइनरी लेबल और 10, 01श्रेणीबद्ध लेबल प्रारूप में दर्शाया जाएगा ।

— स्वायत्त

1

मुझे लगता है कि वह वेक्टर में पहले नंबर की तुलना करता है और बाकी की उपेक्षा करता है।

— थॉमस Pinetz

2

@NilavBaranGhosh प्रतिनिधित्व दो वर्गों (नहीं [[0, 0], [0, 1]] जैसे श्रेणीबद्ध वर्गीकरण के लिए [[1, 0], [0, 1]] होगा। Dense(1, activation='softmax')बाइनरी वर्गीकरण के लिए बस गलत है। याद रखें सॉफ्टमैक्स आउटपुट एक प्रायिकता वितरण है जो किसी एक को देता है। यदि आप बाइनरी वर्गीकरण के साथ केवल एक आउटपुट न्यूरॉन रखना चाहते हैं, तो बाइनरी क्रॉस-एंट्रोपी के साथ सिग्मॉइड का उपयोग करें।

— स्वायत्त

204

स्पष्ट और बाइनरी क्रॉस एन्ट्रॉपी के बीच इस स्पष्ट प्रदर्शन विसंगति का कारण यह है कि उपयोगकर्ता xtof54 ने पहले से ही नीचे दिए गए अपने उत्तर में रिपोर्ट किया है :

evaluateकैरस विधि के साथ गणना की गई सटीकता 2 से अधिक लेबल के साथ बाइनरी_क्रोसेंट्रॉपी का उपयोग करते समय सीधे सादे गलत है

मैं इस पर अधिक विस्तार करना चाहता हूं, वास्तविक अंतर्निहित मुद्दे को प्रदर्शित करता हूं, इसे समझाता हूं, और एक उपाय प्रस्तुत करता हूं।

यह व्यवहार बग नहीं है; अंतर्निहित कारण Kirs वास्तव में जो आपके द्वारा चयनित नुकसान फ़ंक्शन पर निर्भर करता है, का उपयोग करने के लिए सटीकता का अनुमान लगाता है कि जब आप metrics=['accuracy']अपने मॉडल संकलन में बस शामिल करते हैं, तो इसका उपयोग करने में कोई सूक्ष्म और अविवादित मुद्दा है । दूसरे शब्दों में, जबकि आपका पहला संकलन विकल्प

model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

मान्य है, आपका दूसरा:

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

जो आप उम्मीद करते हैं वह उत्पन्न नहीं करेगा, लेकिन इसका कारण बाइनरी क्रॉस एन्ट्रॉपी का उपयोग नहीं है (जो, कम से कम सिद्धांत रूप में, एक बिल्कुल वैध नुकसान फ़ंक्शन है)।

ऐसा क्यों है? यदि आप मेट्रिक्स स्रोत कोड की जांच करते हैं , तो केरेस एक सटीकता सटीकता मीट्रिक को परिभाषित नहीं करता है, लेकिन कई अलग-अलग, उनमें binary_accuracyऔर categorical_accuracy। हुड के नीचे क्या होता है है, क्योंकि आपने बाइनरी क्रॉस एन्ट्रॉपी को अपने नुकसान फ़ंक्शन के रूप में चुना है और एक विशेष सटीकता मीट्रिक, केरस (गलत तरीके से ...) को निर्दिष्ट नहीं किया है जो आप में रुचि रखते हैं binary_accuracy, और यह वही है जो यह रिटर्न करता है - जबकि वास्तव में आप में रुचि रखते हैं categorical_accuracy।

आइए सत्यापित करें कि यह मामला है, MNIST CNN उदाहरण का उपयोग करते हुए , निम्न संशोधन के साथ:

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])  # WRONG way

model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=2,  # only 2 epochs, for demonstration purposes
          verbose=1,
          validation_data=(x_test, y_test))

# Keras reported accuracy:
score = model.evaluate(x_test, y_test, verbose=0) 
score[1]
# 0.9975801164627075

# Actual accuracy calculated manually:
import numpy as np
y_pred = model.predict(x_test)
acc = sum([np.argmax(y_test[i])==np.argmax(y_pred[i]) for i in range(10000)])/10000
acc
# 0.98780000000000001

score[1]==acc
# False

इसे मापने के लिए, अर्थात आपके नुकसान फ़ंक्शन के रूप में बाइनरी क्रॉस एन्ट्रॉपी का उपयोग करने के लिए (जैसा कि मैंने कहा, इसके साथ कुछ भी गलत नहीं है, कम से कम सिद्धांत रूप में) अभी भी हाथ में समस्या से संबंधित स्पष्ट सटीकता प्राप्त करते समय , आपको स्पष्ट रूप से पूछना चाहिएcategorical_accuracy । मॉडल संकलन इस प्रकार है:

from keras.metrics import categorical_accuracy
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=[categorical_accuracy])

एमएनआईएसटी उदाहरण में, प्रशिक्षण, स्कोरिंग और टेस्ट सेट की भविष्यवाणी करने के बाद जैसा कि मैंने ऊपर दिखाया है, दो मैट्रिक्स अब समान हैं, जैसा कि उन्हें होना चाहिए:

# Keras reported accuracy:
score = model.evaluate(x_test, y_test, verbose=0) 
score[1]
# 0.98580000000000001

# Actual accuracy calculated manually:
y_pred = model.predict(x_test)
acc = sum([np.argmax(y_test[i])==np.argmax(y_pred[i]) for i in range(10000)])/10000
acc
# 0.98580000000000001

score[1]==acc
# True

प्रणाली की स्थापना:

Python version 3.5.3
Tensorflow version 1.2.1
Keras version 2.0.4

अद्यतन : मेरी पोस्ट के बाद, मुझे पता चला कि इस मुद्दे को पहले ही इस उत्तर में पहचान लिया गया था ।

— desertnaut
स्रोत

1

क्या loss='categorical_crossentropy', metrics=['categorical_accuracy']मल्टीस्कलैस वर्गीकरण के लिए उपयोग करने में कुछ गड़बड़ है? यह मेरा अंतर्ज्ञान होगा

— NeStack

2

@NeStack न केवल कुछ भी गलत नहीं है, लेकिन यह नाममात्र संयोजन है।

— रेगिस्तानी जूल

1

आपने जो कहा, उसके अनुसार, जब तक मैं नुकसान = 'बाइनरी_क्रोसेंट्रॉपी' का उपयोग करता हूं, मुझे वही रिटर्न मिलेगा जो मैटर नहीं है मैं मेट्रिक्स = 'बाइनरी_सुरसिटी' या मेट्रिक्स = 'सटीकता' का उपयोग करता हूं?

— बायोडाइडर

2

@BioCoder बिल्कुल

— रेगिस्तान में

54

यह सब उस वर्गीकरण समस्या के प्रकार पर निर्भर करता है जिससे आप निपट रहे हैं। तीन मुख्य श्रेणियां हैं

बाइनरी वर्गीकरण (दो लक्ष्य वर्ग),
बहु-श्रेणी वर्गीकरण (दो से अधिक अनन्य लक्ष्य),
मल्टी-लेबल वर्गीकरण (दो से अधिक गैर-विशिष्ट लक्ष्य), जिसमें एक ही समय में कई लक्ष्य कक्षाएं हो सकती हैं।

पहले मामले में, बाइनरी क्रॉस-एंट्रोपी का उपयोग किया जाना चाहिए और लक्ष्य को एक-गर्म वैक्टर के रूप में एन्कोड किया जाना चाहिए।

दूसरे मामले में, श्रेणीगत-एन्ट्रापी का उपयोग किया जाना चाहिए और लक्ष्य को एक-गर्म वैक्टर के रूप में एन्कोड किया जाना चाहिए।

अंतिम स्थिति में, बाइनरी क्रॉस-एंट्रोपी का उपयोग किया जाना चाहिए और लक्ष्य को एक-गर्म वैक्टर के रूप में एन्कोड किया जाना चाहिए। प्रत्येक आउटपुट न्यूरॉन (या यूनिट) को एक अलग यादृच्छिक बाइनरी चर माना जाता है, और आउटपुट के पूरे वेक्टर के लिए नुकसान एकल बाइनरी चर के नुकसान का उत्पाद है। इसलिए यह प्रत्येक एकल आउटपुट इकाई के लिए बाइनरी क्रॉस-एंट्रोपी का उत्पाद है।

बाइनरी क्रॉस-एंट्रोपी के रूप में परिभाषित किया गया है

और स्पष्ट पार-एन्ट्रापी को इस रूप में परिभाषित किया गया है

cवर्गों की संख्या पर सूचकांक कहां चल रहा है

— Whynote
स्रोत

आपका उत्तर मुझे बहुत सही लगता है, लेकिन ... मैंने @desertnaut उत्तर का पालन करने की कोशिश की और उस परीक्षण को किया: बाइनरी_क्रोसेंट्रोपि लॉस फंक्शन के साथ और मेग्निस को श्रेणीबद्धता के लिए। मेरे पास एक बेहतर परिशुद्धता है कि श्रेणीबद्ध_क्रिसेंट्रोपी लॉस फंक्शन और सटीक मेट्रिक्स का उपयोग करते हुए - और मैं समझा नहीं सकता। कि ...

— मेटल 3 डी

@ मेटल 3 डी: आपकी समस्या का सूत्रीकरण क्या है: मल्टी-लेबल या सिंगल-लेबल?

— व्हिअनोटे

एकल-लेबल, और अब मुझे एहसास हुआ कि यह बेहतर क्यों काम करता है :)

— Metal3d

क्या आप सुनिश्चित हैं कि द्विआधारी और श्रेणीबद्ध क्रॉस-एन्ट्रोपियों को इस उत्तर में सूत्र के रूप में परिभाषित किया गया है?

— nbro

@nbro, वास्तव cमें, बाइनरी क्रॉस-एन्ट्रापी फॉर्मूला में इंडेक्स बेमानी है, इसे वहां रहने की आवश्यकता नहीं है (क्योंकि केवल 2 वर्ग हैं और प्रत्येक वर्ग की संभावना अंदर एम्बेडेड है y(x)। अन्यथा उन फॉर्मूले सही होने चाहिए, लेकिन ध्यान दें कि वे नुकसान नहीं हैं, वे संभावनाएं हैं। यदि आप चाहते हैं कि नुकसान आपको इनमें से लेना है log।

— Whynote

40

मुझे एक "उलटा" मुद्दा सामने आया - मुझे gradorical_crossentropy (2 वर्गों के साथ) और Binary_crossentropy के साथ खराब परिणाम मिल रहे थे। ऐसा लगता है कि समस्या गलत सक्रियण फ़ंक्शन के साथ थी। सही सेटिंग्स थीं:

के लिए binary_crossentropy: सिग्माइड सक्रियण, अदिश लक्ष्य
के लिए categorical_crossentropy: सॉफ्टमैक्स सक्रियण, एक-हॉट एन्कोडेड लक्ष्य

— अलेक्जेंडर श्वेतकिन
स्रोत

4

क्या आप द्विआधारी_क्रोसेंट्रोपी के लिए अदिश लक्ष्य के बारे में निश्चित हैं। ऐसा लगता है कि आपको "कई-गर्म" एन्कोडेड लक्ष्य (उदाहरण [0 1 0 0 1 1]) का उपयोग करना चाहिए।

— दिमित्री

5

ज़रूर। Keras.io/losses/#usage-of-loss-functions देखें , यह कहता है: "जब gradorical_crossentropy नुकसान का उपयोग किया जाता है, तो आपके लक्ष्य श्रेणीबद्ध प्रारूप में होने चाहिए (जैसे यदि आपके पास 10 कक्षाएं हैं, तो प्रत्येक नमूने के लिए लक्ष्य 10 होना चाहिए। -डिमेटिक वेक्टर जो ऑल-जीरो उम्मीद है कि नमूने के वर्ग के अनुक्रमणिका के अनुरूप 1) "

— अलेक्जेंडर श्वेतकिन

1

लेकिन हम बाइनरी_क्रोसेंट्रॉपी के बारे में बोल रहे हैं - श्रेणीगत_क्रोसेंट्रोपी नहीं।

— दिमित्री

इस जवाब के साथ असंगत प्रतीत होता है stackoverflow.com/a/49175655/3924118 जबकि, आपका जवाब में, आप का सुझाव वे scalars होना चाहिए, है, जहां लेखक का कहना है कि लक्ष्य एक गर्म एनकोडेड होना चाहिए। आपको यह स्पष्ट करना चाहिए।

— nbro

@AlexanderSvetkin, लक्ष्य हर जगह एक-हॉट एन्कोडेड होना चाहिए, न कि केवल श्रेणीबद्ध क्रॉस-एन्ट्रोपी का उपयोग करते समय

— Whynote

28

यह वाकई दिलचस्प मामला है। वास्तव में आपके सेटअप में निम्नलिखित कथन सत्य है:

binary_crossentropy = len(class_id_index) * categorical_crossentropy

इसका मतलब यह है कि एक निरंतर गुणन कारक तक आपके नुकसान बराबर हैं। प्रशिक्षण चरण के दौरान आप जो अजीब व्यवहार देख रहे हैं, वह निम्नलिखित घटना का एक उदाहरण हो सकता है:

शुरुआत में सबसे अधिक बार वर्ग नुकसान पर हावी रहा है - इसलिए नेटवर्क हर उदाहरण के लिए ज्यादातर इस वर्ग की भविष्यवाणी करना सीख रहा है।
यह सबसे लगातार पैटर्न सीखा है के बाद यह कम लगातार कक्षाओं के बीच भेदभाव शुरू कर देता है। लेकिन जब आप उपयोग कर रहे हैं adam- प्रशिक्षण की शुरुआत में सीखने की दर की तुलना में बहुत कम मूल्य है (यह इस अनुकूलन की प्रकृति के कारण है)। यह प्रशिक्षण को धीमा बनाता है और आपके नेटवर्क को खराब स्थानीय न्यूनतम न्यूनतम संभव छोड़ने से रोकता है।

यही कारण है कि इस निरंतर कारक के मामले में मदद मिल सकती है binary_crossentropy। कई युगों के बाद - सीखने की दर मूल्य categorical_crossentropyमामले में अधिक से अधिक है । मैं आमतौर पर प्रशिक्षण (और सीखने के चरण) को कुछ बार पुनः आरंभ करता हूं जब मैं इस तरह के व्यवहार को नोटिस करता हूं और / या निम्न पैटर्न का उपयोग करते हुए एक वर्ग वजन को समायोजित करता हूं:

class_weight = 1 / class_frequency

यह प्रशिक्षण की शुरुआत में और अनुकूलन प्रक्रिया के एक और हिस्से में एक प्रमुख वर्ग के नुकसान के प्रभाव को संतुलित करते हुए कम लगातार कक्षाओं से नुकसान होता है।

संपादित करें:

वास्तव में - मैंने जाँच की कि गणित के मामले में भी:

binary_crossentropy = len(class_id_index) * categorical_crossentropy

पकड़ होना चाहिए - अगर kerasयह सच नहीं है, kerasतो अपने आप ही सभी आउटपुट को सामान्य करने के लिए योग है 1। इस अजीब व्यवहार के पीछे यह वास्तविक कारण है क्योंकि बहुस्तरीयकरण के मामले में ऐसा सामान्यीकरण एक प्रशिक्षण को नुकसान पहुँचाता है।

— मारकिन मोएजो
स्रोत

क्या मेरे जवाब से आपको मदद मिली है?

— Marcin Mo 12ejko

1

यह बहुत प्रशंसनीय व्याख्या है। लेकिन मुझे यकीन नहीं है कि यह वास्तव में मुख्य कारण है। क्योंकि मैंने अपने कई छात्रों में इस अजीब व्यवहार को देखा है जब कैट-एक्स-एंट (जो एक गलती है) के बजाय बाइनरी-एक्स-एंट्री लागू करते हैं। और यह तब भी सच है जब केवल 2 युगों के लिए प्रशिक्षण! उलटे वर्ग के पुजारियों के साथ वर्ग_वेट का उपयोग करने से मदद नहीं मिली। हो सकता है कि सीखने की दर की एक सख्त ट्यूनिंग में मदद मिलेगी, लेकिन डिफ़ॉल्ट मान बिन-एक्स-एंट के पक्ष में प्रतीत होते हैं। मुझे लगता है कि यह सवाल अधिक जांच के योग्य है ...

— xtof54

1

रुको, नहीं, क्षमा करें, मुझे आपका अपडेट नहीं मिला: सॉफ्टमैक्स हमेशा आउटपुट को 1 के बराबर बनाता है, इसलिए हमें इसकी परवाह नहीं है? और यह नुकसान प्रशिक्षण क्यों होगा, जब तक कि हमारे पास केवल एक स्वर्ण वर्ग है जो प्रति उदाहरण सही है?

— xtof54

20

@Marcin के उत्तर पर टिप्पणी करने के बाद, मैंने अपने छात्रों के एक कोड की और अधिक सावधानी से जाँच की, जहाँ मुझे वही अजीब व्यवहार मिला, वह भी केवल 2 युगों के बाद! (इसलिए @ मेरे मामले में Marcin की व्याख्या बहुत संभावना नहीं थी)।

और मैंने पाया कि उत्तर वास्तव में बहुत सरल है: evaluate2 से अधिक लेबल वाली बाइनरी_क्रसेंट्रोपी का उपयोग करते समय कैरस विधि के साथ गणना की गई सटीकता सिर्फ गलत है। आप यह देख सकते हैं कि सटीकता की पुन: गणना करके (पहले केरेस पद्धति को "भविष्यवाणी" कहते हैं और फिर भविष्यवाणी द्वारा दिए गए सही उत्तरों की संख्या की गणना करते हैं): आपको सच्ची सटीकता प्राप्त होती है, जो केर "मूल्यांकन" की तुलना में बहुत कम है।

— xtof54
स्रोत

1

मैंने पहले पुनरावृति पर भी ऐसा ही व्यवहार देखा।

— डोलबी

10

वर्णन करने के लिए एक बहु-श्रेणी सेटिंग के तहत एक सरल उदाहरण

मान लीजिए कि आपके पास 4 वर्ग हैं (इनहॉट इनकोडेड) और नीचे सिर्फ एक भविष्यवाणी है

true_label = [0,1,0,0] अनुमानित_लबेल = [0,0,1,0]

gradorical_crossentropy का उपयोग करते समय, सटीकता सिर्फ 0 है, यह केवल इस बात की परवाह करता है कि क्या आपको संबंधित वर्ग सही मिलता है।

हालांकि जब बाइनरी_क्रोसेंट्रॉपी का उपयोग करते हैं, तो सटीकता की गणना सभी वर्गों के लिए की जाती है, यह इस भविष्यवाणी के लिए 50% होगा। और अंतिम परिणाम दोनों मामलों के लिए व्यक्तिगत सटीकता का माध्यम होगा।

बहु-श्रेणी (वर्ग परस्पर अनन्य) समस्या के लिए श्रेणीबद्ध_क्रोसेंट्रोपी का उपयोग करने की अनुशंसा की जाती है, लेकिन बहु-लेबल समस्या के लिए बाइनरी_क्रॉसट्रॉपी।

— Bazinga
स्रोत

8

चूँकि यह एक बहु-वर्गीय समस्या है, तो आपको gradorical_crossentropy का उपयोग करना होगा, बाइनरी क्रॉस एन्ट्रापी फर्जी परिणाम देगा, सबसे अधिक संभावना केवल पहले दो वर्गों का मूल्यांकन करेगी।

बहु-वर्ग समस्या के लिए 50% वर्गों की संख्या के आधार पर काफी अच्छा हो सकता है। यदि आपके पास n कक्षाएं हैं, तो 100 / n न्यूनतम प्रदर्शन है जिसे आप यादृच्छिक वर्ग का उत्पादन करके प्राप्त कर सकते हैं।

— डॉ। स्नोपी
स्रोत

2

categorical_crossentropyनुकसान का उपयोग करते समय , आपका लक्ष्य श्रेणीबद्ध प्रारूप में होना चाहिए (जैसे कि यदि आपके पास 10 कक्षाएं हैं, तो प्रत्येक नमूने के लिए लक्ष्य 10-आयामी वेक्टर होना चाहिए जो कि कक्षा 1 के अनुरूप सूचकांक पर 1 को छोड़कर सभी-शून्य हो। नमूना)।

— Priyansh
स्रोत

3

यह प्रश्न का उत्तर कैसे देता है?

— डेजर्टनट

2

उस समीकरण पर एक नज़र डालें जो आप पा सकते हैं कि बाइनरी क्रॉस एन्ट्रॉपी न केवल उन लेबल = 1, पूर्वानुमानित = 0, बल्कि लेबल = 0, अनुमानित = 1 को भी सजा देता है।

हालाँकि श्रेणीगत क्रॉस एन्ट्रापी केवल उन लेबल = 1 को दंडित करते हैं लेकिन भविष्यवाणी की गई है = 1.क्यों हम यह धारणा बनाते हैं कि केवल एक लेबल सकारात्मक है।

— कुआंग यान
स्रोत

1

आप नुकसान के रूप में उपयोग करते समय आकार (x-dim, y-dim) के एक लक्ष्य सरणी से गुजर रहे हैं categorical_crossentropy। categorical_crossentropyउम्मीद है कि आकार (नमूने, कक्षाएं) के बाइनरी मैट्रीस (1s और 0s) होंगे। यदि आपके लक्ष्य पूर्णांक वर्ग हैं, तो आप उन्हें अपेक्षित प्रारूप में बदल सकते हैं:

from keras.utils import to_categorical
y_binary = to_categorical(y_int)

वैकल्पिक रूप से, आप नुकसान फ़ंक्शन का उपयोग कर सकते हैं sparse_categorical_crossentropy इसके बजाय , जो पूर्णांक लक्ष्यों की अपेक्षा करता है।

model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

— susan097
स्रोत

0

बाइनरी_क्रोसेंट्रॉपी (y_target, y_predict) को बाइनरी वर्गीकरण समस्या में लागू करने की आवश्यकता नहीं है। ।

बाइनरी_क्रोसेंट्रॉपी () के स्रोत कोड में , nn.sigmoid_cross_entropy_with_logits(labels=target, logits=output)वास्तव में TensorFlow फ़ंक्शन का उपयोग किया गया था। और, प्रलेखन में , यह कहता है कि:

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

— 翟志伟
स्रोत