Bei kaggle verwenden die meisten Top-Leute das Stapeln. Ich möchte auch in die oberen Ränge kommen, also habe ich das Stapeln studiert. Hier kann beim Stapeln der zu verwendende Code durch Kopieren verwendet werden. (Es ist jedoch auf das Regressionsproblem beschränkt)
Diesmal handelt es sich um eine zweischichtige Stapelung.
Das verwendete maschinelle Lernen war irgendwie
・ XGBoost ・ LightGBM ・ Catboost ・ MLP (versteckte Schicht 2) ・ Lineare SVR ・ Kernel SVR (rbf) ・ KNN ・ Lasso ・ Ridge ・ ElasticNet ・ Zufälliger Wald
Die Hyperparameter sind nicht richtig eingestellt. Wenn Sie jedoch beim Stapeln die Sammlung zu stark anpassen, werden Sie überlernen. Es besteht die Möglichkeit, dass die Genauigkeit der Testdaten verringert wird. Es ist ein schwieriger Ort.
Unten ist die Vorlage. Durch Erstellen einer Klasse ・ Beim Lernen fit ・ Bei der Vorhersage vorhersagen Es ist sehr praktisch, weil es mit vereinheitlicht werden kann (ich habe es nur nachgeahmt)
Darüber hinaus können alle durch Kopieren und Einfügen verwendet werden (sollte).
XGBoost
import xgboost as xgb
class Model1Xgb:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
xgb_params = {'objective': 'reg:squarederror', #binary:logistic #multi:softprob,
'random_state': 10,
#'eval_metric': 'rmse'
}
dtrain = xgb.DMatrix(tr_x, label=tr_y)
dvalid = xgb.DMatrix(va_x, label=va_y)
evals = [(dtrain, 'train'), (dvalid, 'eval')]
self.model = xgb.train(xgb_params, dtrain, num_boost_round=10000,early_stopping_rounds=50, evals=evals)
def predict(self, x):
data = xgb.DMatrix(x)
pred = self.model.predict(data)
return pred
LightGBM
import lightgbm as lgb
class Model1lgb:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
lgb_params = {'objective': 'rmse',
'random_state': 10,
'metric': 'rmse'}
lgb_train = lgb.Dataset(tr_x, label=tr_y)
lgb_eval = lgb.Dataset(va_x, label=va_y,reference=lgb_train)
self.model = lgb.train(lgb_params, lgb_train, valid_sets=lgb_eval, num_boost_round=10000,early_stopping_rounds=50)
def predict(self, x):
pred = self.model.predict(x,num_iteration=self.model.best_iteration)
return pred
Catboost
import catboost
class Model1catboost:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
#https://catboost.ai/docs/concepts/python-reference_catboostregressor.html
#catb = catboost.CatBoostClassifier(
catb = catboost.CatBoostRegressor(
iterations=10000,
use_best_model=True,
random_seed=10,
l2_leaf_reg=3,
depth=6,
loss_function="RMSE",#"CrossEntropy",
#eval_metric = "RMSE", #'AUC',
#classes_coun=3
)
self.model = catb.fit(tr_x,tr_y,eval_set=(va_x,va_y),early_stopping_rounds=50)
print(self.model.score(va_x,va_y))
def predict(self, x):
pred = self.model.predict(x)
return pred
Multi-layer Perceptron(MLP) Diesmal handelt es sich um ein 4-lagiges neuronales Netz.
rom keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.callbacks import EarlyStopping
class Model1NN:
def __init__(self):
self.model = None
self.scaler = None
def fit(self, tr_x, tr_y, va_x, va_y):
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
batch_size = 128
epochs = 10000
tr_x = self.scaler.transform(tr_x)
va_x = self.scaler.transform(va_x)
early_stopping = EarlyStopping(
monitor='val_loss',
min_delta=0.0,
patience=20,
)
model = Sequential()
model.add(Dense(32, activation='relu', input_shape=(tr_x.shape[1],)))
model.add(Dropout(0.5))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='mean_squared_error',
#'categorical_crossentropy',#categorical_crossentropy
optimizer='adam')
history = model.fit(tr_x, tr_y,
batch_size=batch_size, epochs=epochs,
verbose=1,
validation_data=(va_x, va_y),
callbacks=[early_stopping])
self.model = model
def predict(self, x):
x = self.scaler.transform(x)
pred = self.model.predict_proba(x).reshape(-1)
return pred
Linear SVR
from sklearn.svm import LinearSVR
class Model1LinearSVR:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
tr_x = self.scaler.transform(tr_x)
#params = {"C":np.logspace(0,1,params_cnt),"epsilon":np.logspace(-1,1,params_cnt)}
self.model = LinearSVR(max_iter=1000,
random_state=10,
C = 1.0, #Verlustkoeffizient (Umkehrung des Regularisierungskoeffizienten)
epsilon = 5.0
)
self.model.fit(tr_x,tr_y)
def predict(self,x):
x = self.scaler.transform(x)
pred = self.model.predict(x)
return pred
Kernel SVR
from sklearn.svm import SVR
class Model1KernelSVR:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
tr_x = self.scaler.transform(tr_x)
#params = {"kernel":['rbf'],"C":np.logspace(0,1,params_cnt), "epsilon":np.logspace(-1,1,params_cnt)}
self.model = SVR(kernel='rbf',
gamma='auto',
max_iter=1000,
C = 1.0, #Verlustkoeffizient (Umkehrung des Regularisierungskoeffizienten)
epsilon = 5.0
)
self.model.fit(tr_x,tr_y)
def predict(self,x):
x = self.scaler.transform(x)
pred = self.model.predict(x)
return pred
Lasso
from sklearn.linear_model import Lasso
class Model1Lasso:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
'''
(1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1
#https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Lasso.html
'''
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
tr_x = self.scaler.transform(tr_x)
self.model = Lasso(
alpha=1, #L1-Koeffizient
fit_intercept=True,
max_iter=1000,
random_state=10,
)
self.model.fit(tr_x,tr_y)
def predict(self,x):
x = self.scaler.transform(x)
pred = self.model.predict(x)
return pred
Ridge
from sklearn.linear_model import Ridge
class Model1Ridge:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
'''
|y - Xw||^2_2 + alpha * ||w||^2_2
#https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html
'''
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
tr_x = self.scaler.transform(tr_x)
self.model = Ridge(
alpha=1, #L2-Koeffizient
max_iter=1000,
random_state=10,
)
self.model.fit(tr_x,tr_y)
def predict(self,x):
x = self.scaler.transform(x)
pred = self.model.predict(x)
return pred
ElasticNet
from sklearn.linear_model import ElasticNet
class Model1ElasticNet:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
'''1 / (2 * n_samples) * ||y - Xw||^2_2
+ alpha * l1_ratio * ||w||_1
+ 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2
ref) https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.ElasticNet.html
'''
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
tr_x = self.scaler.transform(tr_x)
self.model = ElasticNet(
alpha=1, #L1-Koeffizient
l1_ratio=0.5,
)
self.model.fit(tr_x,tr_y)
def predict(self,x):
x = self.scaler.transform(x)
pred = self.model.predict(x)
return pred
RandomForest
from sklearn.ensemble import RandomForestRegressor
class Model1RF:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
tr_x = self.scaler.transform(tr_x)
self.model = RandomForestRegressor(
max_depth=5,
n_estimators=100,
random_state=10,
)
self.model.fit(tr_x,tr_y)
def predict(self,x):
x = self.scaler.transform(x)
pred = self.model.predict(x)
return pred
from sklearn.neighbors import KNeighborsRegressor
class Model1KNN:
def __init__(self):
self.model = None
def fit(self, tr_x, tr_y, va_x, va_y):
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
tr_x = self.scaler.transform(tr_x)
#params = {"kernel":['rbf'],"C":np.logspace(0,1,params_cnt), "epsilon":np.logspace(-1,1,params_cnt)}
self.model = KNeighborsRegressor(n_neighbors=5,
#weights='uniform'
)
self.model.fit(tr_x,tr_y)
def predict(self,x):
x = self.scaler.transform(x)
pred = self.model.predict(x)
return pred
from sklearn.linear_model import LinearRegression
class Model2Linear:
def __init__(self):
self.model = None
self.scaler = None
def fit(self, tr_x, tr_y, va_x, va_y):
self.scaler = StandardScaler()
self.scaler.fit(tr_x)
tr_x = self.scaler.transform(tr_x)
self.model = LinearRegression()
self.model.fit(tr_x, tr_y)
def predict(self, x):
x = self.scaler.transform(x)
pred = self.model.predict(x)
return pred
Out-of-fold Dieses Mal ist es in 4 Falten und außerhalb der Falte unterteilt. Es scheint, dass die Falte normalerweise ungefähr 2-5 Falten beträgt. Als ich es 10fold mit entsprechenden Daten versuchte, sank die Genauigkeit. Wenn Sie die Anzahl der Falten zu groß machen, lernen Sie nur mit ähnlichen Datensätzen. Ich frage mich, ob ich die Validierungsdaten überlernen werde.
from sklearn.model_selection import KFold
from sklearn.preprocessing import StandardScaler
def predict_cv(model, train_x, train_y, test_x):
preds = []
preds_test = []
va_idxes = []
kf = KFold(n_splits=4, shuffle=True, random_state=10)
#Lernen und prognostizieren Sie mit Kreuzvalidierung und speichern Sie vorhergesagte Werte und Indizes
for i, (tr_idx, va_idx) in enumerate(kf.split(train_x)):
tr_x, va_x = train_x.iloc[tr_idx], train_x.iloc[va_idx]
tr_y, va_y = train_y.iloc[tr_idx], train_y.iloc[va_idx]
model.fit(tr_x, tr_y, va_x, va_y)
pred = model.predict(va_x)
preds.append(pred)
pred_test = model.predict(test_x)
preds_test.append(pred_test)
va_idxes.append(va_idx)
#Verketten Sie die vorhergesagten Werte für die Validierungsdaten und ordnen Sie sie dann in ihrer ursprünglichen Reihenfolge neu an
va_idxes = np.concatenate(va_idxes)
preds = np.concatenate(preds, axis=0)
order = np.argsort(va_idxes)
pred_train = preds[order]
#Nehmen Sie den Durchschnitt der vorhergesagten Werte für die Testdaten
preds_test = np.mean(preds_test, axis=0)
return pred_train, preds_test
Beim Erstellen von train_x_2 und test_x_2 (untere Zeile) ändert sich die Genauigkeit erheblich, je nachdem, welche Daten verwendet werden. Es ist unerwartet interessant, verschiedene Kombinationen auszuprobieren und die Genauigkeit selbst zu überprüfen. Dieses Mal war es genauer, pred_1d (LinearSVR) auszuschließen, also habe ich es entfernt.
model_1a = Model1Xgb()
pred_train_1a, pred_test_1a = predict_cv(model_1a, df_trainval, y_trainval, df_test)
model_1b = Model1lgb()
pred_train_1b, pred_test_1b = predict_cv(model_1b, df_trainval, y_trainval, df_test)
model_1c = Model1NN()
pred_train_1c, pred_test_1c = predict_cv(model_1c, df_trainval, y_trainval, df_test)
model_1d = Model1LinearSVR()
pred_train_1d, pred_test_1d = predict_cv(model_1d, df_trainval, y_trainval, df_test)
model_1e = Model1KernelSVR()
pred_train_1e, pred_test_1e = predict_cv(model_1e, df_trainval, y_trainval, df_test)
model_1f = Model1catboost()
pred_train_1f, pred_test_1f = predict_cv(model_1f, df_trainval, y_trainval, df_test)
model_1g = Model1KNN()
pred_train_1g, pred_test_1g = predict_cv(model_1g, df_trainval, y_trainval, df_test)
model_1h = Model1Lasso()
pred_train_1h, pred_test_1h = predict_cv(model_1h, df_trainval, y_trainval, df_test)
model_1i = Model1Ridge()
pred_train_1i, pred_test_1i = predict_cv(model_1i, df_trainval, y_trainval, df_test)
model_1j = Model1ElasticNet()
pred_train_1j, pred_test_1j = predict_cv(model_1j, df_trainval, y_trainval, df_test)
model_1k = Model1RF()
pred_train_1k, pred_test_1k = predict_cv(model_1k, df_trainval, y_trainval, df_test)
from sklearn.metrics import mean_absolute_error
'''
#Calculate RMSE
from sklearn.metrics import mean_square_error
def rmse(y_true,y_pred):
rmse = np.sqrt(mean_squared_error(y_true,y_pred))
print('rmse',rmse)
return rmse
'''
'''
Nachfolgend wird die Genauigkeit jedes Vorhersagemodells in der ersten Schicht bestätigt.
Diesmal meine_absolute_error(MAE)Überprüfen Sie die Genauigkeit mit
'''
print(f'a LGBM mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1a):.4f}')
print(f'b XGBoostmean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1b):.4f}')
print(f'c MLP mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1c):.4f}')
print(f'd LinearSVR mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1d):.4f}')
print(f'e KernelSVR mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1e):.4f}')
print(f'f Catboost mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1f):.4f}')
print(f'g KNN mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1g):.4f}')
print(f'h Lasso mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1h):.4f}')
print(f'i Ridge mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1i):.4f}')
print(f'j ElasticNet mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1j):.4f}')
print(f'k RandomForest mean_absolute_error: {mean_absolute_error(y_trainval,pred_train_1k):.4f}')
'''
Nachfolgend sind die vorhergesagten Werte der ersten Schicht in einem Datenrahmen zusammengefasst.
Es wird in einem Datenrahmen als Merkmalsmenge der zweiten Schicht zusammengefasst.
'''
train_x_2 = pd.DataFrame({'pred_1a': pred_train_1a,
'pred_1b': pred_train_1b,
'pred_1c': pred_train_1c,
#'pred_1d': pred_train_1d,
'pred_1e': pred_train_1e,
'pred_1f': pred_train_1f,
'pred_1g': pred_train_1g,
'pred_1h': pred_train_1h,
'pred_1i': pred_train_1i,
'pred_1j': pred_train_1j,
'pred_1k': pred_train_1k,
})
test_x_2 = pd.DataFrame({'pred_1a': pred_test_1a,
'pred_1b': pred_test_1b,
'pred_1c': pred_test_1c,
#'pred_1d': pred_test_1d,
'pred_1e': pred_test_1e,
'pred_1f': pred_test_1f,
'pred_1g': pred_test_1g,
'pred_1h': pred_test_1h,
'pred_1i': pred_test_1i,
'pred_1j': pred_test_1j,
'pred_1k': pred_test_1k
})
Dieses Mal wurde nur der vorhergesagte Wert jedes Modells in der ersten Schicht als Merkmalsmenge in der zweiten Schicht festgelegt. Es gibt verschiedene Möglichkeiten, den Feature-Betrag für die zweite Ebene zu erstellen.
model2 = Model2Linear()
pred_train_2, pred_test_2 = predict_cv(model2, train_x_2, y_trainval, test_x_2)
#Überprüfen Sie die Genauigkeit nach dem Stapeln der beiden Schichten.
print(f'mean_absolute_error: {mean_absolute_error(y_trainval, pred_train_2):.4f}')
Durch das Stapeln wird die Genauigkeit verbessert. Ein starker Kaggler verbindet das Stapeln mit 3 oder 4 Schichten. Die Genauigkeit wird erhöht, indem die Anzahl der Schichten auf 3 oder 4 erhöht wird. Im Allgemeinen nimmt der Verbesserungsgrad mit jeder Schicht ab.
Anstatt sich Gedanken über Stapelmethoden zu machen Es ist einfacher, die Genauigkeit zu verbessern, wenn Sie selbst eine Feature-Menge erstellen und eine gute Feature-Menge finden. Anstatt mich auf das Stapeln zu verlassen, möchte ich mein Bestes geben, um selbst gute Funktionen zu erstellen.
Referenz) Datenanalysetechnologie, die mit Kaggle gewinnt https://github.com/ghmagazine/kagglebook/tree/master/ch07
Wenn Sie einen Fehler machen Danke für deinen Kommentar.
Recommended Posts