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({agg_col:agg_func} ).reset_index().rename(columns={agg_col:feature_name})
df = pd.merge(df, group, on=index_features, how="left")
df = downcast1(df)
mean_feats.append(feature_name)
del group
gc.collect()
return df, mean_feats
<feature_engineering> | 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 = N_FOLDS)
oof = np.zeros(len(y))
oof_vanilla = np.zeros(len(y))
preds = np.zeros(len(X_test))
params['learning_rate'] = 0.005
params['num_iterations'] = 5000
for train_ind, test_ind in tqdm(kf.split(X)) :
Xtrain = X.iloc[train_ind]
Xval = X.iloc[test_ind]
ytrain = y.iloc[train_ind]
yval = y.iloc[test_ind]
model = LGBMRegressor(**params)
vanilla_model = LGBMRegressor()
model.fit(Xtrain, ytrain, eval_set =(( Xval,yval)) , early_stopping_rounds = 50, verbose = 0)
vanilla_model.fit(Xtrain, ytrain)
p = model.predict(Xval)
p_vanilla = vanilla_model.predict(Xval)
oof[test_ind] = p
oof_vanilla[test_ind] = p_vanilla
preds += model.predict(X_test)/N_FOLDS
print(f'mean square error on training data(vanilla model): {np.round(mean_squared_error(y, oof_vanilla, squared=False),5)}')
print(f'mean square error on training data(with tuning): {np.round(mean_squared_error(y, oof, squared=False),5)}' ) | 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']/test['cont10']
test['magic3'] = test['cont1']/test['cont7']
test['magic4'] = test['cont7']/test['cont1']
test['magic5'] = test['cont4']/test['cont6'] | 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() , on=index_features, how="left")
df[feat_name] = df[feat_name].fillna(0)
if clip:
lag_feats_to_clip.append(feat_name)
df = downcast1(df)
del df_temp
gc.collect()
return df, lag_feats_to_clip<define_variables> | 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(10 )<prepare_x_and_y> | 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))
params['feature_fraction'] = max(min(feature_fraction, 1), 0)
params['bagging_fraction'] = max(min(bagging_fraction, 1), 0)
params['max_depth'] = int(round(max_depth))
params['min_split_gain'] = min_split_gain
params['min_child_weight'] = min_child_weight
params['learning_rate'] = learning_rate
cv_result = lightgbm.cv(params, dtrain, nfold=3,
seed=RANDOM_SEED, stratified=False,
verbose_eval =None, metrics=['rmse'])
return -np.min(cv_result['rmse-mean'] ) | 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_2"].replace([np.inf, -np.inf], np.nan ).fillna(0 )<feature_engineering> | 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 = []
cv_dataset = cgb.Pool(data=X,
label=y,
cat_features=cat_feat)
scores = cgb.cv(cv_dataset,
params,
fold_count=3)
return -np.min(scores['test-RMSE-mean'] ) | 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), 0)
params['colsample_bytree'] = max(min(colsample_bytree, 1), 0)
params['min_child_weight'] = int(min_child_weight)
params['gamma'] = max(gamma, 0)
params['learning_rate'] = learning_rate
scores = xgb.cv(params, dtrain, num_boost_round=500,verbose_eval=False,
early_stopping_rounds=10, nfold=3)
return -scores['test-rmse-mean'].iloc[-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_test = X_test.drop("item_cnt_month", axis=1)
del all_data
gc.collect()
<save_to_csv> | 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'
}
param_cat = {
'bagging_temperature': 0.31768713094131684,
'depth': int(8.03),
'l2_leaf_reg': 1.3525686450404295,
'learning_rate': 0.2,
'iterations': 100,
'loss_function': 'RMSE',
'verbose': False
}
param_xgb = {
'colsample_bytree': 0.8119098377889549,
'gamma': 2.244423418642122,
'learning_rate': 0.015800631696721114,
'max_depth': int(9.846),
'min_child_weight': int(15.664),
'subsample': 0.82345,
'objective': 'reg:squarederror',
'eval_metric':'rmse',
'num_boost_roun' : 500
} | 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.train(params=params, train_set=lgb_train, valid_sets=(lgb_train, lgb_val), verbose_eval=50 )<predict_on_test> | 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, precision_recall_curve, auc
from sklearn.model_selection import StratifiedKFold, train_test_split, KFold
import matplotlib.pyplot as plt
from sklearn.preprocessing import KBinsDiscretizer, OneHotEncoder
from statsmodels.gam.tests.test_gam import sigmoid
from tqdm import tqdm
| 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
import pandas as pd
import numpy as np
from tqdm import tqdm
import matplotlib.pyplot as plt
from torch.utils.data import Dataset,DataLoader
from torch.utils.data.sampler import SequentialSampler, RandomSampler
from torch.cuda.amp import autocast, GradScaler
import sklearn
import warnings
import joblib
from sklearn.metrics import roc_auc_score, log_loss
from sklearn import metrics
import warnings
import cv2
import pydicom
import timm
from scipy.ndimage.interpolation import zoom
from sklearn.metrics import log_loss<init_hyperparams> | 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_from_csv> | 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,
'max_depth': 8,
'tree_learner': 'serial',
'colsample_bytree': 0.8,
'subsample_freq': 1,
'subsample': 0.8,
'max_bin': 255,
'verbose': -1,
'seed': seed,
}
base_features = [x for x in train.columns if 'cont' in x]
remove_features = [label,'id'] | 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,device='GPU')
for n,(trn_id,val_id)in enumerate(cv.split(train[features],train[label])) :
print(f"===== training fold {n+1} =====")
trn_x,trn_y = train.loc[trn_id,features],train.loc[trn_id,label]
val_x,val_y = train.loc[val_id,features],train.loc[val_id,label]
lgb.fit(trn_x,trn_y,eval_set=[(val_x,val_y)],early_stopping_rounds=100,verbose=-1)
oof_predictions[val_id] = lgb.predict(val_x)
final_predictions += lgb.predict(test[features])/ cv.n_splits
mse_score = np.sqrt(mean_squared_error(y_true=val_y,y_pred=oof_predictions[val_id]))
del trn_x,trn_y,val_x,val_y
gc.collect()
cur_mse_score = np.sqrt(mean_squared_error(y_true=train[label],y_pred=oof_predictions))
cur_mae_score = mean_absolute_error(y_true=train[label],y_pred=oof_predictions)
print(f"global mse score {cur_mse_score}")
print(f"global mae score {cur_mae_score}")
print(f"diff with previous version {score[0] - cur_mse_score}")
print(f"diff with previous version {score[1] - cur_mae_score}")
if not local_test:
test[label] = final_predictions
test[['id',label]].to_csv(f'sub_{np.round(cur_mse_score,4)}.csv',index=False)
return [cur_mse_score,cur_mae_score] | 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 import mean_squared_error
from sklearn.model_selection import cross_val_score, cross_val_predict,RandomizedSearchCV, KFold
from lightgbm import LGBMRegressor
from xgboost import XGBRegressor
from catboost import CatBoostRegressor
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.layers.experimental import preprocessing
import optuna | 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, RandomBrightnessContrast, Flip, OneOf, Compose, Normalize, Cutout, CoarseDropout, ShiftScaleRotate, CenterCrop, Resize
)
def get_train_transforms() :
return Compose([
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.1, rotate_limit=30, p=0.5),
CoarseDropout(p=0.1),
Cutout(p=0.1),
ToTensorV2(p=1.0),
], p=1.)
def get_valid_transforms() :
return Compose([
ToTensorV2(p=1.0),
], p=1.)
def get_inference_transforms() :
return Compose([
ToTensorV2(p=1.0),
], p=1.)<normalization> | 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 x.mul(se_weight)
class GlobalAvgPool(nn.Module):
def __init__(self):
super(GlobalAvgPool, self ).__init__()
def forward(self, x):
return x.view(*(x.shape[:-2]),-1 ).mean(-1)
class SE_Net(nn.Module):
def __init__(self,in_channels):
super(SE_Net,self ).__init__()
self.c1 = nn.Conv2d(in_channels=in_channels, out_channels=64,kernel_size=3,stride=1,padding=0)
self.bn1 = nn.BatchNorm2d(num_features=64,eps=1e-3,momentum=0.01)
self.c2 = nn.Conv2d(64,64,3,1,0)
self.bn2 = nn.BatchNorm2d(64,1e-3,0.01)
self.c3 = nn.Conv2d(64,64,5,1,2)
self.bn3 = nn.BatchNorm2d(64,1e-3,0.01)
self.m1 = nn.MaxPool2d(2)
self.d1 = nn.Dropout(0.4)
self.c4 = nn.Conv2d(64,128,3,1,0)
self.bn4 = nn.BatchNorm2d(128,1e-3,0.01)
self.c5 = nn.Conv2d(128,128,3,1,0)
self.bn5 = nn.BatchNorm2d(128,1e-3,0.01)
self.c6 = nn.Conv2d(128,128,5,1,2)
self.bn6 = nn.BatchNorm2d(128,1e-3,0.01)
self.m2 = nn.MaxPool2d(2)
self.d2 = nn.Dropout(0.4)
self.c7 = nn.Conv2d(128,256,3,1,0)
self.bn7 = nn.BatchNorm2d(256,1e-3,0.01)
self.se3 = Sq_Ex_Block(in_ch=256,r=8)
self.m3 = nn.MaxPool2d(2)
self.d3 = nn.Dropout(0.4)
self.fc1 = nn.Linear(256*1*1,256)
self.bn8 = nn.BatchNorm1d(256,1e-3,0.01)
self.out = nn.Linear(256,10)
self.init_linear_weights()
def forward(self,x):
x = self.bn1(F.leaky_relu(self.c1(x),0.1))
x = self.bn2(F.leaky_relu(self.c2(x),0.1))
x = self.bn3(F.leaky_relu(self.c3(x),0.1))
x = self.d1(self.m1(x))
x = self.bn4(F.leaky_relu(self.c4(x),0.1))
x = self.bn5(F.leaky_relu(self.c5(x),0.1))
x = self.bn6(F.leaky_relu(self.c6(x),0.1))
x = self.d2(self.m2(x))
x = self.bn7(F.leaky_relu(self.c7(x),0.1))
x = self.se3(x)
x = self.d3(self.m3(x))
x = x.view(-1, 256*1*1)
x = self.bn8(F.leaky_relu(self.fc1(x),0.1))
return self.out(x)
def init_linear_weights(self):
nn.init.kaiming_normal_(self.fc1.weight, mode='fan_in')
nn.init.kaiming_normal_(self.out.weight, mode='fan_in' )<load_from_csv> | 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.load(model_path))
with torch.no_grad() :
for _ in range(CFG['tta']):
tst_preds += [1/CFG['tta']*inference_one_epoch(model, tst_loader, device)]
tst_preds = np.mean(tst_preds, axis=0 )<prepare_output> | %%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 keras.callbacks import ModelCheckpoint, EarlyStopping<define_variables> | %%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.apply(format_path ).values
N = len(train_paths)
print(f"- Độ dài bộ train: {len(train_paths)}")
print(f"- Độ dài bộ test: {len(test_paths)}")
N_healthy = train['healthy'].mean() * N
N_multiple_diseases = train['multiple_diseases'].mean() * N
N_rust = train['rust'].mean() * N
N_scab = train['scab'].mean() * N
print(f'Healthy: {N_healthy} mẫu')
print(f'Multiple diseases: {N_multiple_diseases} mẫu')
print(f'Rust: {N_rust} mẫu')
print(f'Scab: {N_scab} mẫu')
train.describe()<split> | %%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_paths)}" )<normalization> | %%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=None):
image = tf.image.random_flip_left_right(image)
image = tf.image.random_flip_up_down(image)
if label is None:
return image
else:
return image, label<categorify> | %%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, valid_labels))
.map(decode_image, num_parallel_calls=AUTO)
.batch(BATCH_SIZE)
.cache()
.prefetch(AUTO)
)
test_dataset =(
tf.data.Dataset
.from_tensor_slices(test_paths)
.map(decode_image, num_parallel_calls=AUTO)
.batch(BATCH_SIZE)
)<choose_model_class> | %%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_sustain_epochs:
lr = lr_max
else:
lr =(lr_max - lr_min)* lr_exp_decay**(epoch - lr_rampup_epochs - lr_sustain_epochs)+ lr_min
return lr
return lrfn
ch_p = ModelCheckpoint(filepath="model_ef1.h5", monitor='val_loss', save_weights_only=True, save_best_only=True, verbose=1 )<define_search_space> | %%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=['categorical_accuracy']
)
model.summary()<choose_model_class> | %%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=cv, n_jobs=-1)
rmse = np.sqrt(-scores)
return np.mean(rmse ) | 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 = np.sqrt(-scores)
return np.mean(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_csv(f'{folder_path}sample_submission.csv')
fix = {o:n for o, n in zip(test_identity.columns, train_identity.columns)}
test_identity.rename(columns=fix, inplace=True)
train = pd.merge(train_transaction, train_identity, on='TransactionID', how='left')
test = pd.merge(test_transaction, test_identity, on='TransactionID', how='left')
del train_identity, train_transaction, test_identity, test_transaction, fix
train = reduce_mem_usage(train)
test = reduce_mem_usage(test )<define_variables> | 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, 173, 182]
v += [187, 203, 205, 207, 215]
v += [169, 171, 175, 180, 185, 188, 198, 210, 209]
v += [218, 223, 224, 226, 228, 229, 235]
v += [240, 258, 257, 253, 252, 260, 261]
v += [264, 266, 267, 274, 277]
v += [220, 221, 234, 238, 250, 271]
v += [294, 284, 285, 286, 291, 297]
v += [303, 305, 307, 309, 310, 320]
v += [281, 283, 289, 296, 301, 314]
use_Vcols = ['V'+str(x)for x in v]
Vcols = ['V'+str(x)for x in range(1,340)]
drop_Vcols = list(set(Vcols)- set(use_Vcols))
train.drop(drop_Vcols, axis=1, inplace=True)
test.drop(drop_Vcols, axis=1, inplace=True )<count_missing_values> | 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(dropna=False, normalize=True ).head()
s6 = train['id_10'].value_counts(dropna=False, normalize=True ).head()
print(pd.concat([s1, s2, s3, s4, s5, s6], axis = 1))<count_values> | 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.de': 'microsoft', 'centurylink.net': 'centurylink',
'gmail.com': 'google', 'me.com': 'apple', 'earthlink.net': 'other', 'gmx.de': 'other',
'web.de': 'other', 'cfl.rr.com': 'other', 'hotmail.com': 'microsoft',
'protonmail.com': 'other', 'hotmail.fr': 'microsoft', 'windstream.net': 'other',
'outlook.es': 'microsoft', 'yahoo.co.jp': 'yahoo', 'yahoo.de': 'yahoo',
'servicios-ta.com': 'other', 'netzero.net': 'other', 'suddenlink.net': 'other',
'roadrunner.com': 'other', 'sc.rr.com': 'other', 'live.fr': 'microsoft',
'verizon.net': 'yahoo', 'msn.com': 'microsoft', 'q.com': 'centurylink',
'prodigy.net.mx': 'att', 'frontier.com': 'yahoo', 'anonymous.com': 'other',
'rocketmail.com': 'yahoo', 'sbcglobal.net': 'att', 'frontiernet.net': 'yahoo',
'ymail.com': 'yahoo', 'outlook.com': 'microsoft', 'mail.com': 'other',
'bellsouth.net': 'other', 'embarqmail.com': 'centurylink', 'cableone.net': 'other',
'hotmail.es': 'microsoft', 'mac.com': 'apple', 'yahoo.co.uk': 'yahoo', 'netzero.com': 'other',
'yahoo.com': 'yahoo', 'live.com.mx': 'microsoft', 'ptd.net': 'other', 'cox.net': 'other',
'aol.com': 'aol', 'juno.com': 'other', 'icloud.com': 'apple'}
us_emails = ['gmail', 'net', 'edu']
for c in ['P_emaildomain', 'R_emaildomain']:
train[c + '_bin'] = train[c].map(emails)
test[c + '_bin'] = test[c].map(emails)
train[c + '_suffix'] = train[c].map(lambda x: str(x ).split('.')[-1])
test[c + '_suffix'] = test[c].map(lambda x: str(x ).split('.')[-1])
train[c + '_suffix'] = train[c + '_suffix'].map(lambda x: x if str(x)not in us_emails else 'us')
test[c + '_suffix'] = test[c + '_suffix'].map(lambda x: x if str(x)not in us_emails else 'us' )<categorify> | 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'] / train.groupby(['card1'])['TransactionAmt'].transform('std')
train['TransactionAmt_to_std_card4'] = train['TransactionAmt'] / train.groupby(['card4'])['TransactionAmt'].transform('std')
test['TransactionAmt_to_mean_card1'] = test['TransactionAmt'] / test.groupby(['card1'])['TransactionAmt'].transform('mean')
test['TransactionAmt_to_mean_card4'] = test['TransactionAmt'] / test.groupby(['card4'])['TransactionAmt'].transform('mean')
test['TransactionAmt_to_std_card1'] = test['TransactionAmt'] / test.groupby(['card1'])['TransactionAmt'].transform('std')
test['TransactionAmt_to_std_card4'] = test['TransactionAmt'] / test.groupby(['card4'])['TransactionAmt'].transform('std')
train['D15_to_mean_card1'] = train['D15'] / train.groupby(['card1'])['D15'].transform('mean')
train['D15_to_mean_card4'] = train['D15'] / train.groupby(['card4'])['D15'].transform('mean')
train['D15_to_std_card1'] = train['D15'] / train.groupby(['card1'])['D15'].transform('std')
train['D15_to_std_card4'] = train['D15'] / train.groupby(['card4'])['D15'].transform('std')
test['D15_to_mean_card1'] = test['D15'] / test.groupby(['card1'])['D15'].transform('mean')
test['D15_to_mean_card4'] = test['D15'] / test.groupby(['card4'])['D15'].transform('mean')
test['D15_to_std_card1'] = test['D15'] / test.groupby(['card1'])['D15'].transform('std')
test['D15_to_std_card4'] = test['D15'] / test.groupby(['card4'])['D15'].transform('std')
train['D15_to_mean_addr1'] = train['D15'] / train.groupby(['addr1'])['D15'].transform('mean')
train['D15_to_mean_addr2'] = train['D15'] / train.groupby(['addr2'])['D15'].transform('mean')
train['D15_to_std_addr1'] = train['D15'] / train.groupby(['addr1'])['D15'].transform('std')
train['D15_to_std_addr2'] = train['D15'] / train.groupby(['addr2'])['D15'].transform('std')
test['D15_to_mean_addr1'] = test['D15'] / test.groupby(['addr1'])['D15'].transform('mean')
test['D15_to_mean_addr2'] = test['D15'] / test.groupby(['addr2'])['D15'].transform('mean')
test['D15_to_std_addr1'] = test['D15'] / test.groupby(['addr1'])['D15'].transform('std')
test['D15_to_std_addr2'] = test['D15'] / test.groupby(['addr2'])['D15'].transform('std' )<string_transform> | 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_emaildomain'].str.split('.', expand=True)
test[['R_emaildomain_1', 'R_emaildomain_2', 'R_emaildomain_3']] = test['R_emaildomain'].str.split('.', expand=True )<categorify> | 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')
encode_CB('card1_addr1','P_emaildomain')
encode_FE(train,test,['card1_addr1','card1_addr1_P_emaildomain'])
encode_AG(['TransactionAmt','D9','D11'],['card1','card1_addr1','card1_addr1_P_emaildomain'],['mean','std'],usena=True )<define_variables> | 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(axis=1)
test_data['std'] = test_data[features].std(axis=1)
test_data['max'] = test_data[features].max(axis=1)
test_data['min'] = test_data[features].min(axis=1)
test_data['sum'] = test_data[features].sum(axis=1 ) | 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 = ['ProductCD', 'card1', 'card2', 'card3', 'card4', 'card5', 'card6', 'addr1', 'addr2',
'P_emaildomain_1', 'P_emaildomain_2', 'P_emaildomain_3',
'R_emaildomain_1', 'R_emaildomain_2', 'R_emaildomain_3','P_emaildomain', 'R_emaildomain',
'P_emaildomain_bin', 'R_emaildomain_bin', 'P_emaildomain_suffix', 'R_emaildomain_suffix',
'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'M8', 'M9']
cat_cols = identity_cat_cols + transaction_cat_cols
cat_cols = list(set(cat_cols)& set(train.columns))
encoded_cols = ['addr1','card1','card2','card3']
cat_cols = list(set(cat_cols)- set(encoded_cols))
common_cat_cols = [col for col in test.columns if col in cat_cols]
cat_cols == common_cat_cols<drop_column> | 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_pred = model.predict(X_val)
print('Score validation data:', np.sqrt(mean_squared_error(y_val, y_val_pred)) ) | 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_sub['9'])/ 165
)/ 145)
submission = pd.DataFrame({'ID': sub_file.ID, 'target': df_sub['weighted_avg'].tolist() })
submission.to_csv(r'submission.csv', index=False ) | 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 seaborn as sns
import matplotlib.pyplot as plt | 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(['id_'+str(x)for x in range(22,28)])& set(cols)) :
cols.remove(c )<create_dataframe> | 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 = test[features]
target = train['target']
train.head() | 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
preds = np.zeros(test.shape[0])
kf = KFold(n_splits=7,random_state=48,shuffle=True)
rmse=[]
n=0
for trn_idx, test_idx in kf.split(train[features],target):
X_tr,X_val=train[features].iloc[trn_idx],train[features].iloc[test_idx]
y_tr,y_val=target.iloc[trn_idx],target.iloc[test_idx]
model = xgb.XGBRegressor(**Best_trial)
model.fit(X_tr,y_tr,eval_set=[(X_val,y_val)],early_stopping_rounds=100,verbose=False)
preds+=model.predict(test[features])/kf.n_splits
rmse.append(mean_squared_error(y_val, model.predict(X_val), squared=False))
print(n+1,rmse[n])
n+=1
print(f"mean RMSE for all the folds is {np.mean(rmse)}" ) | 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': -1,
'cat_smooth': 1.0,
'silent': True,
'importance_type': 'split',
'metric': 'rmse',
'feature_pre_filter': False,
'bagging_fraction': 0.8206341150202605,
'min_data_in_leaf': 100,
'min_sum_hessian_in_leaf': 0.001,
'bagging_freq': 6,
'feature_fraction': 0.5,
'min_gain_to_split': 0.0,
'min_child_samples': 20} | 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.