kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,162,481 | del group
gc.collect()<merge> | submission.to_csv("submission.csv", index=False ) | Tabular Playground Series - Jan 2021 |
14,162,481 | <set_options><EOS> | oof_df = pd.DataFrame({"lgb":oof,
"xgb":oof_xgb,
"cb":oof_cb})
oof_df["pred"] = oof_df.mean(axis="columns" ) | Tabular Playground Series - Jan 2021 |
14,128,879 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<concatenate> | import numpy as np
import pandas as pd | Tabular Playground Series - Jan 2021 |
14,128,879 | test["date_block_num"] = 34
all_data = pd.concat([train, test.drop("ID", axis=1)], ignore_index=True, keys=index_feats)
all_data = all_data.fillna(0)
all_data.sample(10 )<merge> | train_data = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv')
test_data = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
print('Train: ', train_data.shape)
print('Test: ', test_data.shape ) | Tabular Playground Series - Jan 2021 |
14,128,879 | all_data = pd.merge(all_data, shops, on="shop_id", how="left")
all_data = pd.merge(all_data, items, on="item_id", how="left")
all_data = pd.merge(all_data, categories, on="category_id", how="left")
all_data.sample(10 )<drop_column> | y = train_data['target']
X = train_data.drop(columns=['target', 'id'])
X_test = test_data.drop(columns='id' ) | Tabular Playground Series - Jan 2021 |
14,128,879 | all_data = downcast1(all_data)
del shops, items, categories
gc.collect()<merge> | X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size = 0.05, random_state=22 ) | Tabular Playground Series - Jan 2021 |
14,128,879 | def add_mean_feats(df, mean_feats, index_features, agg_col="item_cnt_month", agg_func="mean"):
if len(index_features)== 2:
feature_name = index_features[1] + f"_{agg_col}_{agg_func}"
else:
feature_name = index_features[1] + "_" + index_features[2] + f"_{agg_col}_{agg_func}"
group = df.groupby(index_features ).agg({ag... | params = {'objective': 'regression',
'metric': 'rmse',
'verbosity': -1,
'boosting_type': 'gbdt',
'feature_pre_filter': False,
'learning_rate': 0.007,
'num_leaves': 102,
'min_child_samples': 20,
'sub_feature': 0.4,
'sub_row': 1,
'subsample_freq': 0,
'lambda_l1': 4.6,
'lambda_l2': 1.9}
N_FOLDS = 10
kf = KFold(n_splits = ... | Tabular Playground Series - Jan 2021 |
14,128,879 | item_mean_features = []
all_data, item_mean_features = add_mean_feats(all_data, item_mean_features, ["date_block_num", "item_id"])
all_data<feature_engineering> | output = pd.DataFrame({"id":test_data.id, "target":preds})
output.to_csv('submission.csv', index=False ) | Tabular Playground Series - Jan 2021 |
14,128,879 | all_data, item_mean_features = add_mean_feats(all_data, item_mean_features, ["date_block_num", "item_id", "city"] )<feature_engineering> | print('Finish!' ) | Tabular Playground Series - Jan 2021 |
14,070,377 | shop_mean_features = []
all_data, shop_mean_features = add_mean_feats(all_data, shop_mean_features, ["date_block_num", "shop_id", "category_id"] )<drop_column> | warnings.filterwarnings('ignore')
RANDOM_SEED = 123 | Tabular Playground Series - Jan 2021 |
14,070,377 | cat_mean_features = []
all_data, cat_mean_features = add_mean_feats(all_data, cat_mean_features, ["date_block_num", "category_id"] )<feature_engineering> | train = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/train.csv")
test = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/test.csv")
sample = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/sample_submission.csv" ) | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data, cat_mean_features = add_mean_feats(all_data, cat_mean_features, ["date_block_num", "cats_le"] )<merge> | train['magic1'] = train['cont10']/train['cont11']
train['magic2'] = train['cont11']/train['cont10']
train['magic3'] = train['cont1']/train['cont7']
train['magic4'] = train['cont7']/train['cont1']
train['magic5'] = train['cont4']/train['cont6']
test['magic1'] = test['cont10']/test['cont11']
test['magic2'] = test['cont11... | Tabular Playground Series - Jan 2021 |
14,070,377 | def add_lags(df, lag_features, index_features, lag_feature, lags=[1,2,3], clip=False):
df_temp = df[index_features + [lag_feature]].copy()
for i in lags:
feat_name = lag_feature + "_lag" + str(i)
df_temp.columns = index_features + [feat_name]
df_temp["date_block_num"] += i
df = pd.merge(df, df_temp.drop_duplicates()... | train = train.drop('id', axis=1)
test = test.drop('id', axis=1)
X = train.drop('target', axis=1)
y = train.target | Tabular Playground Series - Jan 2021 |
14,070,377 | lag_feats_to_clip = []
index_features = ["date_block_num", "shop_id", "item_id"]
all_data, lag_feats_to_clip = add_lags(all_data, lag_feats_to_clip, index_features, "item_cnt_month", clip=True)
all_data, lag_feats_to_clip = add_lags(all_data, lag_feats_to_clip, index_features, "item_cnt", clip=True)
all_data.sample(1... | cat = CatBoostRegressor(iterations=1000 ) | Tabular Playground Series - Jan 2021 |
14,070,377 | X_test_temp = all_data[all_data["date_block_num"]==34]
X_test_temp[item_mean_features].sum()<categorify> | model = [cat]
for mod in model:
score = cross_val_score(mod, X, y, cv=3, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("CAT RMSE Mean Score: ", np.mean(score)) | Tabular Playground Series - Jan 2021 |
14,070,377 | for item in item_mean_features:
all_data, lag_feats_to_clip = add_lags(all_data, lag_feats_to_clip, index_features, item, clip=True )<categorify> | model = [cat]
for mod in model:
score = cross_val_score(mod, X, y, cv=10, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("CAT RMSE Mean Score: ", np.mean(score)) | Tabular Playground Series - Jan 2021 |
14,070,377 | for shop in shop_mean_features:
all_data, lag_feats_to_clip = add_lags(all_data, lag_feats_to_clip, ["date_block_num", "shop_id", "category_id"],
shop, clip=True)
<drop_column> | lgbm = lightgbm.LGBMRegressor(random_state=RANDOM_SEED, n_jobs=-1, metric= 'rmse' ) | Tabular Playground Series - Jan 2021 |
14,070,377 | for cat in cat_mean_features:
all_data, lag_feats_to_clip = add_lags(all_data, lag_feats_to_clip, ["date_block_num", "category_id"], cat, lags=[1,2,3], clip=True)
<drop_column> | model = [lgbm]
for mod in model:
score = cross_val_score(mod, X, y, cv=3, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("LGBM RMSE Mean Score: ", np.mean(score)) | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data = all_data.drop(item_mean_features, axis=1)
all_data = all_data.drop(shop_mean_features, axis=1)
all_data = all_data.drop(cat_mean_features, axis=1)
all_data = all_data.drop(all_data[all_data["date_block_num"]<3].index )<set_options> | model = [lgbm]
for mod in model:
score = cross_val_score(mod, X, y, cv=10, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("LGBM RMSE Mean Score: ", np.mean(score)) | Tabular Playground Series - Jan 2021 |
14,070,377 | del X_test_temp
gc.collect()<feature_engineering> | xgbr = XGBRegressor(random_state=RANDOM_SEED ) | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data["item_cnt_month_3lag_mean"] = all_data[["item_cnt_month_lag1", "item_cnt_month_lag2", "item_cnt_month_lag3"]].mean(axis=1 )<feature_engineering> | model = [xgbr]
for mod in model:
score = cross_val_score(mod, X, y, cv=3, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("XGB RMSE Mean Score: ", np.mean(score)) | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data[lag_feats_to_clip + ["item_cnt_month_3lag_mean",
"item_cnt_month"]] = all_data[lag_feats_to_clip + ["item_cnt_month_3lag_mean",
"item_cnt_month"]].clip(0,20 )<feature_engineering> | dtrain = lightgbm.Dataset(data=X, label=y)
def hyp_lgbm(num_leaves, feature_fraction, bagging_fraction, max_depth, min_split_gain, min_child_weight, learning_rate):
params = {'application':'regression','num_iterations': 5000,
'early_stopping_round':100, 'metric':'rmse'}
params["num_leaves"] = int(round(num_leaves))
pa... | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data["lag_grad_1"] = all_data["item_cnt_month_lag1"] / all_data["item_cnt_month_lag2"]
all_data["lag_grad_1"] = all_data["lag_grad_1"].replace([np.inf, -np.inf], np.nan ).fillna(0)
all_data["lag_grad_2"] = all_data["item_cnt_month_lag2"] / all_data["item_cnt_month_lag3"]
all_data["lag_grad_2"] = all_data["lag_grad... | pds = {
'num_leaves':(5, 50),
'feature_fraction':(0.2, 1),
'bagging_fraction':(0.2, 1),
'max_depth':(2, 20),
'min_split_gain':(0.001, 0.1),
'min_child_weight':(10, 50),
'learning_rate':(0.01, 0.5),
} | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data["new_items"] = all_data["first_sale_date"] == all_data["date_block_num"]<drop_column> | def cat_hyp(depth, bagging_temperature, l2_leaf_reg, learning_rate):
params = {"iterations": 100,
"loss_function": "RMSE",
"verbose": False}
params["depth"] = int(round(depth))
params["bagging_temperature"] = bagging_temperature
params["learning_rate"] = learning_rate
params["l2_leaf_reg"] = l2_leaf_reg
cat_feat = []
c... | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data["time_since_first_sale"] = all_data["date_block_num"] - all_data["first_sale_date"]
all_data.drop("first_sale_date", inplace=True, axis=1 )<feature_engineering> | pds = {'depth':(4, 10),
'bagging_temperature':(0.1,10),
'l2_leaf_reg':(0.1, 10),
'learning_rate':(0.1, 0.2)
} | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data["month"] = all_data["date_block_num"] % 12<drop_column> | dtrain = xgb.DMatrix(X, y, feature_names=X.columns.values)
def hyp_xgb(max_depth, subsample, colsample_bytree,min_child_weight, gamma, learning_rate):
params = {
'objective': 'reg:squarederror',
'eval_metric':'rmse',
'nthread':-1
}
params['max_depth'] = int(round(max_depth))
params['subsample'] = max(min(subsample, 1)... | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data.drop(["item_cnt"], axis=1, inplace=True )<data_type_conversions> | pds ={
'min_child_weight':(3, 20),
'gamma':(0, 5),
'subsample':(0.7, 1),
'colsample_bytree':(0.1, 1),
'max_depth':(3, 10),
'learning_rate':(0.01, 0.5)
} | Tabular Playground Series - Jan 2021 |
14,070,377 | all_data["category_id"] = all_data["category_id"].astype("int8" )<prepare_x_and_y> | from sklearn.ensemble import StackingRegressor
from sklearn.linear_model import LinearRegression | Tabular Playground Series - Jan 2021 |
14,070,377 | X_train = all_data[all_data["date_block_num"]<33]
y_train = X_train["item_cnt_month"]
X_train = X_train.drop("item_cnt_month", axis=1)
X_val = all_data[all_data["date_block_num"] == 33]
y_val = X_val["item_cnt_month"]
X_val = X_val.drop("item_cnt_month", axis=1)
X_test = all_data[all_data["date_block_num"]==34]
X_tes... | param_lgbm = {
'bagging_fraction': 0.973905385549851,
'feature_fraction': 0.2945585590881137,
'learning_rate': 0.03750332268701348,
'max_depth': int(7.66),
'min_child_weight': int(41.36),
'min_split_gain': 0.04033836353603582,
'num_leaves': int(46.42),
'application':'regression',
'num_iterations': 5000,
'metric': 'rmse... | Tabular Playground Series - Jan 2021 |
14,070,377 | def preds(model, test, name):
prediction = model.predict(test)
df_sub = pd.read_csv(".. /input/competitive-data-science-predict-future-sales/sample_submission.csv")
df_sub["item_cnt_month"] = prediction.clip(0,20)
df_sub.to_csv(f"{name}.csv", index=False)
print("Complete." )<create_dataframe> | from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor, GradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn import svm
import lightgbm | Tabular Playground Series - Jan 2021 |
14,070,377 | params = {'metric': 'rmse',
'num_leaves': 255,
'learning_rate': 0.005,
'feature_fraction': 0.75,
'bagging_fraction': 0.75,
'bagging_freq': 5,
'force_col_wise' : True,
'random_state': 10,
'num_rounds':1500,
'early_stopping':150}
lgb_train = lgb.Dataset(X_train, y_train)
lgb_val = lgb.Dataset(X_val, y_val)
model = lgb.... | estimators = [
('lgbm', lightgbm.LGBMRegressor(**param_lgbm, random_state=RANDOM_SEED, n_jobs=-1)) ,
('xgbr', XGBRegressor(**param_xgb, random_state=RANDOM_SEED, nthread=-1)) ,
('cat', CatBoostRegressor(**param_cat)) ,
('mlp', MLPRegressor())
] | Tabular Playground Series - Jan 2021 |
14,070,377 | preds(model, X_test, "lgb_model" )<set_options> | reg = StackingRegressor(
estimators=estimators,
final_estimator=LinearRegression() ,
n_jobs=-1,
cv=5
)
reg.fit(X, y)
y_pred = reg.predict(test ) | Tabular Playground Series - Jan 2021 |
14,070,377 | <train_model><EOS> | sample['target'] = y_pred
sample.to_csv("submission.csv", index=False ) | Tabular Playground Series - Jan 2021 |
14,030,995 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<import_modules> | import pandas as pd
import numpy as np
import datetime
import gc
import os
import random
import time
import warnings
import pandas as pd
import numpy as np
import lightgbm as lgb
import xgboost
import catboost
import seaborn as sns
from pandas import DataFrame
from sklearn.metrics import roc_auc_score, f1_score, precis... | Tabular Playground Series - Jan 2021 |
14,030,995 | from glob import glob
from sklearn.model_selection import GroupKFold, StratifiedKFold
import cv2
from skimage import io
import torch
from torch import nn
import torch.nn.functional as F
import os
from datetime import datetime
import time
import random
import cv2
import torchvision
from torchvision import transforms
imp... | train = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/train.csv')
test = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/test.csv')
train.shape,test.shape | Tabular Playground Series - Jan 2021 |
14,030,995 | CFG = {
'fold_num': 5,
'seed': 324,
'model_arch': 'SE-Net',
'img_size': 28,
'epochs': 10,
'train_bs': 16,
'valid_bs': 32,
'T_0': 10,
'lr': 1e-2,
'min_lr': 1e-6,
'weight_decay':1e-6,
'num_workers': 2,
'accum_iter': 4,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 15,
'used_epochs': [8],
'weights': [1,1,1,1,1]
}<load_fro... | label = 'target'
seed = 0
local_test = True
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
seed_everything(seed)
params = {
'objective': 'regression',
'boosting_type': 'gbdt',
'metric': 'rmse',
'n_jobs': -1,
'learning_rate': 0.006,
'num_leaves': 2 ** 8,
'm... | Tabular Playground Series - Jan 2021 |
14,030,995 | submission = pd.read_csv('.. /input/Kannada-MNIST/sample_submission.csv')
submission.head()<categorify> | def make_test(new_features):
features = base_features + new_features
oof_predictions = np.zeros(len(train))
final_predictions = np.zeros(len(test))
cv = KFold(n_splits=10,shuffle=True,random_state=seed)
if local_test:
n_estimators=1000
else:
n_estimators = 10000
lgb = LGBMRegressor(**params,n_estimators=n_estimators,d... | Tabular Playground Series - Jan 2021 |
14,030,995 | <categorify><EOS> | local_test=False
score = [0.6970820000536615, 0.5829603998473519]
make_test([] ) | Tabular Playground Series - Jan 2021 |
13,991,623 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<categorify> | import os
import joblib
import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.metrics... | Tabular Playground Series - Jan 2021 |
13,991,623 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | train_df = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/train.csv')
test_df = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/test.csv')
submission = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/sample_submission.csv' ) | Tabular Playground Series - Jan 2021 |
13,991,623 | class Sq_Ex_Block(nn.Module):
def __init__(self, in_ch, r):
super(Sq_Ex_Block, self ).__init__()
self.se = nn.Sequential(
GlobalAvgPool() ,
nn.Linear(in_ch, in_ch//r),
nn.ReLU(inplace=True),
nn.Linear(in_ch//r, in_ch),
nn.Sigmoid()
)
def forward(self, x):
se_weight = self.se(x ).unsqueeze(-1 ).unsqueeze(-1)
return ... | features = [feature for feature in train_df.columns if feature not in ['id', 'target']]
X_train = train_df[features]
y_train = train_df['target']
X_test = test_df[features] | Tabular Playground Series - Jan 2021 |
13,991,623 | seed_everything(CFG['seed'])
test_data = pd.read_csv(".. /input/Kannada-MNIST/test.csv")
test_ds = KMnistDataset(test_data, transforms=get_inference_transforms())
tst_preds = []
device = torch.device(CFG['device'] )<define_variables> | print('Missing value in train dataset:', sum(train_df.isnull().sum()))
print('Missing value in test dataset:', sum(test_df.isnull().sum())) | Tabular Playground Series - Jan 2021 |
13,991,623 | model_paths = ['.. /input/eesm5720/SE-Net_fold_0_9',
'.. /input/eesm5720/SE-Net_fold_1_9',
'.. /input/eesm5720/SE-Net_fold_2_9',
'.. /input/eesm5720/SE-Net_fold_3_9',
'.. /input/eesm5720/SE-Net_fold_4_9',]<load_pretrained> | cv = KFold(n_splits=5, shuffle=True, random_state=42 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | for o, model_path in enumerate(model_paths):
model = SE_Net(in_channels=1 ).to(device)
tst_loader = torch.utils.data.DataLoader(
test_ds,
batch_size=CFG['valid_bs'],
num_workers=CFG['num_workers'],
shuffle=False,
pin_memory=False,
)
print("using the model from {}".format(model_path))
model.load_state_dict(torch.loa... | %%time
lin_reg = LinearRegression()
scores = cross_val_score(lin_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
lin_rmse_scores = np.sqrt(-scores)
print('Linear Regression performance:', lin_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | test_data['label'] = np.argmax(tst_preds, axis=1 )<create_dataframe> | %%time
tree_reg = DecisionTreeRegressor(random_state=42)
scores = cross_val_score(tree_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
tree_rmse_scores = np.sqrt(-scores)
print('Decision Tree Regressor performance:', tree_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | test_data = pd.DataFrame(test_data, columns=['id','label'] )<save_to_csv> | %%time
forest_reg = RandomForestRegressor(random_state=42, n_jobs=-1)
scores = cross_val_score(forest_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
forest_rmse_scores = np.sqrt(-scores)
print('Random Forest performance:', forest_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | test_data.to_csv('submission.csv', index=False )<install_modules> | %%time
lgbm_reg = LGBMRegressor(random_state=42)
scores = cross_val_score(lgbm_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
lgbm_rmse_scores = np.sqrt(-scores)
print('LGBM performance:', lgbm_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | !pip install efficientnet<import_modules> | %%time
xgb_reg = XGBRegressor(random_state=42)
scores = cross_val_score(xgb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
xgb_rmse_scores = np.sqrt(-scores)
print('XGBoost performance:', xgb_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | import math, re, os
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from kaggle_datasets import KaggleDatasets
import tensorflow as tf
import tensorflow.keras.layers as L
import efficientnet.tfkeras as efn
from sklearn import metrics
from sklearn.model_selection import train_test_split
from ... | %%time
cb_reg = CatBoostRegressor(random_state=42, verbose=False)
scores = cross_val_score(cb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
cb_rmse_scores = np.sqrt(-scores)
print('CatBoost performance:', cb_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | GCS_DS_PATH = KaggleDatasets().get_gcs_path('plant-pathology-2020-fgvc7')
EPOCHS = 200
BATCH_SIZE = 8 * strategy.num_replicas_in_sync
IM_Z = 768<define_variables> | %%time
ab_reg = AdaBoostRegressor(random_state=42)
scores = cross_val_score(ab_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
ab_rmse_scores = np.sqrt(-scores)
print('AdaBoost performance:', ab_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | def format_path(st):
return GCS_DS_PATH + '/images/' + st + '.jpg'<load_from_csv> | def build_and_compile_model(norm):
model = keras.Sequential([
norm,
layers.Dense(64, activation='relu'),
layers.Dense(64, activation='relu'),
layers.Dense(1)])
model.compile(loss='mean_squared_error',
optimizer=tf.keras.optimizers.Adam(0.001))
return model | Tabular Playground Series - Jan 2021 |
13,991,623 | train = pd.read_csv('/kaggle/input/plant-pathology-2020-fgvc7/train.csv')
test = pd.read_csv('/kaggle/input/plant-pathology-2020-fgvc7/test.csv')
sub = pd.read_csv('/kaggle/input/plant-pathology-2020-fgvc7/sample_submission.csv')
train_paths = train.image_id.apply(format_path ).values
test_paths = test.image_id.appl... | %%time
normalizer = preprocessing.Normalization()
normalizer.adapt(np.array(X_train))
dnn_model = build_and_compile_model(normalizer)
history = dnn_model.fit(X_train, y_train, validation_split=0.2,
verbose=0, epochs=100 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | train_labels = train.loc[:, 'healthy':].values
print(f"- Train labels:
{train_labels}")
train_paths, valid_paths, train_labels, valid_labels = train_test_split(
train_paths, train_labels, test_size=0.3, random_state=2020)
print(f" - Độ dài bộ train: {len(train_paths)}")
print(f" - Độ dài bộ validation: {len(valid_p... | %%time
lin_reg = LinearRegression()
y_predict = cross_val_predict(lin_reg, X_train, y_train, cv=cv, n_jobs=-1 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | def decode_image(filename, label=None, image_size=(IM_Z, IM_Z)) :
bits = tf.io.read_file(filename)
image = tf.image.decode_jpeg(bits, channels=3)
image = tf.cast(image, tf.float32)/ 255.0
image = tf.image.resize(image, image_size)
if label is None:
return image
else:
return image, label
def data_augment(image, label... | %%time
tree_reg = DecisionTreeRegressor(random_state=42)
y_predict = cross_val_predict(tree_reg, X_train, y_train, cv=cv, n_jobs=-1 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | train_dataset =(
tf.data.Dataset
.from_tensor_slices(( train_paths, train_labels))
.map(decode_image, num_parallel_calls=AUTO)
.cache()
.map(data_augment, num_parallel_calls=AUTO)
.repeat()
.shuffle(512)
.batch(BATCH_SIZE)
.prefetch(AUTO)
)
valid_dataset =(
tf.data.Dataset
.from_tensor_slices(( valid_paths, val... | %%time
forest_reg = RandomForestRegressor(random_state=42, n_jobs=-1)
y_predict = cross_val_predict(forest_reg, X_train, y_train, cv=cv, n_jobs=-1 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | def build_lrfn(lr_start=0.00001, lr_max=0.000075,
lr_min=0.000001, lr_rampup_epochs=20,
lr_sustain_epochs=0, lr_exp_decay=.8):
lr_max = lr_max * strategy.num_replicas_in_sync
def lrfn(epoch):
if epoch < lr_rampup_epochs:
lr =(lr_max - lr_start)/ lr_rampup_epochs * epoch + lr_start
elif epoch < lr_rampup_epochs + lr_sus... | %%time
lgbm_reg = LGBMRegressor(random_state=42)
y_predict = cross_val_predict(lgbm_reg, X_train, y_train, cv=cv, n_jobs=-1 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | lrs = []
lrnfn = build_lrfn()
for epoch in range(0, 100):
lr = lrnfn(epoch)
lrs.append(lr)
plt.plot(lrs )<choose_model_class> | %%time
xgb_reg = XGBRegressor(random_state=42)
y_predict = cross_val_predict(xgb_reg, X_train, y_train, cv=cv, n_jobs=-1 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | with strategy.scope() :
model = tf.keras.Sequential([
efn.EfficientNetB7(
input_shape=(IM_Z, IM_Z, 3),
weights='imagenet',
include_top=False
),
L.GlobalAveragePooling2D() ,
L.Dense(train_labels.shape[1], activation='softmax')
])
model.compile(
optimizer='adam',
loss = 'categorical_crossentropy',
metrics=['categori... | %%time
cb_reg = CatBoostRegressor(random_state=42, verbose=False)
y_predict = cross_val_predict(cb_reg, X_train, y_train, cv=cv, n_jobs=-1 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | lrfn = build_lrfn()
lr_schedule = tf.keras.callbacks.LearningRateScheduler(lrfn, verbose=0)
STEPS_PER_EPOCH = train_labels.shape[0] // BATCH_SIZE
EarlyStop_callback = EarlyStopping(monitor='val_loss', patience=20, restore_best_weights=True )<train_model> | %%time
ab_reg = AdaBoostRegressor(random_state=42)
y_predict = cross_val_predict(ab_reg, X_train, y_train, cv=cv, n_jobs=-1 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | history = model.fit(
train_dataset,
epochs=EPOCHS,
callbacks=[ch_p, EarlyStop_callback],
steps_per_epoch=STEPS_PER_EPOCH,
validation_data=valid_dataset
)<load_pretrained> | def objective(trial):
params = {
'random_state': 42,
'max_depth': trial.suggest_int('max_depth', 1, 14),
'learning_rate': trial.suggest_float('learning_rate', 0.01, 1.0)
}
lgbm_reg = LGBMRegressor()
lgbm_reg.set_params(**params)
scores = cross_val_score(lgbm_reg, X_train, y_train, scoring='neg_mean_squared_error', cv... | Tabular Playground Series - Jan 2021 |
13,991,623 | model.load_weights("model_ef1.h5" )<categorify> | study = optuna.create_study(direction = 'minimize')
study.optimize(objective, n_trials = 1)
best_params = study.best_trial.params | Tabular Playground Series - Jan 2021 |
13,991,623 | def dummy_data_augment(image):
return image
data_augments = [dummy_data_augment, tf.image.flip_left_right, tf.image.flip_up_down]<categorify> | %%time
lgbm_reg = LGBMRegressor()
lgbm_reg.set_params(**best_params)
scores = cross_val_score(lgbm_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
lgbm_rmse_scores = np.sqrt(-scores)
print('LGBM performance:', lgbm_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | TTA_test_datasets = [(
tf.data.Dataset
.from_tensor_slices(test_paths)
.map(decode_image, num_parallel_calls=AUTO)
.batch(BATCH_SIZE)
.map(d_augment, num_parallel_calls=AUTO)
)for d_augment in data_augments]<predict_on_test> | def objective(trial):
params = {
'random_state': 42,
'max_depth': trial.suggest_int('max_depth', 1, 14),
'eta': trial.suggest_float('eta', 0.01, 1.0),
}
xgb_reg = XGBRegressor()
xgb_reg.set_params(**params)
scores = cross_val_score(xgb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
rmse = ... | Tabular Playground Series - Jan 2021 |
13,991,623 | combined_probs_TTAs = [model.predict(dataset)for dataset in TTA_test_datasets]<define_variables> | study = optuna.create_study(direction = 'minimize')
study.optimize(objective, n_trials = 1)
best_params = study.best_trial.params | Tabular Playground Series - Jan 2021 |
13,991,623 | submission_name = 'submission_eff_TTA'
for d_aug in data_augments:
submission_name += "-"
submission_name += d_aug.__name__
submission_name += ".csv"
submission_name<save_to_csv> | %%time
xgb_reg = XGBRegressor()
xgb_reg.set_params(**best_params)
scores = cross_val_score(xgb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
xgb_rmse_scores = np.sqrt(-scores)
print('XGBoost performance:', xgb_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,991,623 | sub.loc[:, 'healthy':] = probs_TTA
sub.to_csv(submission_name, index=False)
sub.head()<set_options> | X_train['below8'] = np.where(y_train < 8, 1, 0 ) | Tabular Playground Series - Jan 2021 |
13,991,623 | <import_modules><EOS> | %%time
cb_reg = CatBoostRegressor(random_state=42, verbose=False)
scores = cross_val_score(cb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=5)
cb_rmse_scores = np.sqrt(-scores)
print('CatBoost performance:', cb_rmse_scores ) | Tabular Playground Series - Jan 2021 |
13,959,467 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<load_from_csv> | import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from xgboost import XGBRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error | Tabular Playground Series - Jan 2021 |
13,959,467 | %%time
folder_path = '.. /input/'
train_identity = pd.read_csv(f'{folder_path}train_identity.csv')
train_transaction = pd.read_csv(f'{folder_path}train_transaction.csv')
test_identity = pd.read_csv(f'{folder_path}test_identity.csv')
test_transaction = pd.read_csv(f'{folder_path}test_transaction.csv')
sub = pd.read_... | train = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv', index_col='id')
test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv', index_col='id' ) | Tabular Playground Series - Jan 2021 |
13,959,467 | v = [1, 3, 4, 6, 8, 11]
v += [13, 14, 17, 20, 23, 26, 27, 30]
v += [36, 37, 40, 41, 44, 47, 48]
v += [54, 56, 59, 62, 65, 67, 68, 70]
v += [76, 78, 80, 82, 86, 88, 89, 91]
v += [107, 108, 111, 115, 117, 120, 121, 123]
v += [124, 127, 129, 130, 136]
v += [138, 139, 142, 147, 156, 162]
v += [165, 160, 166]
v += [178, 176... | plt.style.use('ggplot')
plt.rcParams['axes.titlesize'] = 16
plt.rcParams['axes.labelsize'] = 12
plt.rcParams['xtick.labelsize'] = 'large' | Tabular Playground Series - Jan 2021 |
13,959,467 | print(f'There are {train.isnull().any().sum() } columns in train dataset with missing values.' )<count_unique_values> | print('Missing values on the train data:', train.isnull().sum().sum())
print('Missing values on the test data:', test.isnull().sum().sum() ) | Tabular Playground Series - Jan 2021 |
13,959,467 | one_value_cols = [col for col in train.columns if train[col].nunique() <= 1]
one_value_cols_test = [col for col in test.columns if test[col].nunique() <= 1]
one_value_cols == one_value_cols_test<count_unique_values> | print('Duplicated rows on the train data:', train.duplicated().sum())
print('Duplicated rows on the test data:', test.duplicated().sum() ) | Tabular Playground Series - Jan 2021 |
13,959,467 | print(f'There are {len(one_value_cols)} columns in train dataset with one unique value.')
print(f'There are {len(one_value_cols_test)} columns in test dataset with one unique value.' )<count_values> | q1 = train.quantile(0.25)
q3 = train.quantile(0.75)
iqr = q3 - q1
mask =(train >=(q1 - 1.5*iqr)) &(train <= q3 + 1.5*iqr)
train = train[mask.apply(all, axis=1)]
print('Train set without outliers shape:', train.shape ) | Tabular Playground Series - Jan 2021 |
13,959,467 | s1 = train['id_03'].value_counts(dropna=False, normalize=True ).head()
s2 = train['id_04'].value_counts(dropna=False, normalize=True ).head()
s3 = train['id_05'].value_counts(dropna=False, normalize=True ).head()
s4 = train['id_06'].value_counts(dropna=False, normalize=True ).head()
s5 = train['id_09'].value_counts(dro... | X_train, X_val, y_train, y_val = train_test_split(train[predictors],
train[target],
test_size = 0.2,
random_state=2021 ) | Tabular Playground Series - Jan 2021 |
13,959,467 | train['id_11'].value_counts(dropna=False, normalize=True ).head()<feature_engineering> | model = XGBRegressor(objective='reg:squarederror',
booster = "gbtree",
eval_metric = "rmse",
tree_method = "gpu_hist",
n_estimators = 1000,
learning_rate = 0.04,
eta = 0.1,
max_depth = 7,
subsample=0.85,
colsample_bytree = 0.85,
colsample_bylevel = 0.8,
alpha = 0,
random_state = 2021 ) | Tabular Playground Series - Jan 2021 |
13,959,467 | for i in range(1,16):
if i in [1,2,3,5,9]: continue
train['D'+str(i)] = train['D'+str(i)] - train.TransactionDT/np.float32(24*60*60)
test['D'+str(i)] = test['D'+str(i)] - test.TransactionDT/np.float32(24*60*60 )<define_variables> | %time model.fit(X_train, y_train ) | Tabular Playground Series - Jan 2021 |
13,959,467 | emails = {'gmail': 'google', 'att.net': 'att', 'twc.com': 'spectrum',
'scranton.edu': 'other', 'optonline.net': 'other', 'hotmail.co.uk': 'microsoft',
'comcast.net': 'other', 'yahoo.com.mx': 'yahoo', 'yahoo.fr': 'yahoo',
'yahoo.es': 'yahoo', 'charter.net': 'spectrum', 'live.com': 'microsoft',
'aim.com': 'aol', 'hotmail... | y_val_pred = model.predict(X_val)
print('Validation Set RMSE:', np.sqrt(mean_squared_error(y_val, y_val_pred)) ) | Tabular Playground Series - Jan 2021 |
13,959,467 | <feature_engineering><EOS> | test['target'] = model.predict(test[predictors])
test['target'].to_csv('submission.csv' ) | Tabular Playground Series - Jan 2021 |
13,955,851 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<feature_engineering> | warnings.filterwarnings("ignore" ) | Tabular Playground Series - Jan 2021 |
13,955,851 | train['TransactionAmt_log'] = np.log(train['TransactionAmt'])
test['TransactionAmt_log'] = np.log(test['TransactionAmt'] )<categorify> | train_data = pd.read_csv(path+'train.csv')
test_data = pd.read_csv(path+'test.csv')
samp_subm = pd.read_csv(path+'sample_submission.csv' ) | Tabular Playground Series - Jan 2021 |
13,955,851 | train['TransactionAmt_to_mean_card1'] = train['TransactionAmt'] / train.groupby(['card1'])['TransactionAmt'].transform('mean')
train['TransactionAmt_to_mean_card4'] = train['TransactionAmt'] / train.groupby(['card4'])['TransactionAmt'].transform('mean')
train['TransactionAmt_to_std_card1'] = train['TransactionAmt'] /... | print('Number train samples:', len(train_data.index))
print('Number test samples:', len(test_data.index))
print('Number features:', len(train_data.columns)) | Tabular Playground Series - Jan 2021 |
13,955,851 | train[['P_emaildomain_1', 'P_emaildomain_2', 'P_emaildomain_3']] = train['P_emaildomain'].str.split('.', expand=True)
train[['R_emaildomain_1', 'R_emaildomain_2', 'R_emaildomain_3']] = train['R_emaildomain'].str.split('.', expand=True)
test[['P_emaildomain_1', 'P_emaildomain_2', 'P_emaildomain_3']] = test['P_emaildom... | print('Missing values on the train data:', train_data.isnull().sum().sum())
print('Missing values on the test data:', test_data.isnull().sum().sum() ) | Tabular Playground Series - Jan 2021 |
13,955,851 | %time
train['cents'] =(train['TransactionAmt'] - np.floor(train['TransactionAmt'])).astype('float32')
test['cents'] =(test['TransactionAmt'] - np.floor(test['TransactionAmt'])).astype('float32')
print('cents, ', end='')
encode_FE(train,test,['addr1','card1','card2','card3','P_emaildomain'])
encode_CB('card1','addr1... | pca = PCA().fit(train_data[train_data.columns[1:-1]])
plt.plot(np.cumsum(pca.explained_variance_ratio_))
plt.xlabel('No of components')
plt.ylabel('Cumulative explained variance')
plt.grid()
plt.show() | Tabular Playground Series - Jan 2021 |
13,955,851 | many_null_cols = [col for col in train.columns if train[col].isnull().sum() / train.shape[0] > 0.9]
many_null_cols_test = [col for col in test.columns if test[col].isnull().sum() / test.shape[0] > 0.9]<define_variables> | features = ['cont'+str(i)for i in range(1, 15)]
no_features = ['id', 'target'] | Tabular Playground Series - Jan 2021 |
13,955,851 | big_top_value_cols = [col for col in train.columns if train[col].value_counts(dropna=False, normalize=True ).values[0] > 0.9]
big_top_value_cols_test = [col for col in test.columns if test[col].value_counts(dropna=False, normalize=True ).values[0] > 0.9]<drop_column> | train_data['mean'] = train_data[features].mean(axis=1)
train_data['std'] = train_data[features].std(axis=1)
train_data['max'] = train_data[features].max(axis=1)
train_data['min'] = train_data[features].min(axis=1)
train_data['sum'] = train_data[features].sum(axis=1)
test_data['mean'] = test_data[features].mean(axi... | Tabular Playground Series - Jan 2021 |
13,955,851 | cols_to_drop = list(set(many_null_cols + many_null_cols_test + big_top_value_cols + big_top_value_cols_test + one_value_cols+ one_value_cols_test))
cols_to_drop.remove('isFraud')
len(cols_to_drop )<drop_column> | X = train_data[train_data.columns.difference(no_features)]
y = train_data['target']
X_test = test_data[test_data.columns.difference(no_features)] | Tabular Playground Series - Jan 2021 |
13,955,851 | train = train.drop(cols_to_drop, axis=1)
test = test.drop(cols_to_drop, axis=1 )<categorify> | iso = IsolationForest(contamination=0.01)
yhat = iso.fit_predict(train_data[train_data.columns.difference(no_features)])
mask = yhat != -1
| Tabular Playground Series - Jan 2021 |
13,955,851 | def clean_inf_nan(df):
return df.replace([np.inf, -np.inf], np.nan)
train = clean_inf_nan(train)
test = clean_inf_nan(test )<define_variables> | print('Number of outliers:', len(train_data)-mask.sum() ) | Tabular Playground Series - Jan 2021 |
13,955,851 | identity_cat_cols = ['id_12', 'id_13', 'id_14', 'id_15', 'id_16', 'id_17', 'id_18',
'id_19', 'id_20', 'id_21', 'id_22', 'id_23', 'id_24', 'id_25',
'id_26', 'id_27', 'id_28', 'id_29', 'id_30', 'id_31', 'id_32',
'id_33', 'id_34', 'id_35', 'id_36', 'id_37', 'id_38', 'DeviceType', 'DeviceInfo']
transaction_cat_cols = ['Pro... | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size = 0.2, random_state=2021 ) | Tabular Playground Series - Jan 2021 |
13,955,851 | cat_train = train[common_cat_cols]
num_train = train.drop(cat_cols, axis=1)
cat_test = test[common_cat_cols]
num_test = test.drop(common_cat_cols, axis=1)
cat_train.columns == cat_test.columns<count_unique_values> | model = XGBRegressor(objective='reg:squarederror',
booster = "gbtree",
eval_metric = "rmse",
tree_method = "gpu_hist",
n_estimators = 600,
learning_rate = 0.04,
eta = 0.1,
max_depth = 7,
subsample=0.85,
colsample_bytree = 0.85,
colsample_bylevel = 0.8,
alpha = 0,
random_state = 2021)
model.fit(X_train, y_train)
y_val... | Tabular Playground Series - Jan 2021 |
13,955,851 | cat_nunique = list(map(lambda col: cat_train[col].nunique() , common_cat_cols))
d = dict(zip(common_cat_cols, cat_nunique))
sorted(d.items() , key=lambda x:x[1] )<data_type_conversions> | y_test = model.predict(X_test ) | Tabular Playground Series - Jan 2021 |
13,955,851 | cat_train = cat_train.astype('category')
cat_test = cat_test.astype('category')
print(cat_train.dtypes )<categorify> | output = samp_subm.copy()
output['target'] = y_test | Tabular Playground Series - Jan 2021 |
13,955,851 | <categorify><EOS> | output.to_csv('submission.csv', index=False ) | Tabular Playground Series - Jan 2021 |
16,947,019 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<categorify> | sub_file = pd.read_csv(r'.. /input/tpsjan2021/submission_blend_1.csv')
df_sub = pd.read_csv(r'.. /input/tpsjan2021/best_blend_1.csv')
df_sub = df_sub.iloc[:, :14]
plt.figure(figsize=(10,10))
sns.heatmap(df_sub.corr() , cmap='Spectral')
plt.ylabel('file index numbers')
plt.xlabel('file index numbers')
plt.show() | Tabular Playground Series - Jan 2021 |
16,947,019 | <drop_column><EOS> | df_sub['weighted_avg'] = abs(1 *(
-10 *(30 * df_sub['3'] + 30 * df_sub['4'] + 30 * df_sub['6'] +
50 * df_sub['8'] + 1 * df_sub['10'] + 1 * df_sub['11'])/ 142 +
5 *(170 * df_sub['2'] + 20 * df_sub['7'] + 5 * df_sub['12'] + 1 * df_sub['13'])/ 196 +
150 *(150 * df_sub['0'] + 50 * df_sub['1'] -10 * df_sub['5'] - 25 * df_s... | Tabular Playground Series - Jan 2021 |
14,331,351 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<drop_column> | import numpy as np
import pandas as pd
from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error
import sklearn.datasets
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
import optuna
import lightgbm as lgb
import xgboost as xgb
import seabor... | Tabular Playground Series - Jan 2021 |
14,331,351 | cols = list(train.columns)
for c in list(set(['D6','D7','D8','D9','D12','D13','D14'])& set(cols)) :
cols.remove(c)
for c in list(set(['C3','M5','id_08','id_33'])& set(cols)) :
cols.remove(c)
for c in list(set(['card4','id_07','id_14','id_21','id_30','id_32','id_34'])& set(cols)) :
cols.remove(c)
for c in list(set([... | train = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv')
test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
sub = pd.read_csv('.. /input/tabular-playground-series-jan-2021/sample_submission.csv')
features = [f'cont{x}'for x in range(1,15)]
data = train[features]
X_test =... | Tabular Playground Series - Jan 2021 |
14,331,351 | final_train = train[cols].copy()
final_test = test[list(set(cols)- set(['isFraud'])) ].copy()
print(f'Our Final Train dataset has {final_train.shape[0]} rows and {final_train.shape[1]} columns.')
print(f'Our Final Test dataset has {final_test.shape[0]} rows and {final_test.shape[1]} columns.' )<drop_column> | Best_trial = {'lambda': 0.0030282073258141168, 'alpha': 0.01563845128469084, 'colsample_bytree': 0.5,
'subsample': 0.7,'n_estimators': 4000, 'learning_rate': 0.01,'max_depth': 15,
'random_state': 2020, 'min_child_weight': 257,'tree_method':'gpu_hist'
,'predictor': 'gpu_predictor'}
train = train_data
test = test_data
pr... | Tabular Playground Series - Jan 2021 |
14,331,351 | del train, test<define_variables> | sub1 = pd.read_csv('.. /input/results-driven-tabular-playground-series-201/submission.csv')
predictions1 = sub1['target'].tolist()
results = [x*0.66 + y*0.34 for x, y in zip(predictions1, preds)]
| Tabular Playground Series - Jan 2021 |
14,331,351 | idxT = X_train.index[:3*len(X_train)//4]
idxV = X_train.index[3*len(X_train)//4:]<count_values> | Best_trial ={'random_state': 33,'n_estimators':5000,
'min_data_per_group': 5,
'boosting_type': 'gbdt',
'device_type' : 'gpu',
'num_leaves': 256,
'num_iterations' : 5000,
'max_dept': -1,
'learning_rate': 0.005,
'subsample_for_bin': 200000,
'lambda_l1': 1.074622455507616e-05,
'lambda_l2': 2.0521330798729704e-06,
'n_jobs'... | Tabular Playground Series - Jan 2021 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.