एक साधारण फ़ीड अग्रेषित नेटवर्क पर अधिक से अधिक से बचने के लिए कैसे करें

Question

pima indians diabetes dataset का उपयोग करके मैं केरास का उपयोग करके एक सटीक मॉडल बनाने की कोशिश कर रहा हूं। मैं निम्नलिखित कोड लिखा है:

# Visualize training history 
from keras import callbacks 
from keras.layers import Dropout 

tb = callbacks.TensorBoard(log_dir='/.logs', histogram_freq=10, batch_size=32, 
          write_graph=True, write_grads=True, write_images=False, 
          embeddings_freq=0, embeddings_layer_names=None, embeddings_metadata=None) 
# Visualize training history 
from keras.models import Sequential 
from keras.layers import Dense 
import matplotlib.pyplot as plt 
import numpy 

# fix random seed for reproducibility 
seed = 7 
numpy.random.seed(seed) 
# load pima indians dataset 
dataset = numpy.loadtxt("pima-indians-diabetes.csv", delimiter=",") 
# split into input (X) and output (Y) variables 
X = dataset[:, 0:8] 
Y = dataset[:, 8] 
# create model 
model = Sequential() 
model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu', name='first_input')) 
model.add(Dense(500, activation='tanh', name='first_hidden')) 
model.add(Dropout(0.5, name='dropout_1')) 
model.add(Dense(8, activation='relu', name='second_hidden')) 
model.add(Dense(1, activation='sigmoid', name='output_layer')) 

# Compile model 
model.compile(loss='binary_crossentropy', 
       optimizer='rmsprop', 
       metrics=['accuracy']) 

# Fit the model 
history = model.fit(X, Y, validation_split=0.33, epochs=1000, batch_size=10, verbose=0, callbacks=[tb]) 
# list all data in history 
print(history.history.keys()) 
# summarize history for accuracy 
plt.plot(history.history['acc']) 
plt.plot(history.history['val_acc']) 
plt.title('model accuracy') 
plt.ylabel('accuracy') 
plt.xlabel('epoch') 
plt.legend(['train', 'test'], loc='upper left') 
plt.show() 
# summarize history for loss 
plt.plot(history.history['loss']) 
plt.plot(history.history['val_loss']) 
plt.title('model loss') 
plt.ylabel('loss') 
plt.xlabel('epoch') 
plt.legend(['train', 'test'], loc='upper left') 
plt.show() 

कई की कोशिश करता के बाद, मैं आदेश overfitting से बचने के लिए छोड़ने वालों की परतों को जोड़ दिया है, लेकिन कोई भाग्य के साथ। निम्नलिखित ग्राफ से पता चलता है कि सत्यापन बिंदु और प्रशिक्षण हानि एक बिंदु पर अलग हो जाती है।

और क्या मैं इस नेटवर्क अनुकूलन करने के लिए कर सकता है?

अद्यतन: टिप्पणी के आधार पर मुझे मिल गया मैं कोड इसलिए की तरह बदलाव किया है:

model = Sequential() 
model.add(Dense(12, input_dim=8, kernel_initializer='uniform', kernel_regularizer=regularizers.l2(0.01), 
       activity_regularizer=regularizers.l1(0.01), activation='relu', 
       name='first_input')) # added regularizers 
model.add(Dense(8, activation='relu', name='first_hidden')) # reduced to 8 neurons 
model.add(Dropout(0.5, name='dropout_1')) 
model.add(Dense(5, activation='relu', name='second_hidden')) 
model.add(Dense(1, activation='sigmoid', name='output_layer')) 

यहाँ 500 अवधियों को

Answer 1

पहला उदाहरण एक सत्यापन सटीकता> 75% दे दी है और दूसरा एक < 65% की सटीकता दिया और आप 100 से नीचे अवधियों को, के लिए घाटे की तुलना अगर इसके लिए कम से कम < 0.5 पहले एक के लिए और दूसरा एक> 0.6 था। लेकिन दूसरा मामला बेहतर कैसे है?

मेरे लिए दूसरा एक under-fitting का मामला है: मॉडल में सीखने की पर्याप्त क्षमता नहीं है। जबकि पहले मामले में over-fitting की समस्या है क्योंकि ओवरफिटिंग शुरू होने पर इसका प्रशिक्षण रोका नहीं गया था (early stopping)। यदि प्रशिक्षण 100 युग कहने पर रोक दिया गया था, तो यह दोनों के बीच तुलना में एक बेहतर मॉडल होगा।

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

तो इस विशेष मामले में over-fitting से कैसे बचें? early stopping को अपनाने।

कोड परिवर्तन:early stopping और input scaling शामिल करने के लिए।

# input scaling 
scaler = StandardScaler() 
X = scaler.fit_transform(X) 

# Early stopping 
early_stop = EarlyStopping(monitor='val_loss', min_delta=0, patience=3, verbose=1, mode='auto') 

# create model - almost the same code 
model = Sequential() 
model.add(Dense(12, input_dim=8, activation='relu', name='first_input')) 
model.add(Dense(500, activation='relu', name='first_hidden')) 
model.add(Dropout(0.5, name='dropout_1')) 
model.add(Dense(8, activation='relu', name='second_hidden')) 
model.add(Dense(1, activation='sigmoid', name='output_layer'))) 

history = model.fit(X, Y, validation_split=0.33, epochs=1000, batch_size=10, verbose=0, callbacks=[tb, early_stop]) 

Accuracy और loss रेखांकन:

Answer 2

के लिए के लिए रेखांकन कर रहे हैं मधुमेह की तरह एक डेटासेट एक आप एक बहुत ही सरल नेटवर्क का उपयोग कर सकते हैं। अपनी दूसरी परत में न्यूरॉन्स को कम करने का प्रयास करें। (क्या कोई विशिष्ट कारण है कि आपने तन्ह को सक्रियण के रूप में क्यों चुना?)।

इसके अलावा आप बस अपने प्रशिक्षण के लिए एक EarlyStopping कॉलबैक जोड़ सकते हैं: https://keras.io/callbacks/

Answer 3

सबसे पहले, इस कोड के साथ जैसे कुछ नियमितीकरण (https://keras.io/regularizers/) जोड़ने का प्रयास करें:

model.add(Dense(12, input_dim=12, 
      kernel_regularizer=regularizers.l2(0.01), 
      activity_regularizer=regularizers.l1(0.01))) 

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