केरास: एक गर्म एन्कोडिंग

Question

के लिए कक्षा वजन (वर्ग_वेट) मैं असंतुलित प्रशिक्षण डेटा को संभालने के लिए keras model.fit में class_weight तर्क का उपयोग करना चाहता हूं। कुछ दस्तावेजों को देख कर, मैं समझ गया कि हम इस तरह एक शब्दकोश पारित कर सकते हैं:

class_weight = {0 : 1, 
    1: 1, 
    2: 5} 

(। इस उदाहरण में, वर्ग -2 नुकसान समारोह में उच्च दंड मिल जाएगा)

समस्या यह है कि मेरी नेटवर्क के आउटपुट में एक-गर्म एन्कोडिंग यानी कक्षा -0 = (1, 0, 0), कक्षा -1 = (0, 1, 0), और कक्षा -3 = (0, 0, 1) है।

हम एक गर्म एन्कोडेड आउटपुट के लिए class_weight का उपयोग कैसे कर सकते हैं?

some codes in Keras को देख कर, यह लग रहा है _feed_output_names तरह उत्पादन कक्षाओं की एक सूची शामिल है, लेकिन मेरे मामले में, model.output_names/model._feed_output_names रिटर्न ['dense_1']

संबंधित: How to set class weights for imbalanced classes in Keras?

Answer 1

मुझे लगता है कि हम बजाय sample_weights उपयोग कर सकते हैं। केरा के अंदर, वास्तव में, class_weights को sample_weights में परिवर्तित कर दिया गया है।

नमूना_वेट: एक्स के समान लंबाई की वैकल्पिक सरणी जिसमें वजन प्रत्येक नमूने के लिए मॉडल के नुकसान पर लागू करने के लिए होता है। अस्थायी डेटा के मामले में, आप प्रत्येक नमूना के प्रत्येक टाइमस्टेप पर अलग-अलग वजन लागू करने के लिए आकार (नमूने, अनुक्रम_लेथेंथ) के साथ 2 डी सरणी पास कर सकते हैं। इस मामले में आपको संकलन (0) में sample_weight_mode = "temporal" निर्दिष्ट करना सुनिश्चित करना चाहिए।

https://github.com/fchollet/keras/blob/d89afdfd82e6e27b850d910890f4a4059ddea331/keras/engine/training.py#L1392

Answer 2

एक जटिल जवाब का एक छोटा सा है, लेकिन सबसे अच्छा मैं अब तक मिल गया है। इसका मतलब यह है अपने डेटा एक गर्म एन्कोडेड, बहु स्तरीय, और केवल लेबल पर काम कर DataFrame df_y है:

import pandas as pd 
import numpy as np 

# Create a pd.series that represents the categorical class of each one-hot encoded row 
y_classes = df_y.idxmax(1, skipna=False) 

from sklearn.preprocessing import LabelEncoder 

# Instantiate the label encoder 
le = LabelEncoder() 

# Fit the label encoder to our label series 
le.fit(list(y_classes)) 

# Create integer based labels Series 
y_integers = le.transform(list(y_classes)) 

# Create dict of labels : integer representation 
labels_and_integers = dict(zip(y_classes, y_integers)) 

from sklearn.utils.class_weight import compute_class_weight, compute_sample_weight 

class_weights = compute_class_weight('balanced', np.unique(y_integers), y_integers) 
sample_weights = compute_sample_weight('balanced', y_integers) 

class_weights_dict = dict(zip(le.transform(list(le.classes_)), class_weights)) 

यह एक sample_weights वेक्टर एक असंतुलित डाटासेट जो Keras sample_weight को पारित किया जा सकता संतुलित करने के लिए गणना की में जो परिणाम संपत्ति, और class_weights_dict जिसे .fit विधि में केरा class_weight संपत्ति में खिलाया जा सकता है। आप वास्तव में दोनों का उपयोग नहीं करना चाहते हैं, बस एक चुनें। मैं अभी class_weight का उपयोग कर रहा हूं क्योंकि sample_weightfit_generator के साथ काम करना जटिल है।

Answer 3

_standardize_weights में, keras करता है:

if y.shape[1] > 1: 
    y_classes = y.argmax(axis=1) 

तो मूल रूप से, आप एक गर्म एन्कोडिंग का उपयोग करना चाहते हैं, कक्षाओं स्तंभ अनुक्रमणिका कर रहे हैं।

आप यह भी पूछ सकते हैं कि आप अपने डेटा के मूल वर्गों में कॉलम इंडेक्स को कैसे मैप कर सकते हैं। ठीक है, यदि आप विज्ञान के लेबलएन्कोडर वर्ग का उपयोग करते हैं तो एक-गर्म एन्कोडिंग करने के लिए सीखें, कॉलम इंडेक्स फ़ंक्शन द्वारा गणना की गई unique labels के क्रम को मानचित्र करता है। दस्तावेज़ कहते हैं

अद्वितीय लेबल

के एक आदेश दिया सरणी निकालें

उदाहरण:

from sklearn.preprocessing import LabelBinarizer 
y=[4,1,2,8] 
l=LabelBinarizer() 
y_transformed=l.fit_transorm(y) 
y_transormed 
> array([[0, 0, 1, 0], 
    [1, 0, 0, 0], 
    [0, 1, 0, 0], 
    [0, 0, 0, 1]]) 
l.classes_ 
> array([1, 2, 4, 8]) 

एक निष्कर्ष के रूप में, class_weights शब्दकोश की चाबी classes_ विशेषता में आदेश को प्रतिबिंबित करना चाहिए एन्कोडर का।