मैं मशीन लर्निंग में नया हूं और रिग्रेशन आउटपुट के लिए एक न्यूरल नेटवर्क बनाया है। मेरे पास ~ 95000 प्रशिक्षण उदाहरण और ~ 24000 परीक्षण उदाहरण हैं। मैं जानना चाहता हूं कि मैं अपने मॉडल का मूल्यांकन कैसे कर सकता हूं और ट्रेन और परीक्षण त्रुटियां कैसे प्राप्त कर सकता हूं? इस प्रतिगमन मॉडल की सटीकता को कैसे जानें? मेरा Y चर मान 100-200 के बीच है और X में डेटासेट में 9 इनपुट विशेषताएं हैं।

यहाँ मेरा कोड है:

import pandas as pd
from keras.layers import Dense, Activation,Dropout
from keras.models import Sequential
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from matplotlib import pyplot

# Importing the dataset
# Importing the dataset
dataset = pd.read_csv('data2csv.csv')

X = dataset.iloc[:,1:10].values
y = dataset.iloc[:, :1].values

# Splitting the dataset into the Training set and Test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size = 0.2, random_state = 0)

# Feature Scaling
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)

# Initialising the ANN
model = Sequential()

# Adding the input layer and the first hidden layer

model.add(Dense(10, activation = 'relu', input_dim = 9))

# Adding the second hidden layer
model.add(Dense(units = 5, activation = 'sigmoid'))
model.add(Dropout(0.2))

# Adding the third hidden layer
model.add(Dense(units = 5, activation = 'relu'))
model.add(Dropout(0.2))

model.add(Dense(units = 5, activation = 'relu'))
model.add(Dense(units = 5, activation = 'relu'))

# Adding the output layer

model.add(Dense(units = 1))

#model.add(Dense(1))
# Compiling the ANN
model.compile(optimizer = 'adam', loss = 'mean_squared_error',metrics=['mae','mse','mape','cosine'])

# Fitting the ANN to the Training set
history=model.fit(X_train, y_train,validation_data=(X_val, y_val) ,batch_size = 1000, epochs = 100)
test_loss = model.evaluate(X_test,y_test)

loss = history.history['loss']
acc = history.history['mean_absolute_error']
val_loss = history.history['val_loss']
val_acc = history.history['val_mean_absolute_error']
mape_loss=history.history['mean_absolute_percentage_error']
cosine_los=history.history['cosine_proximity']
pyplot.plot(history.history['mean_squared_error'])
pyplot.plot(history.history['mean_absolute_error'])
pyplot.plot(history.history['mean_absolute_percentage_error'])
pyplot.plot(history.history['cosine_proximity'])
pyplot.show()
epochs = range(1, len(loss)+1)
plt.plot(epochs, loss, 'ro', label='Training loss')
plt.legend()
plt.show()

y_pred = model.predict(X_test)

plt.plot(y_test, color = 'red', label = 'Real data')
plt.plot(y_pred, color = 'blue', label = 'Predicted data')
plt.title('Prediction')
plt.legend()
plt.show()

[Results]

Model.evaluate के बाद मेरा परीक्षण नुकसान। ध्यान दें कि यहां 5 हानि कार्य हैं जैसा कि कोड में दिखाया गया है।

1) 84.69654303799824 2) 7.03016996963975834 3) 84.69654303799824 4) 5.2418552823133331 5) -0.9999999996023872

-1
user123098 24 अगस्त 2018, 12:35

2 जवाब

अपने मॉडल का मूल्यांकन करने के लिए आप evaluate विधि का उपयोग कर सकते हैं:

test_loss = model.evaluate(X_test, y_test)

यह प्रशिक्षण के दौरान आपके द्वारा उपयोग किए गए समान हानि फ़ंक्शन (यानी mean_squared_error) का उपयोग करके गणना किए गए दिए गए परीक्षण डेटा पर नुकसान देता है। इसके अलावा, यदि आप प्रत्येक युग के अंत में प्रशिक्षण हानि प्राप्त करना चाहते हैं तो आप History ऑब्जेक्ट जो लौटाया जाता है fit विधि द्वारा:

history = model.fit(...)
loss = history.history['loss']

loss प्रत्येक युग के अंत में प्रशिक्षण के नुकसान मूल्यों वाली एक सूची है। यदि आपने मॉडल को प्रशिक्षित करते समय सत्यापन डेटा का उपयोग किया है (यानी model.fit(..., validation_data=(X_val, y_val)) या किसी अन्य मीट्रिक जैसे mean_absolute_error (यानी model.compile(..., metrics=['mae'])) का उपयोग किया है, तो आप उनके मूल्यों तक भी पहुंच सकते हैं:

acc = history.history['mae']
val_loss = history.history['val_loss']
val_acc = history.history['val_mae']

बोनस: प्रशिक्षण हानि वक्र की साजिश रचने के लिए:

epochs = range(1, len(loss)+1)
plt.plot(epochs, loss, 'ro', label='Training loss')
plt.legend()
plt.show()
1
today 24 अगस्त 2018, 17:54
धन्यवाद। इन परिणामों को देखने के बाद कैसे समझें कि मेरा मॉडल अच्छा है?
 – 
user123098
24 अगस्त 2018, 16:55
खैर, यह पूरी तरह से उस समस्या पर निर्भर करता है जिस पर आप काम कर रहे हैं और आप "अच्छे" नुकसान को क्या परिभाषित करते हैं। बेशक, नुकसान के रूप में mean_squared_error का उपयोग करने के मामले में, शून्य के करीब होना बेहतर है। हालांकि, उदाहरण के लिए, यदि आप कल के तापमान का अनुमान लगाने की कोशिश कर रहे हैं, तो एक के औसत वर्ग नुकसान का मतलब है कि आपके पूर्वानुमान औसतन एक डिग्री कम हैं। आप इस सटीकता को "उत्कृष्ट", "अच्छा", "बुरा नहीं" या "बस भयानक" मान सकते हैं। मुझे आशा है कि यह स्पष्ट है कि मैं क्या कहना चाह रहा हूं।
 – 
today
24 अगस्त 2018, 17:08
हाँ, मेरा अंतिम युग लगभग 45.7 का नुकसान देता है। मेरा डेटासेट बहुत बड़ा है और इसमें एक आश्रित चर Y है जो X की 9 इनपुट विशेषताओं पर निर्भर करता है। क्या आप मुझे कुछ सुझा सकते हैं?
 – 
user123098
24 अगस्त 2018, 17:18
मैं आपको कुछ नहीं बता सकता। 45.7 के MSE का अर्थ है sqrt(45.7) ~= 6.8 की औसत त्रुटि। क्या 6.8 त्रुटि अच्छी मानी जाती है? खैर, मैं केवल इतना कह सकता हूं कि यदि Y मान बड़े हैं तो (उदाहरण के लिए [1000, 10000] की सीमा में) तो औसत त्रुटि बहुत अच्छी है। अन्यथा यदि वे बहुत छोटे हैं (जैसे [1-10] या [0-1]) तो यह अच्छा नहीं है और आपको अपने मॉडल के आर्किटेक्चर या मापदंडों को संशोधित करने या अधिक प्रशिक्षण डेटा एकत्र करने की आवश्यकता है। आपको एक सत्यापन सेट को परिभाषित करना चाहिए और प्रशिक्षण त्रुटि और सत्यापन त्रुटि की तुलना करनी चाहिए। यदि प्रशिक्षण त्रुटि बहुत छोटी है और सत्यापन त्रुटि बड़ी है तो आप >>>> . हैं
 – 
today
24 अगस्त 2018, 17:31
ओवरफिटिंग। ओवरफिटिंग को रोकने के लिए आप नियमितीकरण जोड़ सकते हैं, अधिक प्रशिक्षण डेटा एकत्र कर सकते हैं, नेटवर्क का आकार कम कर सकते हैं, आदि। BTW, मैं मूल्यांकन करते समय आपको मिलने वाली त्रुटि को नहीं समझ सका। क्या आप मूल्यांकन भाग को शामिल करने के लिए अपने प्रश्न में कोड अपडेट कर सकते हैं? और कृपया वहां आपको जो त्रुटि मिलती है उसका उल्लेख करें,
 – 
today
24 अगस्त 2018, 17:33

प्रशिक्षण के दौरान सत्यापन हानि दिखाने के लिए:

model.fit(X_train, y_train, batch_size = 1000, epochs = 100, validation_data = (y_train,y_test))

मुझे नहीं लगता कि आप प्लॉटिंग द्वारा आसानी से सटीकता प्राप्त कर सकते हैं, क्योंकि आपका इनपुट 9 डायमेंशनल है, आप प्रत्येक फीचर के लिए अनुमानित y प्लॉट कर सकते हैं, बस डॉट्स से जुड़ने वाली लाइनों को बंद कर दें यानी plt.plot(x,y,'k) .') नोट 'के' तो कोई लाइन नहीं है, लेकिन मुझे यकीन नहीं है कि यह उपयोगी होगा या नहीं।

0
liyuan 24 अगस्त 2018, 13:28