Xác thực chéo lồng nhau và chọn mô hình hồi quy tốt nhất - đây có phải là quy trình SKLearn đúng không?

Nếu tôi hiểu chính xác, lồng nhau-CV có thể giúp tôi đánh giá mô hình và quy trình điều chỉnh siêu tham số nào là tốt nhất. Vòng lặp bên trong ( GridSearchCV) tìm ra các siêu đường kính tốt nhất và vòng lặp outter ( cross_val_score) đánh giá thuật toán điều chỉnh siêu tham số. Sau đó, tôi chọn kết hợp điều chỉnh / mô hình nào từ vòng lặp bên ngoài để giảm thiểu mse(tôi đang xem phân loại hồi quy) cho thử nghiệm mô hình cuối cùng của mình.

Tôi đã đọc các câu hỏi / câu trả lời về xác thực chéo lồng nhau, nhưng chưa thấy một ví dụ nào về một đường ống dẫn đầy đủ sử dụng điều này. Vì vậy, mã của tôi dưới đây (xin vui lòng bỏ qua các phạm vi siêu tham số thực tế - đây chỉ là ví dụ) và quá trình suy nghĩ có ý nghĩa?

from sklearn.cross_validation import cross_val_score, train_test_split
from sklearn.grid_search import GridSearchCV
from sklearn.metrics import mean_squared_error
from sklearn.ensemble import RandomForestRegressor
from sklearn.svm import SVR
from sklearn.datasets import make_regression

# create some regression data
X, y = make_regression(n_samples=1000, n_features=10)
params = [{'C':[0.01,0.05,0.1,1]},{'n_estimators':[10,100,1000]}]

# setup models, variables
mean_score = []
models = [SVR(), RandomForestRegressor()]

# split into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.3)

# estimate performance of hyperparameter tuning and model algorithm pipeline
for idx, model in enumerate(models):
    clf = GridSearchCV(model, params[idx], scoring='mean_squared_error')

    # this performs a nested CV in SKLearn
    score = cross_val_score(clf, X_train, y_train, scoring='mean_squared_error')

    # get the mean MSE across each fold
    mean_score.append(np.mean(score))
    print('Model:', model, 'MSE:', mean_score[-1])

# estimate generalization performance of the best model selection technique
best_idx = mean_score.index(max(mean_score)) # because SKLearn flips MSE signs, max works OK here
best_model = models[best_idx]

clf_final = GridSearchCV(best_model, params[best_idx])
clf_final.fit(X_train, y_train)

y_pred = clf_final.predict(X_test)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))

print('Final Model': best_model, 'Final model RMSE:', rmse)

Của bạn không phải là một ví dụ về xác nhận chéo lồng nhau.

Xác thực chéo lồng nhau rất hữu ích để tìm hiểu xem, một khu rừng ngẫu nhiên hoặc một SVM phù hợp hơn cho vấn đề của bạn. CV lồng nhau chỉ xuất ra một số điểm, nó không xuất ra một mô hình như trong mã của bạn.

Đây sẽ là một ví dụ về xác nhận chéo lồng nhau:

from sklearn.datasets import load_boston
from sklearn.cross_validation import KFold
from sklearn.metrics import mean_squared_error
from sklearn.grid_search import GridSearchCV
from sklearn.ensemble import RandomForestRegressor
from sklearn.svm import SVR
import numpy as np

params = [{'C': [0.01, 0.05, 0.1, 1]}, {'n_estimators': [10, 100, 1000]}]
models = [SVR(), RandomForestRegressor()]

df = load_boston()
X = df['data']
y = df['target']

cv = [[] for _ in range(len(models))]
for tr, ts in KFold(len(X)):
    for i, (model, param) in enumerate(zip(models, params)):
        best_m = GridSearchCV(model, param)
        best_m.fit(X[tr], y[tr])
        s = mean_squared_error(y[ts], best_m.predict(X[ts]))
        cv[i].append(s)
print(np.mean(cv, 1))

Nhân tiện, một vài suy nghĩ:

• Tôi thấy không có mục đích tìm kiếm lưới cho n_estimatorskhu rừng ngẫu nhiên của bạn. Rõ ràng, càng nhiều, càng tốt. Những thứ như max_depthlà loại chính quy mà bạn muốn tối ưu hóa. Lỗi cho CV lồng nhau RandomForestcao hơn nhiều do bạn không tối ưu hóa cho các siêu đường kính phù hợp, không nhất thiết vì đó là một mô hình tồi tệ hơn.
• Bạn cũng có thể muốn thử cây tăng cường độ dốc.

Xác thực chéo lồng nhau ước tính lỗi tổng quát hóa của một mô hình, vì vậy đây là một cách tốt để chọn mô hình tốt nhất từ ​​danh sách các mô hình ứng cử viên và lưới tham số liên quan của chúng. Bài đăng gốc gần giống với thực hiện CV lồng nhau: thay vì thực hiện phân tách kiểm tra Train train đơn, thay vào đó, người ta nên sử dụng bộ chia xác thực chéo thứ hai. Đó là, một "tổ" một bộ tách xác thực chéo "bên trong" bên trong bộ chia xác thực chéo "bên ngoài".

Bộ chia xác thực chéo bên trong được sử dụng để chọn siêu đường kính. Bộ chia xác thực chéo bên ngoài tính trung bình lỗi kiểm tra trên nhiều lần phân tách kiểm tra của Train. Tính trung bình lỗi tổng quát hóa trên nhiều phân tách kiểm tra đào tạo cung cấp ước tính đáng tin cậy hơn về độ chính xác của mô hình trên dữ liệu chưa xem.

Tôi đã sửa đổi mã của bài đăng gốc để cập nhật nó lên phiên bản mới nhất sklearn(được sklearn.cross_validationthay thế bởi sklearn.model_selectionvà được 'mean_squared_error'thay thế bởi 'neg_mean_squared_error') và tôi đã sử dụng hai KFoldbộ tách xác thực chéo để chọn mô hình tốt nhất. Để tìm hiểu thêm về kiểm chứng chéo lồng nhau, xem sklearn's ví dụ về lồng nhau qua xác nhận .

from sklearn.model_selection import KFold, cross_val_score, GridSearchCV
from sklearn.datasets import make_regression
from sklearn.ensemble import RandomForestRegressor
from sklearn.svm import SVR
import numpy as np

# `outer_cv` creates 3 folds for estimating generalization error
outer_cv = KFold(3)

# when we train on a certain fold, we use a second cross-validation
# split in order to choose hyperparameters
inner_cv = KFold(3)

# create some regression data
X, y = make_regression(n_samples=1000, n_features=10)

# give shorthand names to models and use those as dictionary keys mapping
# to models and parameter grids for that model
models_and_parameters = {
    'svr': (SVR(),
            {'C': [0.01, 0.05, 0.1, 1]}),
    'rf': (RandomForestRegressor(),
           {'max_depth': [5, 10, 50, 100, 200, 500]})}

# we will collect the average of the scores on the 3 outer folds in this dictionary
# with keys given by the names of the models in `models_and_parameters`
average_scores_across_outer_folds_for_each_model = dict()

# find the model with the best generalization error
for name, (model, params) in models_and_parameters.items():
    # this object is a regressor that also happens to choose
    # its hyperparameters automatically using `inner_cv`
    regressor_that_optimizes_its_hyperparams = GridSearchCV(
        estimator=model, param_grid=params,
        cv=inner_cv, scoring='neg_mean_squared_error')

    # estimate generalization error on the 3-fold splits of the data
    scores_across_outer_folds = cross_val_score(
        regressor_that_optimizes_its_hyperparams,
        X, y, cv=outer_cv, scoring='neg_mean_squared_error')

    # get the mean MSE across each of outer_cv's 3 folds
    average_scores_across_outer_folds_for_each_model[name] = np.mean(scores_across_outer_folds)
    error_summary = 'Model: {name}\nMSE in the 3 outer folds: {scores}.\nAverage error: {avg}'
    print(error_summary.format(
        name=name, scores=scores_across_outer_folds,
        avg=np.mean(scores_across_outer_folds)))
    print()

print('Average score across the outer folds: ',
      average_scores_across_outer_folds_for_each_model)

many_stars = '\n' + '*' * 100 + '\n'
print(many_stars + 'Now we choose the best model and refit on the whole dataset' + many_stars)

best_model_name, best_model_avg_score = max(
    average_scores_across_outer_folds_for_each_model.items(),
    key=(lambda name_averagescore: name_averagescore[1]))

# get the best model and its associated parameter grid
best_model, best_model_params = models_and_parameters[best_model_name]

# now we refit this best model on the whole dataset so that we can start
# making predictions on other data, and now we have a reliable estimate of
# this model's generalization error and we are confident this is the best model
# among the ones we have tried
final_regressor = GridSearchCV(best_model, best_model_params, cv=inner_cv)
final_regressor.fit(X, y)

print('Best model: \n\t{}'.format(best_model), end='\n\n')
print('Estimation of its generalization error (negative mean squared error):\n\t{}'.format(
    best_model_avg_score), end='\n\n')
print('Best parameter choice for this model: \n\t{params}'
      '\n(according to cross-validation `{cv}` on the whole dataset).'.format(
      params=final_regressor.best_params_, cv=inner_cv))

Bạn không cần

# this performs a nested CV in SKLearn
score = cross_val_score(clf, X_train, y_train, scoring='mean_squared_error')

GridSearchCVlàm điều này cho bạn. Để có được trực giác của quá trình tìm kiếm lưới, hãy thử sử dụng GridSearchCV(... , verbose=3)

Để trích xuất điểm cho mỗi lần, hãy xem ví dụ này trong tài liệu tìm hiểu scikit