如何处理MLPRegressor中简单（X，Y）数据的过拟合问题

Question

ResultResult2解决

处理少量数据，并处理带有折叠的过度拟合[GridSearchCV]

我完全困惑于如何从模型中获得更好的估计。看来，当我尝试运行我的代码时，我获得了负面的准确性。如何提高cross_val_score或测试成绩或任何您想称呼的分数，以便我可以更可靠地预测值。

我尝试添加更多数据（从50到200 +）。

我尝试了随机参数（并意识到这是一种天真的方法）

我还尝试使用StandardScaler清除功能上的数据

有人有什么建议吗？

from sklearn.neural_network import MLPRegressor
from sklearn import preprocessing
import requests
import json
from calendar import monthrange
import numpy as np
from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.preprocessing import scale


r =requests.get('https://www.alphavantage.co/query?function=TIME_SERIES_WEEKLY_ADJUSTED&symbol=W&apikey=QYQ2D6URDOKNUGF4')

#print(r.text)

y = json.loads(r.text)
#print(y["Monthly Adjusted Time Series"].keys())

keysInResultSet = y["Weekly Adjusted Time Series"].keys()
#print(keysInResultSet)

featuresListTemp = []
labelsListTemp = []

count = 0;

for i in keysInResultSet: 
    #print(i)
    count = count + 1;
    #print(y["Monthly Adjusted Time Series"][i])
    tmpList = []
    tmpList.append(count)
    featuresListTemp.append(tmpList)
    strValue = y["Weekly Adjusted Time Series"][i]["5. adjusted close"]
    numValue = float(strValue)
    labelsListTemp.append(numValue)


print("TOTAL SET")
print(featuresListTemp)
print(labelsListTemp)
print("---")

arrTestInput = []
arrTestOutput = []


print("SCALING SET")
X_train = np.array(featuresListTemp)
scaler = preprocessing.StandardScaler().fit(X_train)

X_train_scaled = scaler.transform(X_train)
print(X_train_scaled)


product_model = MLPRegressor()
#10.0 ** -np.arange(1, 10)

#todo : once found general settings, iterate through some more seeds to find one that can be used on the training

parameters = {'learning_rate': ['constant','adaptive'],'solver': ['lbfgs','adam'], 'tol' : 10.0 ** -np.arange(1, 4), 'verbose' : [True], 'early_stopping': [True], 'activation' : ['tanh','logistic'], 'learning_rate_init': 10.0 ** -np.arange(1, 4), 'max_iter': [4000], 'alpha': 10.0 ** -np.arange(1, 4), 'hidden_layer_sizes':np.arange(1,11), 'random_state':np.arange(1, 3)}
clf = GridSearchCV(product_model, parameters, n_jobs=-1)
clf.fit(X_train_scaled, labelsListTemp)
print(clf.score(X_train_scaled, labelsListTemp))
print(clf.best_params_)

best_params = clf.best_params_


newPM = MLPRegressor(hidden_layer_sizes=((best_params['hidden_layer_sizes'])), #try reducing the layer size / increasing it and playing around with resultFit variable
                                     batch_size='auto',
                                     power_t=0.5,
                                     activation=best_params['activation'],
                                     solver=best_params['solver'], #non scaled input
                                     learning_rate=best_params['learning_rate'],
                                     max_iter=best_params['max_iter'],
                                     learning_rate_init=best_params['learning_rate_init'],
                                     alpha=best_params['alpha'],
                                     random_state=best_params['random_state'],
                                     early_stopping=best_params['early_stopping'],
                                     tol=best_params['tol'])

scores = cross_val_score(newPM, X_train_scaled, labelsListTemp, cv=10, scoring='neg_mean_absolute_error')
print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))

print(scores)

63行及以下的输出

0.9142644531564619 {'activation'：'logistic'，'alpha'：0.001，'early_stopping'：True，'hidden_​​layer_sizes'：7，'learning_rate'：'constant'，'learning_rate_init'：0.1，'max_iter'：4000，'random_state'：2，'solver'：'lbfgs'，'tol'：0.01，'verbose'：True}]

准确度：-21.91（+/- 58.89）[-32.87854574 -105.0632913-22.89836453 -7.33154414 -22.38773819 -3.3786339 -1.7658796 -3.78002866 -4.78734308 -14.81212738]

Answer 1

{''activation'：'logistic'，'alpha'：0.01，'early_stopping'：True，'hidden_​​layer_sizes'：30，'learning_rate'：'constant'，'learning_rate_init'：0.1，'max_iter'：4000，' random_state'：2，“ solver”：“ lbfgs”，“ tol”：0.1，“ verbose”：True}

{''activation'：'tanh'，'alpha'：0.01，'early_stopping'：True，'hidden_​​layer_sizes'：99，'learning_rate'：'constant'，'learning_rate_init'：0.1，'max_iter'：4000，' random_state'：1，“ solver”：“ lbfgs”，“ tol”：0.01，“ verbose”：True}

上述两种配置都适用于样品组。谢谢，如果有任何疑问，请告诉我。这可以通过按比例缩小所有其他参数来解决。而不是10.0 ** -np.arange（1，3）做10.0 ** -np.arange（1，2）

限定为一组。开始删除您知道正确的参数（很难做到，但是可能是learning_rate ='constant'，因为我注意到我最合适的结果是学习速率恒定，而与其他任何参数无关。）

这主要是为了优化时间，但是随着网络中节点数量的增加，过拟合也将有所帮助。这样做的想法是，在执行第一次网格搜索后，您希望将拟合度增加一些N度，而又不会失去true函数的泛化属性。]

您应该开始进行网格搜索，以确保隐藏节点的数量介于输入节点的数量和输出节点的数量之间。

一旦找到合适的拟合度，就可以通过增加节点数来提高拟合度。您必须注意不要添加太多节点，以免失去true函数的泛化能力。在甚至开始考虑扩大规模之前，您必须开始降低参数的复杂度，以便在第二个网格搜索中，将在带有更多常规参数的更多节点上执行它。

上面通过第二个网格搜索描述了参数的一般化，同时考虑了来自初始搜索的更多通用参数，同时增加了网络节点。

我知道这很令人困惑，但这正是帮助我体面地适应的原因。

对于任何挣扎的人，我会尽量0）在执行搜索并获得合适的模型后进行概括1）在具有增加节点的第二次搜索中使用归纳2）在放大的同时使用alpha参数（其余参数可以一概而论）3）根据情况添加一些其他种子或将其删除