kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,331,351 | y_train.value_counts() /y_train.shape[0]<train_model> | preds = np.zeros(test.shape[0])
kf = KFold(n_splits=10,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 = lgb.LGBMRegressor(**Best_trial)
model.fit(X_tr,y_tr,eval_set=[(X_val,y_val)],early_stopping_rounds=50,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 | <prepare_x_and_y><EOS> | final_results = [x*0.72 + y*0.28 for x, y in zip(results, preds)]
sub['target']=final_results
sub.to_csv('submission.csv', index=False ) | Tabular Playground Series - Jan 2021 |
17,103,400 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<import_modules> | import optuna
import xgboost as xgb
import numpy as np
import pandas as pd
from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split | Tabular Playground Series - Jan 2021 |
17,103,400 |
<init_hyperparams> | 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' ) | Tabular Playground Series - Jan 2021 |
17,103,400 | best_params = {'bagging_fraction': 0.5818772519688797,
'colsample_bytree': 0.3035307099891744,
'feature_fraction': 0.795967379488282,
'gamma': 0.6896677451866189,
'learning_rate': 0.011336192527320772,
'max_depth': 20,
'min_child_samples': 140,
'num_leaves': 230,
'reg_alpha': 0.06035695642758,
'reg_lambda': 0.012734543098346575,
'subsample': 0.7}<prepare_x_and_y> | columns = [col for col in train.columns.to_list() if col not in ['id','target']] | Tabular Playground Series - Jan 2021 |
17,103,400 | X_train = final_train.copy()
y_train = X_train.pop('isFraud')
X_test = final_test.copy()
X_train,X_test = X_train.align(other=X_test,join='left', axis=1 )<train_model> | data=train[columns]
target=train['target'] | Tabular Playground Series - Jan 2021 |
17,103,400 | print("XGBoost version:", xgb.__version__)
clf = xgb.XGBClassifier(
n_estimators=2000,
**best_params,
tree_method='gpu_hist',
verbose=50,
early_stopping_rounds=100
)
clf.fit(X_train, y_train)
y_preds = clf.predict_proba(X_test)[:,1]<save_to_csv> | def objective(trial,data=data,target=target):
train_x, test_x, train_y, test_y = train_test_split(data, target, test_size=0.15,random_state=42)
param = {
'tree_method':'gpu_hist',
'lambda': trial.suggest_loguniform('lambda', 1e-3, 10.0),
'alpha': trial.suggest_loguniform('alpha', 1e-3, 10.0),
'colsample_bytree': trial.suggest_categorical('colsample_bytree', [0.3,0.4,0.5,0.6,0.7,0.8,0.9, 1.0]),
'subsample': trial.suggest_categorical('subsample', [0.4,0.5,0.6,0.7,0.8,1.0]),
'learning_rate': trial.suggest_categorical('learning_rate', [0.008,0.009,0.01,0.012,0.014,0.016,0.018, 0.02]),
'n_estimators': 4000,
'max_depth': trial.suggest_categorical('max_depth', [5,7,9,11,13,15,17,20]),
'random_state': trial.suggest_categorical('random_state', [24, 48,2020]),
'min_child_weight': trial.suggest_int('min_child_weight', 1, 300),
}
model = xgb.XGBRegressor(**param)
model.fit(train_x,train_y,eval_set=[(test_x,test_y)],early_stopping_rounds=100,verbose=False)
preds = model.predict(test_x)
rmse = mean_squared_error(test_y, preds,squared=False)
return rmse | Tabular Playground Series - Jan 2021 |
17,103,400 | sub['isFraud'] = y_preds
sub.to_csv('XGB_hypopt_model.csv', index=False )<import_modules> | Best_trial= {'lambda': 0.0042687338951820425,
'alpha': 6.2637008222060935,
'colsample_bytree': 0.4,
'subsample': 0.6,
'n_estimators': 4000,
'learning_rate': 0.01,
'max_depth': 11,
'random_state': 2020,
'min_child_weight': 171,
'tree_method':'gpu_hist'
} | Tabular Playground Series - Jan 2021 |
17,103,400 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
<load_from_csv> | preds = np.zeros(test.shape[0])
kf = KFold(n_splits=5,random_state=48,shuffle=True)
rmse=[]
models = []
n=0
for trn_idx, test_idx in kf.split(train[columns],train['target']):
X_tr,X_val=train[columns].iloc[trn_idx],train[columns].iloc[test_idx]
y_tr,y_val=train['target'].iloc[trn_idx],train['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[columns])/kf.n_splits
rmse.append(mean_squared_error(y_val, model.predict(X_val), squared=False))
models.append(model)
print(n+1,rmse[n])
n+=1 | Tabular Playground Series - Jan 2021 |
17,103,400 | train_transaction = pd.read_csv('/kaggle/input/ieee-fraud-detection/train_transaction.csv')
train_identity = pd.read_csv('/kaggle/input/ieee-fraud-detection/train_identity.csv')
test_transaction = pd.read_csv('/kaggle/input/ieee-fraud-detection/test_transaction.csv')
test_identity = pd.read_csv('/kaggle/input/ieee-fraud-detection/test_identity.csv' )<categorify> | sub['target']=preds
sub.to_csv('submission.csv', index=False ) | Tabular Playground Series - Jan 2021 |
17,103,400 | train_transaction = reduce_mem_usage(train_transaction, verbose = True)
train_identity = reduce_mem_usage(train_identity,verbose = True)
test_transaction = reduce_mem_usage(test_transaction, verbose=True)
test_identity = reduce_mem_usage(test_identity,verbose = True )<set_options> | import matplotlib.pyplot as plt | Tabular Playground Series - Jan 2021 |
14,305,889 | pd.set_option('display.max_columns', None )<merge> | train_df = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/train.csv", index_col=["id"])
test_df = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/test.csv", index_col=["id"])
X = train_df.iloc[:, :-1].to_numpy()
y = train_df.iloc[:, -1].to_numpy()
X_test = test_df.to_numpy() | Tabular Playground Series - Jan 2021 |
14,305,889 | final_train = pd.merge(train_transaction, train_identity, how = 'left', on = 'TransactionID')
final_test = pd.merge(test_transaction, test_identity, how = 'left', on = 'TransactionID')
<drop_column> | def train(model):
X_train, X_test, y_train, y_test = train_test_split(X, y.flatten() , test_size=0.1, random_state=156)
y_train = y_train.reshape(-1, 1)
y_test = y_test.reshape(-1, 1)
model = model.fit(X_train, y_train, early_stopping_rounds=100, verbose=False, eval_set=[(X_test, y_test)])
score = mean_squared_error(model.predict(X_train), y_train, squared=False)
print(score)
return model | Tabular Playground Series - Jan 2021 |
14,305,889 | del train_transaction
del train_identity
del test_transaction
del test_identity<rename_columns> | def objectiveXGB(trial: Trial, X, y, test):
param = {
"n_estimators" : trial.suggest_int('n_estimators', 500, 4000),
'max_depth':trial.suggest_int('max_depth', 8, 16),
'min_child_weight':trial.suggest_int('min_child_weight', 1, 300),
'gamma':trial.suggest_int('gamma', 1, 3),
'learning_rate': 0.01,
'colsample_bytree':trial.suggest_discrete_uniform('colsample_bytree',0.5, 1, 0.1),
'nthread' : -1,
'tree_method': 'gpu_hist',
'predictor': 'gpu_predictor',
'lambda': trial.suggest_loguniform('lambda', 1e-3, 10.0),
'alpha': trial.suggest_loguniform('alpha', 1e-3, 10.0),
'subsample': trial.suggest_categorical('subsample', [0.6,0.7,0.8,1.0]),
'random_state': 42
}
X_train, X_test, y_train, y_test = train_test_split(X, y.flatten() , test_size=0.1)
y_train = y_train.reshape(-1, 1)
y_test = y_test.reshape(-1, 1)
model = xgb.XGBRegressor(**param)
xgb_model = model.fit(X_train, y_train, verbose=False, eval_set=[(X_test, y_test)])
score = mean_squared_error(xgb_model.predict(X_test), y_test, squared=False)
return score | Tabular Playground Series - Jan 2021 |
14,305,889 | final_test = final_test.rename(columns = {"id-01": "id_01", "id-02": "id_02", "id-03": "id_03",
"id-06": "id_06", "id-05": "id_05", "id-04": "id_04",
"id-07": "id_07", "id-08": "id_08", "id-09": "id_09",
"id-10": "id_10", "id-11": "id_11", "id-12": "id_12",
"id-15": "id_15", "id-14": "id_14", "id-13": "id_13",
"id-16": "id_16", "id-17": "id_17", "id-18": "id_18",
"id-21": "id_21", "id-20": "id_20", "id-19": "id_19",
"id-22": "id_22", "id-23": "id_23", "id-24": "id_24",
"id-27": "id_27", "id-26": "id_26", "id-25": "id_25",
"id-28": "id_28", "id-29": "id_29", "id-30": "id_30",
"id-31": "id_31", "id-32": "id_32", "id-33": "id_33",
"id-34": "id_34", "id-35": "id_35", "id-36": "id_36",
"id-37": "id_37", "id-38": "id_38"})
final_test.head()<count_missing_values> | study = optuna.create_study(direction='minimize',sampler=TPESampler())
study.optimize(lambda trial : objectiveXGB(trial, X, y, X_test), n_trials=50)
print('Best trial: score {},
params {}'.format(study.best_trial.value,study.best_trial.params))
best_param = study.best_trial.params
xgbReg = train(xgb.XGBRegressor(**best_param, tree_method='gpu_hist', random_state=42, predictor='gpu_predictor', learning_rate=0.01, nthread=-1))
| Tabular Playground Series - Jan 2021 |
14,305,889 | def getNulls(data):
total = data.isnull().sum()
percent = data.isnull().sum() / data.isnull().count()
missing_data = pd.concat([total, percent], axis = 1, keys = ['total', 'precent'])
return missing_data<count_missing_values> | def objectiveLGBM(trial: Trial, X, y, test):
param = {
'objective': 'regression',
'metric': 'root_mean_squared_error',
'verbosity': -1,
'boosting_type': 'gbdt',
'lambda_l1': trial.suggest_loguniform('lambda_l1', 1e-8, 10.0),
'lambda_l2': trial.suggest_loguniform('lambda_l2', 1e-8, 10.0),
'num_leaves': trial.suggest_int('num_leaves', 2, 512),
'learning_rate': 0.01,
'n_estimators': trial.suggest_int('n_estimators', 700, 3000),
'feature_fraction': trial.suggest_uniform('feature_fraction', 0.4, 1.0),
'bagging_fraction': trial.suggest_uniform('bagging_fraction', 0.4, 1.0),
'bagging_freq': trial.suggest_int('bagging_freq', 1, 7),
'min_child_samples': trial.suggest_int('min_child_samples', 5, 100),
'device':"gpu",
'gpu_use_dp':True
}
X_train, X_test, y_train, y_test = train_test_split(X, y.flatten() , test_size=0.1)
lgbm_regr = LGBMRegressor(**param)
lgbm_regr = lgbm_regr.fit(X_train, y_train, verbose=False)
score = mean_squared_error(lgbm_regr.predict(X_test), y_test, squared=False)
return score | Tabular Playground Series - Jan 2021 |
14,305,889 | missing_data_train = getNulls(final_train)
missing_data_train.head(434 ).T<drop_column> | study = optuna.create_study(direction='minimize',sampler=TPESampler())
study.optimize(lambda trial : objectiveLGBM(trial, X, y, X_test), n_trials=20)
print('Best trial: score {},
params {}'.format(study.best_trial.value,study.best_trial.params))
best_param2 = study.best_trial.params
lgbm = LGBMRegressor(**best_param2, device="gpu",gpu_use_dp=True, objective='regression', metric='root_mean_squared_error', learning_rate= 0.01, boosting_type='gbdt')
| Tabular Playground Series - Jan 2021 |
14,305,889 | del missing_data_train<concatenate> | final_model = xgb.XGBRegressor(n_estimators= 2000, max_depth= 16,tree_method='gpu_hist', predictor='gpu_predictor')
sgd = SGDRegressor(max_iter=1000)
hgb = HistGradientBoostingRegressor(max_depth=3, min_samples_leaf=1)
cat = CatBoostRegressor(task_type="GPU", verbose=False)
estimators = [
lgbm, cat, sgd, hgb, xgbReg
]
S_train, S_test = stacking(estimators, X, y, X_test, regression=True, metric=mean_squared_error, n_folds=5,
shuffle=False, random_state=0, verbose=2)
final_model.fit(S_train, y)
print(mean_squared_error(final_model.predict(S_train), y, squared=False)) | Tabular Playground Series - Jan 2021 |
14,305,889 | ntrain = final_train.shape[0]
ntest = final_test.shape[0]
all_data = pd.concat([final_train, final_test], axis = 0, sort = False )<drop_column> | submission = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/test.csv", index_col=["id"])
y_hat = final_model.predict(S_test)
submission["target"] = y_hat
submission[["target"]].to_csv("/kaggle/working/submission_stacking.csv")
joblib.dump(final_model, '/kaggle/working/skacking.pkl' ) | Tabular Playground Series - Jan 2021 |
14,305,889 | all_data = all_data.drop(columns=['isFraud'] )<drop_column> | submission = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/test.csv", index_col=["id"])
lgbm = LGBMRegressor(**best_param2, device="gpu",gpu_use_dp=True, objective='regression', learning_rate= 0.01, metric='root_mean_squared_error', boosting_type='gbdt')
lgbm = lgbm.fit(X, y, verbose=False)
y_hat = lgbm.predict(submission.to_numpy())
print(mean_squared_error(lgbm.predict(X), y, squared=False))
submission["target"] = y_hat
submission[["target"]].to_csv("/kaggle/working/submission_lgbm.csv")
joblib.dump(lgbm, '/kaggle/working/lgbm.pkl' ) | Tabular Playground Series - Jan 2021 |
14,305,889 | <define_variables><EOS> | submission = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/test.csv", index_col=["id"])
params = {'n_estimators': 3520, 'max_depth': 11, 'min_child_weight': 231, 'gamma': 2, 'colsample_bytree': 0.7, 'lambda': 0.014950936465569798, 'alpha': 0.28520156840812494, 'subsample': 0.6}
xgbReg = train(xgb.XGBRegressor(**params, tree_method='gpu_hist', random_state=42, predictor='gpu_predictor', learning_rate=0.01, nthread=-1))
y_hat = xgbReg.predict(submission.to_numpy())
print(mean_squared_error(xgbReg.predict(X), y, squared=False))
submission["target"] = y_hat
submission[["target"]].to_csv("/kaggle/working/submission_xgb.csv")
joblib.dump(xgbReg, '/kaggle/working/xgb_reg.pkl' ) | Tabular Playground Series - Jan 2021 |
14,589,590 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<define_variables> | sns.set(font_scale=1.4)
warnings.filterwarnings("ignore")
| Tabular Playground Series - Jan 2021 |
14,589,590 | num_cols_to_shrink_all = detect_num_cols_to_shrink(num_all_cols, all_data)
convert_to_int8 = num_cols_to_shrink_all[0]
convert_to_int16 = num_cols_to_shrink_all[1]
convert_to_int32 = num_cols_to_shrink_all[2]
convert_to_float16 = num_cols_to_shrink_all[3]
convert_to_float32 = num_cols_to_shrink_all[4]<data_type_conversions> | def root_mean_squared_error(y_true, y_pred):
return K.sqrt(K.mean(K.square(y_pred - y_true)) ) | Tabular Playground Series - Jan 2021 |
14,589,590 | print("starting with converting process.... ")
for col in convert_to_int16:
all_data[col] = all_data[col].astype('int16')
for col in convert_to_int32:
all_data[col] = all_data[col].astype('int32')
for col in convert_to_float16:
all_data[col] = all_data[col].astype('float16')
for col in convert_to_float32:
all_data[col] = all_data[col].astype('float32')
print("successfully converted!" )<define_variables> | def add_pca(train_df, test_df, cols, n_comp=20, fit_test = True, prefix='pca_', fit_test_first=False):
pca = PCA(n_components=n_comp, random_state=42)
pca_titles = [prefix+'_pca_'+str(x)for x in range(n_comp)]
temp_train = train_df.copy()
temp_test = test_df.copy()
for c in cols:
fv = temp_train[c].mean()
temp_train[c] = temp_train[c].fillna(value=fv)
fv = temp_test[c].mean()
temp_test[c] = temp_test[c].fillna(value=fv)
for p in pca_titles:
train_df[p] = 0.0
test_df[p] = 0.0
if fit_test==True:
pca_data = pd.concat([temp_train[cols], temp_test[cols]], axis=0)
if fit_test_first==True:
pca.fit(pca_data[len(train_df):])
pca_data = pca.transform(pca_data)
else:
pca_data = pca.fit_transform(pca_data)
train_df.loc[:, pca_titles] = pca_data[0:len(train_df)]
test_df.loc[:, pca_titles] = pca_data[len(train_df):]
return train_df, test_df, pca_titles
def split_distributions(train_df, test_df, cols, target, n_comp=20, prefix='gm', add_labels=False):
gm = GaussianMixture(n_components=n_comp,covariance_type='full', tol=0.001, reg_covar=1e-06, max_iter=100, n_init=1,
init_params='kmeans', weights_init=None, means_init=None, precisions_init=None,
random_state=42, warm_start=False, verbose=0, verbose_interval=10)
temp_train = train_df.copy()
temp_test = test_df.copy()
gm_data = pd.concat([temp_train[[cols]], temp_test[[cols]]], axis=0 ).reset_index(drop=True)
gm.fit(gm_data)
gm_data['labels'] = gm.predict(gm_data)
if add_labels:
gm_titles = [prefix+str(x)for x in range(n_comp)]
train_df[gm_titles]=0
test_df[gm_titles]=0
dummies = pd.get_dummies(gm_data['labels'], prefix=prefix)
train_df.loc[:, gm_titles] = dummies[0:len(train_df)].values
test_df.loc[:, gm_titles] = dummies[len(train_df):].values
else:
gm_titles = []
train_df[prefix+'_label'] = gm.labels_[0:len(train_df)]
test_df[prefix+'_label'] = gm.labels_[len(train_df):]
means = train_df.groupby([prefix+'_label'])[target].mean()
train_df['menc_'+prefix+'_label'] = train_df[prefix+'_label'].map(means)
test_df['menc_'+prefix+'_label'] = test_df[prefix+'_label'].map(means)
gm_titles+=[prefix+'_label', 'menc_'+prefix+'_label']
return train_df, test_df, gm_titles
def assign_fold(df, label_column,fold_column, NFOLDS=5):
skf = StratifiedKFold(n_splits=NFOLDS)
df[fold_column]=0
f=0
for trn_idx, val_idx in skf.split(df, df[label_column]):
df.loc[val_idx, 'fold']=f
f+=1
df[fold_column].value_counts()
return df
def st_scale(train_df, test_df, cols):
StSc = StandardScaler()
train_df[cols] = StSc.fit_transform(train_df[cols])
test_df[cols] = StSc.transform(test_df[cols])
return train_df, test_df
def seed_everything(seed=1234):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed ) | Tabular Playground Series - Jan 2021 |
14,589,590 | 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 += [96, 98, 99, 104]
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]
v += [332, 325, 335, 338]<drop_column> | PATH = '/kaggle/input/tabular-playground-series-jan-2021/'
train = pd.read_csv(PATH+'train.csv')
test = pd.read_csv(PATH+'test.csv')
submission = pd.read_csv(PATH+'sample_submission.csv')
FT_COLS = [x for x in train.columns if 'cont' in x]
TARGET='target'
print(train.shape)
train.head(10 ) | Tabular Playground Series - Jan 2021 |
14,589,590 | cols = ['V'+str(x)for x in v]
for i in all_data_cols:
if(i.startswith("V")) and i not in cols:
all_data = all_data.drop(columns=[i])
all_data<drop_column> | original_feature_dict = {'cont1': 5,
'cont2': 10,
'cont3': 8,
'cont4': 8,
'cont5': 5,
'cont6': 6,
'cont7': 4,
'cont8': 3,
'cont9': 7,
'cont10':3,
'cont11': 4,
'cont12': 2,
'cont13': 3,
'cont14': 5,}
pca_dict = {
'extra_pca_0': 4,
'extra_pca_1': 1,
'extra_pca_2': 1,
'extra_pca_3': 2,
'extra_pca_4': 1,
'extra_pca_5': 1 }
MULTIPLIER = 3.0
original_feature_dict = {a:int(b*MULTIPLIER)for(a,b)in original_feature_dict.items() }
ft_dict = {**original_feature_dict, **pca_dict}
ft_dict | Tabular Playground Series - Jan 2021 |
14,589,590 | for c in ['C3','M5','id_08','id_33']:
cols.remove(c)
all_data = all_data.drop(columns=[i])
for c in ['card4','id_07','id_14','id_21','id_30','id_32','id_34']:
cols.remove(c)
all_data = all_data.drop(columns=[i])
for c in ['id_'+str(x)for x in range(22,28)]:
cols.remove(c)
all_data = all_data.drop(columns=[i])
for c in ['D6','D7','D8','D9','D12','D13','D14']:
cols.remove(c)
all_data = all_data.drop(columns=[i] )<define_variables> | mixture_title_cols=[]
for f in FT_COLS+pca_titles2:
train, test, titles = split_distributions(train, test,f,TARGET, n_comp=ft_dict[f], prefix=f+'_dim', add_labels=True)
mixture_title_cols+=titles
mixture_value_cols = []
for count,f in enumerate(FT_COLS+pca_titles2):
for d in range(ft_dict[f]):
t_median = train[f][train[f+'_dim'+str(d)]==1].median()
t_std = train[f][train[f+'_dim'+str(d)]==1].std()
train[f+'_dim'+str(d)+'_dist'] = np.where(train[f+'_dim'+str(d)]==1,
(train[f] - t_median)/t_std, np.nan)
test[f+'_dim'+str(d)+'_dist'] = np.where(test[f+'_dim'+str(d)]==1,
(test[f] - t_median)/t_std, np.nan)
mixture_value_cols+=[f+'_dim'+str(d)+'_dist'] | Tabular Playground Series - Jan 2021 |
14,589,590 | numerical = all_data.select_dtypes(include='number')
categorical = all_data.select_dtypes(exclude = 'number')
numeric_transformer = Pipeline(steps=[('mean',SimpleImputer(strategy='constant',fill_value=-1)) ])
categorical_transformer = Pipeline(steps=[('constant', SimpleImputer(strategy='constant',fill_value=-1)) ] )<split> | print('Total Original Features', len(FT_COLS))
print('Total Submixtures Labels', len(mixture_title_cols))
print('Total Submixtures Values', len(mixture_value_cols))
print('Total Feature Columns', len(FT_COLS)+len(mixture_title_cols)+len(mixture_value_cols)) | Tabular Playground Series - Jan 2021 |
14,589,590 | final_train = all_data[ : ntrain]
final_test = all_data[ntrain : ]<drop_column> | NAN_VALUE = 0.0
for d in mixture_value_cols:
train[d] = train[d].fillna(value=NAN_VALUE)
test[d] = test[d].fillna(value=NAN_VALUE ) | Tabular Playground Series - Jan 2021 |
14,589,590 | del all_data<data_type_conversions> | SCALE = True
if SCALE:
train, test = st_scale(train, test, FT_COLS)
for f in FT_COLS:
train[f] = np.clip(train[f], -2, 2)
test[f] = np.clip(test[f], -2, 2)
SCALE_DISTS = True
if SCALE_DISTS:
for d in mixture_value_cols:
TEMP_MAX = np.abs(train[d] ).max()
train[d] = train[d] / TEMP_MAX
test[d] = test[d] / TEMP_MAX | Tabular Playground Series - Jan 2021 |
14,589,590 | for i,f in enumerate(final_train.columns):
if(np.str(final_train[f].dtype)=='category')|(final_train[f].dtype=='object'):
df_comb = pd.concat([final_train[f],final_test[f]],axis=0)
df_comb,_ = df_comb.factorize(sort=True)
if df_comb.max() >32000: print(f,'needs int32')
final_train[f] = df_comb[:len(final_train)].astype('int16')
final_test[f] = df_comb[len(final_train):].astype('int16')
elif f not in ['TransactionAmt','TransactionDT']:
mn = np.min(( final_train[f].min() ,final_test[f].min()))
final_train[f] -= np.float32(mn)
final_test[f] -= np.float32(mn)
final_train[f].fillna(-999,inplace=True)
final_test[f].fillna(-999,inplace=True )<count_values> | train['outlier_filter'] = np.where(train[TARGET]<4, True, False)
print(' | Tabular Playground Series - Jan 2021 |
14,589,590 | y.value_counts()<choose_model_class> | print('CV Benchmark - Random Guess of Median')
cv_bm = np.sqrt(mse(train[TARGET], np.full(( train[TARGET].shape), train[TARGET].median())))
cv_bm | Tabular Playground Series - Jan 2021 |
14,589,590 | model = xgb.XGBClassifier(n_estimators=2000,
max_depth=12,
learning_rate=0.02,
subsample=0.8,
colsample_bytree=0.4,
missing=-1,
eval_metric='auc',
tree_method='hist'
)<prepare_x_and_y> | def run_training(model, train_df, test_df,sample_submission, fold_col,
orig_features, mixture_val_cols,mixture_label_cols, target_col,
benchmark,
outlier_col=None, nn=False, epochs=10,batch_size=32, verbose=False,
dense=70, dout=0.15, dense_reg = 0.000001,act='elu'):
FOLD_VALUES = sorted([x for x in train_df[fold_col].unique() ])
oof = np.zeros(( len(train_df),))
test_predictions = np.zeros(( len(sample_submission),))
fig,axes=plt.subplots(figsize=(15,6))
axes.set_ylim(0.69,0.75)
RANDOM_SEEDS = [0,42,100,1000]
for rs in RANDOM_SEEDS:
seed_everything(seed=rs)
for fold in FOLD_VALUES:
print(' --- ')
print('running random seed', rs, 'fold', fold)
if outlier_col:
trn_idx =(train_df[fold_col]!=fold)&(~train_df[outlier_col])
else:
trn_idx = train_df[fold_col]!=fold
val_idx = train_df[fold_col]==fold
X_train_orig = train_df.loc[trn_idx,orig_features].values
X_train = train_df.loc[trn_idx,mixture_val_cols].values
X_train_mask = train_df.loc[trn_idx,mixture_label_cols].values
y_train = train_df.loc[trn_idx, target_col].values
X_val_orig = train_df.loc[val_idx,orig_features].values
X_val = train_df.loc[val_idx,mixture_val_cols].values
X_val_mask = train_df.loc[val_idx,mixture_label_cols].values
y_val = train_df.loc[val_idx, target_col].values
model = keras_model(orig_features, mixture_val_cols,mixture_label_cols,dout=dout,
dense=dense,act=act, dense_reg = dense_reg, descend_fraction = 0.9)
K.clear_session()
back_count = 5
epoch_list=list(range(epochs-back_count, epochs))
class CustomModelCheckpoint(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs=None):
if epoch in epoch_list:
self.model.save_weights('model_fold_'+str(fold)+'_epoch_'+str(epoch)+'.h5', overwrite=True)
else:
pass
cbk = CustomModelCheckpoint()
history = model.fit([X_train_orig, X_train,X_train_mask ], y_train, epochs=epochs, batch_size=batch_size,shuffle=True,
validation_data=([X_val_orig, X_val,X_val_mask], y_val), verbose=verbose,
callbacks=[cbk])
print('Fold Last Epoch Train Error', history.history['root_mean_squared_error'][-1])
print('Fold Last Epoch Valid Error', history.history['val_root_mean_squared_error'][-1])
model.save_weights('model_final_'+str(fold)+'.h5')
sns.lineplot(x=range(epochs), y=history.history['loss'], color='Blue')
sns.lineplot(x=range(epochs), y=history.history['val_loss'], color='Red')
val_preds = np.zeros(( len(X_val),))
for e in epoch_list:
model = keras_model(orig_features, mixture_val_cols,mixture_label_cols,dout=dout,
dense=dense,act=act, dense_reg = dense_reg, descend_fraction = 0.9)
model.load_weights('model_fold_'+str(fold)+'_epoch_'+str(e)+'.h5')
val_preds += model.predict([X_val_orig, X_val,X_val_mask] ).mean(axis=1)
test_predictions += model.predict([test_df[orig_features].values,test_df[mixture_val_cols].values,
test_df[mixture_label_cols].values] ).mean(axis=1)
val_preds = val_preds / len(epoch_list)
oof[val_idx]+=val_preds
val_error = np.sqrt(mse(y_val, val_preds))
print('Fold multi epoch weight prediction error', val_error)
oof = oof / len(RANDOM_SEEDS)
total_val_error = np.sqrt(mse(train_df[target_col], oof))
print('final OOF MSE', total_val_error)
fold_errors = []
for fold in train_df[fold_col].unique() :
val_idx = train_df[fold_col]==fold
fold_errors+=[np.sqrt(mse(train_df.loc[val_idx, target_col].values, oof[val_idx])) ]
test_predictions = test_predictions/(NFOLDS * len(RANDOM_SEEDS)* len(epoch_list))
return oof, test_predictions, fold_errors | Tabular Playground Series - Jan 2021 |
14,589,590 | X_train = final_train
y_train = y
X_test = final_test<drop_column> | def keras_model(ft_orig, mixture_values, mixture_labels, n_layer=3,bnorm=True,dout=0.2,
dense=20,act='elu', dense_reg = 0.000001, descend_fraction = 0.9):
input1 = L.Input(shape=(len(ft_orig)) , name='input_orig')
input1_do = L.Dropout(0.1 )(input1)
XA = L.Dense(dense, activation=act, activity_regularizer=tf.keras.regularizers.L2(dense_reg), name='dense_orig' )(input1_do)
if bnorm:
XA = L.BatchNormalization(name='bn_1' )(XA)
XA1 = L.Dropout(dout, name='do_orig' )(XA)
input2 = L.Input(shape=(len(mixture_values)) , name='input_new')
input3 = L.Input(shape=(len(mixture_labels)) , name='input_new2')
all_input_combo = tf.keras.layers.Concatenate(axis=1, name='concat_i2' )([input2, input3])
input2_do = L.Dropout(0.2 )(all_input_combo)
XB = L.Dense(dense, activation=act, activity_regularizer=tf.keras.regularizers.L2(dense_reg), name='dense_new' )(input2_do)
if bnorm:
XB = L.BatchNormalization(name='bn_2' )(XB)
XB1 = L.Dropout(dout, name='do_new' )(XB)
all_input_combo = tf.keras.layers.Concatenate(axis=1, name='concat_new' )([XA1, XB1])
X = L.Dense(int(dense), activation=act, activity_regularizer=tf.keras.regularizers.L2(dense_reg))(all_input_combo)
if bnorm:
X = L.BatchNormalization(name='bn_3' )(X)
X2 = L.Dropout(dout, name='do_3' )(X)
X2 = tf.keras.layers.concatenate([all_input_combo, X2], axis=1)
X = L.Dense(int(( descend_fraction**2)*dense), activation=act, activity_regularizer=tf.keras.regularizers.L2(dense_reg))(X2)
if bnorm:
X = L.BatchNormalization()(X)
X3 = L.Dropout(dout )(X)
X3 = tf.keras.layers.concatenate([X2, X3], axis=1)
X = L.Dense(int(( descend_fraction**3)*dense), activation=act, activity_regularizer=tf.keras.regularizers.L2(dense_reg *2))(X3)
if bnorm:
X = L.BatchNormalization()(X)
X4 = L.Dropout(dout )(X)
X4 = tf.keras.layers.concatenate([X3, X4],axis=1)
X = L.Dense(int(( descend_fraction**4)*dense), activation=act, activity_regularizer=tf.keras.regularizers.L2(dense_reg*4))(X4)
if bnorm:
X = L.BatchNormalization()(X)
X5 = L.Dropout(dout )(X)
X5 = tf.keras.layers.concatenate([X4, X5], axis=1)
X = L.Dense(5, activation=act, activity_regularizer=tf.keras.regularizers.L2(0.0001))(X5)
output1 = L.Dense(1, activation='linear' )(X)
model = tf.keras.Model(inputs=[input1, input2, input3], outputs=output1)
model.compile(loss=root_mean_squared_error,
optimizer=tfa.optimizers.AdamW(learning_rate=0.000809028893821181, weight_decay=9.83479875802558E-06),
metrics=tf.keras.metrics.RootMeanSquaredError())
return model
K.clear_session()
model = keras_model(FT_COLS, mixture_title_cols, mixture_value_cols,
dense=70,
dout=0.15,
dense_reg = 0.000001,
act='elu',
descend_fraction = 0.9)
model.summary() | Tabular Playground Series - Jan 2021 |
14,589,590 | del final_train
del y
del final_test<drop_column> | oof, test_predictions, fold_errors = run_training(model, train, test,submission, 'fold', FT_COLS,
mixture_value_cols, mixture_title_cols, TARGET, cv_bm,
outlier_col='outlier_filter',
epochs=25,
batch_size=256,
verbose=False,
dense=70,
dout=0.15,
dense_reg = 0.000001,
act='elu', ) | Tabular Playground Series - Jan 2021 |
14,589,590 | final_col = X_train['TransactionID']
X_train = X_train.drop(columns=['TransactionID'] )<feature_engineering> | print('Save Out of Fold Predictions')
oof = pd.DataFrame(columns=['oof_prediction'], index=train['id'], data=oof + TARGET_MEAN)
oof.to_csv('oof_predictions.csv', index=True)
oof.head(10 ) | Tabular Playground Series - Jan 2021 |
14,589,590 | START_DATE = datetime.datetime.strptime('2017-11-30', '%Y-%m-%d')
X_train['DT_M'] = X_train['TransactionDT'].apply(lambda x:(START_DATE + datetime.timedelta(seconds = x)))
X_train['DT_M'] =(X_train['DT_M'].dt.year-2017)*12 + X_train['DT_M'].dt.month
X_test['DT_M'] = X_test['TransactionDT'].apply(lambda x:(START_DATE + datetime.timedelta(seconds = x)))
X_test['DT_M'] =(X_test['DT_M'].dt.year-2017)*12 + X_test['DT_M'].dt.month<drop_column> | print('fold errors', fold_errors)
print('fold error std', np.array(fold_errors ).std() ) | Tabular Playground Series - Jan 2021 |
14,589,590 | cols = list(X_train.columns)
cols.remove('TransactionDT' )<define_variables> | submission['target'] = test_predictions + TARGET_MEAN
submission.to_csv('submission.csv', index=False)
submission.head(5 ) | Tabular Playground Series - Jan 2021 |
14,579,645 | idxT = X_train.index[:3*len(X_train)//4]
idxV = X_train.index[3*len(X_train)//4:]<train_on_grid> | import numpy as np
import pandas as pd
from math import sqrt
from xgboost import XGBRegressor
from lightgbm import LGBMRegressor
from sklearn.impute import SimpleImputer
from sklearn.ensemble import VotingRegressor
from sklearn.feature_selection import VarianceThreshold
from sklearn.metrics import make_scorer, mean_squared_error
from sklearn.model_selection import GridSearchCV, ParameterGrid, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer, StandardScaler | Tabular Playground Series - Jan 2021 |
14,579,645 | oof = np.zeros(len(X_train))
preds = np.zeros(len(X_test))
skf = GroupKFold(n_splits=6)
for i,(idxT, idxV)in enumerate(skf.split(X_train, y_train, groups=X_train['DT_M'])) :
month = X_train.iloc[idxV]['DT_M'].iloc[0]
print('Fold',i,'withholding month',month)
print(' rows of train =',len(idxT),'rows of holdout =',len(idxV))
clf = xgb.XGBClassifier(
n_estimators=5000,
max_depth=12,
learning_rate=0.02,
subsample=0.8,
colsample_bytree=0.4,
missing=-1,
eval_metric='auc',
tree_method='hist'
)
h = clf.fit(X_train[cols].iloc[idxT], y_train.iloc[idxT],
eval_set=[(X_train[cols].iloc[idxV],y_train.iloc[idxV])],
verbose=100, early_stopping_rounds=200)
oof[idxV] += clf.predict_proba(X_train[cols].iloc[idxV])[:,1]
preds += clf.predict_proba(X_test[cols])[:,1]/skf.n_splits
print('
print('XGB96 OOF CV=',roc_auc_score(y_train,oof))<categorify> | RANDOM_STATE = 2021
CROSS_VALIDATION = 3 | Tabular Playground Series - Jan 2021 |
14,579,645 | def encode_FE(df1, df2, cols):
for col in cols:
df = pd.concat([df1[col],df2[col]])
vc = df.value_counts(dropna=True, normalize=True ).to_dict()
vc[-1] = -1
nm = col+'_FE'
df1[nm] = df1[col].map(vc)
df1[nm] = df1[nm].astype('float32')
df2[nm] = df2[col].map(vc)
df2[nm] = df2[nm].astype('float32')
print(nm,', ',end='')
def encode_LE(col,train=X_train,test=X_test,verbose=True):
df_comb = pd.concat([train[col],test[col]],axis=0)
df_comb,_ = df_comb.factorize(sort=True)
nm = col
if df_comb.max() >32000:
train[nm] = df_comb[:len(train)].astype('int32')
test[nm] = df_comb[len(train):].astype('int32')
else:
train[nm] = df_comb[:len(train)].astype('int16')
test[nm] = df_comb[len(train):].astype('int16')
del df_comb; x=gc.collect()
if verbose: print(nm,', ',end='')
def encode_AG(main_columns, uids, aggregations=['mean'], train_df=X_train, test_df=X_test,
fillna=True, usena=False):
for main_column in main_columns:
for col in uids:
for agg_type in aggregations:
new_col_name = main_column+'_'+col+'_'+agg_type
temp_df = pd.concat([train_df[[col, main_column]], test_df[[col,main_column]]])
if usena: temp_df.loc[temp_df[main_column]==-1,main_column] = np.nan
temp_df = temp_df.groupby([col])[main_column].agg([agg_type] ).reset_index().rename(
columns={agg_type: new_col_name})
temp_df.index = list(temp_df[col])
temp_df = temp_df[new_col_name].to_dict()
train_df[new_col_name] = train_df[col].map(temp_df ).astype('float32')
test_df[new_col_name] = test_df[col].map(temp_df ).astype('float32')
if fillna:
train_df[new_col_name].fillna(-1,inplace=True)
test_df[new_col_name].fillna(-1,inplace=True)
print("'"+new_col_name+"'",', ',end='')
def encode_CB(col1,col2,df1=X_train,df2=X_test):
nm = col1+'_'+col2
df1[nm] = df1[col1].astype(str)+'_'+df1[col2].astype(str)
df2[nm] = df2[col1].astype(str)+'_'+df2[col2].astype(str)
encode_LE(nm,verbose=False)
print(nm,', ',end='')
def encode_AG2(main_columns, uids, train_df=X_train, test_df=X_test):
for main_column in main_columns:
for col in uids:
comb = pd.concat([train_df[[col]+[main_column]],test_df[[col]+[main_column]]],axis=0)
mp = comb.groupby(col)[main_column].agg(['nunique'])['nunique'].to_dict()
train_df[col+'_'+main_column+'_ct'] = train_df[col].map(mp ).astype('float32')
test_df[col+'_'+main_column+'_ct'] = test_df[col].map(mp ).astype('float32')
print(col+'_'+main_column+'_ct, ',end='' )<data_type_conversions> | data_dir = '/kaggle/input/tabular-playground-series-jan-2021' | Tabular Playground Series - Jan 2021 |
14,579,645 | encode_CB('card1','addr1')
X_train['day'] =X_train.TransactionDT /(24*60*60)
X_train['uid'] = X_train.card1_addr1.astype(str)+'_'+np.floor(X_train.day-X_train.D1 ).astype(str)
X_test['day'] = X_test.TransactionDT /(24*60*60)
X_test['uid'] =X_test.card1_addr1.astype(str)+'_'+np.floor(X_test.day-X_test.D1 ).astype(str )<categorify> | df = pd.read_csv(f"{data_dir}/train.csv" ).set_index('id' ).convert_dtypes()
display(df.shape)
df.head(2 ) | Tabular Playground Series - Jan 2021 |
14,579,645 | %%time
X_train['cents'] =(X_train['TransactionAmt'] - np.floor(X_train['TransactionAmt'])).astype('float32')
X_test['cents'] =(X_test['TransactionAmt'] - np.floor(X_test['TransactionAmt'])).astype('float32')
encode_FE(X_train,X_test,['uid'])
encode_AG(['TransactionAmt','D4','D9','D10','D15'],['uid'],['mean','std'],fillna=True,usena=True)
encode_AG(['C'+str(x)for x in range(1,15)if x!=3],['uid'],['mean'],X_train,X_test,fillna=True,usena=True)
encode_AG(['M'+str(x)for x in range(1,10)],['uid'],['mean'],fillna=True,usena=True)
encode_AG2(['P_emaildomain','dist1','DT_M','id_02','cents'], ['uid'], train_df=X_train, test_df=X_test)
encode_AG(['C14'],['uid'],['std'],X_test,X_test,fillna=True,usena=True)
encode_AG2(['C13','V314'], ['uid'], train_df=X_train, test_df=X_test)
encode_AG2(['V127','V136','V309','V307','V320'], ['uid'], train_df=X_train, test_df=X_test)
X_train['outsider15'] =(np.abs(X_train.D1-X_train.D15)>3 ).astype('int8')
X_test['outsider15'] =(np.abs(X_test.D1-X_test.D15)>3 ).astype('int8')
print('outsider15' )<feature_engineering> | X = df.copy()
y = X.pop('target')
X_train, X_valid, y_train, y_valid = train_test_split(
X, y, train_size=0.8, test_size=0.2, random_state=RANDOM_STATE,
) | Tabular Playground Series - Jan 2021 |
14,579,645 | for i in range(1,16):
if i in [1,2,3,5,9]: continue
X_train['D'+str(i)] = X_train['D'+str(i)] - X_train.TransactionDT/np.float32(24*60*60)
X_test['D'+str(i)] = X_test['D'+str(i)] - X_test.TransactionDT/np.float32(24*60*60 )<drop_column> | preprocessor = Pipeline(steps=[
('imputer', SimpleImputer()),
('log', FunctionTransformer(np.log1p)) ,
('scaler', StandardScaler()),
] ) | Tabular Playground Series - Jan 2021 |
14,579,645 | cols = list(X_train.columns)
cols.remove('TransactionDT')
for c in ['DT_M','day','uid']:
cols.remove(c)
<prepare_x_and_y> | pipeline = Pipeline([
('preprocessor', preprocessor),
('variance_drop', VarianceThreshold(threshold=(0.95 *(1 - 0.95)))) ,
('voting', 'passthrough'),
] ) | Tabular Playground Series - Jan 2021 |
14,579,645 | idxT = X_train.index[:3*len(X_train)//4]
idxV = X_train.index[3*len(X_train)//4:]<drop_column> | parameters = [
{
'voting': [VotingRegressor([
('lgbm', LGBMRegressor(random_state=RANDOM_STATE)) ,
('xgb', XGBRegressor(random_state=RANDOM_STATE))
])],
'voting__lgbm__n_estimators': [2000],
'voting__lgbm__max_depth': [12],
'voting__lgbm__learning_rate': [0.01],
'voting__lgbm__num_leaves': [256],
'voting__lgbm__min_child_weight': [12],
'voting__lgbm__feature_fraction': [0.4],
'voting__lgbm__bagging_fraction': [0.7],
'voting__lgbm__bagging_freq': [5],
'voting__lgbm__min_child_samples': [32],
'voting__lgbm__lambda_l1':[9],
'voting__lgbm__lambda_l2': [0.13],
'voting__xgb__n_estimators': [2000],
'voting__xgb__max_depth': [12],
'voting__xgb__learning_rate': [0.01],
'voting__xgb__alpha': [5],
'voting__xgb__gamma': [3],
'voting__xgb__lambda': [3],
'voting__xgb__subsample': [0.8],
'voting__xgb__colsample_bytree': [0.4],
}
] | Tabular Playground Series - Jan 2021 |
14,579,645 | X_train = X_train.drop(columns=['uid'] )<define_variables> | total = CROSS_VALIDATION * len(ParameterGrid(parameters))
display(f"Number of combination that will be run by the GridSearch: {total}" ) | Tabular Playground Series - Jan 2021 |
14,579,645 | idxT = X_train.index[:3*len(X_train)//4]
idxV = X_train.index[3*len(X_train)//4:]<train_on_grid> | custom_scoring = make_scorer(
score_func=lambda y, y_pred: mean_squared_error(y, y_pred, squared=False),
greater_is_better=False,
) | Tabular Playground Series - Jan 2021 |
14,579,645 | oof = np.zeros(len(X_train))
preds = np.zeros(len(X_test))
skf = GroupKFold(n_splits=6)
for i,(idxT, idxV)in enumerate(skf.split(X_train, y_train, groups=X_train['DT_M'])) :
month = X_train.iloc[idxV]['DT_M'].iloc[0]
print('Fold',i,'withholding month',month)
print(' rows of train =',len(idxT),'rows of holdout =',len(idxV))
clfz = xgb.XGBClassifier(
n_estimators=5000,
max_depth=12,
learning_rate=0.02,
subsample=0.8,
colsample_bytree=0.4,
missing=-1,
eval_metric='auc',
tree_method='hist'
)
hz = clfz.fit(X_train[cols].iloc[idxT], y_train.iloc[idxT],
eval_set=[(X_train[cols].iloc[idxV],y_train.iloc[idxV])],
verbose=100, early_stopping_rounds=200)
oof[idxV] += clfz.predict_proba(X_train[cols].iloc[idxV])[:,1]
preds += clfz.predict_proba(X_test[cols])[:,1]/skf.n_splits
print('
print('XGB96 OOF CV=',roc_auc_score(y_train,oof))<load_from_csv> | grid_search = GridSearchCV(
pipeline,
param_grid=parameters,
cv=CROSS_VALIDATION,
scoring=custom_scoring,
n_jobs=-1,
verbose=True,
) | Tabular Playground Series - Jan 2021 |
14,579,645 | test_transaction = pd.read_csv('/kaggle/input/ieee-fraud-detection/test_transaction.csv')
final_col = test_transaction['TransactionID']<save_to_csv> | grid_search.fit(X_train, y_train ) | Tabular Playground Series - Jan 2021 |
14,579,645 | my_submission = pd.DataFrame({'TransactionID':final_col, 'isFraud': preds})
my_submission.to_csv('./submission.csv', index=False)
my_submission.head(5 )<import_modules> | display(abs(grid_search.best_score_))
display(grid_search.best_params_ ) | Tabular Playground Series - Jan 2021 |
14,579,645 | print(tf.__version__ )<feature_engineering> | preds = grid_search.best_estimator_.predict(X_valid)
mean_squared_error(y_valid, preds, squared=False ) | Tabular Playground Series - Jan 2021 |
14,579,645 | TRAIN_PREFIX = '.. /input/fish-data/fish/train'
def load_annotations() :
boxes = dict()
for path in tqdm(glob('.. /input/fish-data/fish/boxes/*.json')) :
label = os.path.basename(path ).split('_', 1)[0]
with open(path)as src:
for annotation in json.load(src):
basename = os.path.basename(annotation['filename'])
annotation['filename'] = os.path.join(
TRAIN_PREFIX, label.upper() , basename)
for rect in annotation['annotations']:
rect['x'] += rect['width'] / 2
rect['y'] += rect['height'] / 2
rect['class'] = label
if os.path.isfile(annotation['filename']):
boxes.setdefault(label, [] ).append(annotation)
return boxes
def draw_boxes(annotation, rectangles=None, image_size=None):
def _draw(img, rectangles, scale_x, scale_y, color=(0, 255, 0)) :
for i, rect in enumerate(rectangles):
pt1 =(int(( rect['x'] - rect['width'] / 2)* scale_x),
int(( rect['y'] - rect['height'] / 2)* scale_y))
pt2 =(int(( rect['x'] + rect['width'] / 2)* scale_x),
int(( rect['y'] + rect['height'] / 2)* scale_y))
img = cv2.rectangle(img.copy() , pt1, pt2,
color=color, thickness=10)
img = cv2.putText(img.copy() , annotation['annotations'][i]['class'], tuple(np.array(pt1)+[0,-7]), cv2.FONT_HERSHEY_SIMPLEX, 1, color, 4)
return img
def __draw(img, rectangles, scale_x, scale_y, color=(0, 255, 0)) :
for i, rect in enumerate(rectangles):
pt1 =(int(( rect['x'] - rect['width'] / 2)* scale_x),
int(( rect['y'] - rect['height'] / 2)* scale_y))
pt2 =(int(( rect['x'] + rect['width'] / 2)* scale_x),
int(( rect['y'] + rect['height'] / 2)* scale_y))
img = cv2.rectangle(img.copy() , pt1, pt2,
color=color, thickness=3)
img = cv2.putText(img.copy() , counts['class'][int(rect['label'])] + ': ' + str(rect['label']), tuple(np.array(pt1)+[0,-7]), cv2.FONT_HERSHEY_SIMPLEX, 1, color, 4)
return img
scale_x, scale_y = 1., 1.
img = cv2.imread(annotation['filename'], cv2.IMREAD_COLOR)[...,::-1]
if image_size is not None:
scale_x = 1.* image_size[0] / img.shape[1]
scale_y = 1.* image_size[1] / img.shape[0]
img = cv2.resize(img, image_size)
img = _draw(img, annotation.get('annotations', []), scale_x, scale_y)
if rectangles is not None:
img = __draw(img, rectangles, 1., 1.,(255, 0, 0))
return img<define_variables> | X_test = pd.read_csv(f"{data_dir}/test.csv" ).set_index('id' ).convert_dtypes()
display(X_test.shape)
X_test.head(2 ) | Tabular Playground Series - Jan 2021 |
14,579,645 | <create_dataframe><EOS> | preds_test = grid_search.best_estimator_.predict(X_test)
output = pd.DataFrame(
{'Id': X_test.index, 'target': preds_test})
output.to_csv(f"submission.csv", index=False ) | Tabular Playground Series - Jan 2021 |
14,044,928 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<init_hyperparams> | !pip install pytorch_tabular
!pip install torch_optimizer | Tabular Playground Series - Jan 2021 |
14,044,928 | IMG_HEIGHT = 736
IMG_WIDTH = 1184
features = VGG16(weights='imagenet',
include_top=False,
input_shape=(IMG_HEIGHT, IMG_WIDTH, 3))
for layer in features.layers[:-5]:
layer.trainable = False
feature_tensor = features.layers[-1].output
print(feature_tensor.shape )<define_variables> | import numpy as np
import pandas as pd
import time
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import StandardScaler
from pytorch_tabular import TabularModel
from pytorch_tabular.models import CategoryEmbeddingModelConfig, NodeConfig, TabNetModelConfig
from pytorch_tabular.config import DataConfig, OptimizerConfig, TrainerConfig, ExperimentConfig
from pytorch_tabular.categorical_encoders import CategoricalEmbeddingTransformer
from torch_optimizer import QHAdam
import category_encoders as ce
from lightgbm import LGBMRegressor
from catboost import CatBoostRegressor | Tabular Playground Series - Jan 2021 |
14,044,928 | FEATURE_SHAPE =(feature_tensor.shape[1],
feature_tensor.shape[2])
print(FEATURE_SHAPE)
GRID_STEP_H = IMG_HEIGHT / FEATURE_SHAPE[0]
GRID_STEP_W = IMG_WIDTH / FEATURE_SHAPE[1]
ANCHOR_WIDTH = 150.
ANCHOR_HEIGHT = 150.
ANCHOR_CENTERS = np.mgrid[GRID_STEP_H/2:IMG_HEIGHT:GRID_STEP_H,
GRID_STEP_W/2:IMG_WIDTH:GRID_STEP_W]
ANCHOR_CENTERS.shape<define_variables> | df_train = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv')
display(df_train.head())
df_test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
display(df_test.head())
features = ['cont1', 'cont2', 'cont3', 'cont4', 'cont5',
'cont6', 'cont7', 'cont8', 'cont9', 'cont10',
'cont11', 'cont12', 'cont13', 'cont14'] | Tabular Playground Series - Jan 2021 |
14,044,928 | num_classes = counts.shape[0]
num_classes<import_modules> | enc = KBinsDiscretizer(n_bins=10, encode='ordinal', strategy="quantile")
enc.fit(df_train[features])
binned_df_train = enc.transform(df_train[features])
binned_df_test = enc.transform(df_test[features])
for i, feature in enumerate(features):
df_train[f"{feature}_binned"] = binned_df_train[:,i]
df_test[f"{feature}_binned"] = binned_df_test[:,i] | Tabular Playground Series - Jan 2021 |
14,044,928 | from scipy.special import softmax<normalization> | def get_configs(train):
epochs = 25
batch_size = 512
steps_per_epoch = int(( len(train)//batch_size)*0.9)
data_config = DataConfig(
target=['target'],
continuous_cols=['cont1', 'cont2', 'cont3', 'cont4', 'cont5', 'cont6', 'cont7',
'cont8', 'cont9', 'cont10', 'cont11', 'cont12', 'cont13', 'cont14'],
categorical_cols=['cont1_binned', 'cont2_binned', 'cont3_binned',
'cont4_binned', 'cont5_binned', 'cont6_binned', 'cont7_binned',
'cont8_binned', 'cont9_binned', 'cont10_binned', 'cont11_binned',
'cont12_binned', 'cont13_binned', 'cont14_binned'],
continuous_feature_transform="quantile_normal"
)
trainer_config = TrainerConfig(
auto_lr_find=False,
batch_size=batch_size,
max_epochs=epochs,
gpus=1,
)
optimizer_config = OptimizerConfig(lr_scheduler="OneCycleLR", lr_scheduler_params={"max_lr":0.005, "epochs": epochs, "steps_per_epoch":steps_per_epoch})
model_config = NodeConfig(
task="regression",
num_layers=2,
num_trees=1024,
depth=6,
embed_categorical=True,
learning_rate = 1e-3,
target_range=[(df_train[col].min() ,df_train[col].max())for col in ['target']]
)
return data_config, trainer_config, optimizer_config, model_config | Tabular Playground Series - Jan 2021 |
14,044,928 | def iou(rect, x_scale, y_scale, anchor_x, anchor_y,
anchor_w=ANCHOR_WIDTH, anchor_h=ANCHOR_HEIGHT):
rect_x1 =(rect['x'] - rect['width'] / 2)* x_scale
rect_x2 =(rect['x'] + rect['width'] / 2)* x_scale
rect_y1 =(rect['y'] - rect['height'] / 2)* y_scale
rect_y2 =(rect['y'] + rect['height'] / 2)* y_scale
anch_x1, anch_x2 = anchor_x - anchor_w / 2, anchor_x + anchor_w / 2
anch_y1, anch_y2 = anchor_y - anchor_h / 2, anchor_y + anchor_h / 2
dx =(min(rect_x2, anch_x2)- max(rect_x1, anch_x1))
dy =(min(rect_y2, anch_y2)- max(rect_y1, anch_y1))
intersection = dx * dy if(dx > 0 and dy > 0)else 0.
anch_square =(anch_x2 - anch_x1)*(anch_y2 - anch_y1)
rect_square =(rect_x2 - rect_x1)*(rect_y2 - rect_y1)
union = anch_square + rect_square - intersection
return intersection / union
def encode_anchors(annotation, img_shape, iou_thr=0.5):
encoded = np.zeros(shape=(FEATURE_SHAPE[0],
FEATURE_SHAPE[1], 11), dtype=np.float32)
x_scale = 1.* IMG_WIDTH / img_shape[1]
y_scale = 1.* IMG_HEIGHT / img_shape[0]
for rect in annotation['annotations']:
scores = []
label = fish_classes == rect['class']
for row in range(FEATURE_SHAPE[0]):
for col in range(FEATURE_SHAPE[1]):
anchor_x = ANCHOR_CENTERS[1, row, col]
anchor_y = ANCHOR_CENTERS[0, row, col]
score = iou(rect, x_scale, y_scale, anchor_x, anchor_y)
scores.append(( score, anchor_x, anchor_y, row, col))
scores = sorted(scores, reverse=True)
if scores[0][0] < iou_thr:
scores = [scores[0]]
else:
scores = [e for e in scores if e[0] > iou_thr]
for score, anchor_x, anchor_y, row, col in scores:
dx =(anchor_x - rect['x'] * x_scale)/ ANCHOR_WIDTH
dy =(anchor_y - rect['y'] * y_scale)/ ANCHOR_HEIGHT
dw =(ANCHOR_WIDTH - rect['width'] * x_scale)/ ANCHOR_WIDTH
dh =(ANCHOR_HEIGHT - rect['height'] * y_scale)/ ANCHOR_HEIGHT
encoded[row, col] = np.array([*label, 1., dx, dy, dw, dh])
return encoded
def _sigmoid(x):
return 1./(1.+ np.exp(-x))
def decode_prediction(prediction, conf_thr=0.1):
rectangles = []
for row in range(FEATURE_SHAPE[0]):
for col in range(FEATURE_SHAPE[1]):
label = np.empty(6)
label[0], label[1], label[2], label[3], label[4], label[5], conf, dx, dy, dw, dh = prediction[row, col]
conf = _sigmoid(conf)
label = softmax(label)
if conf > conf_thr:
anchor_x = ANCHOR_CENTERS[1, row, col]
anchor_y = ANCHOR_CENTERS[0, row, col]
rectangles.append({'x': anchor_x - dx * ANCHOR_WIDTH,
'y': anchor_y - dy * ANCHOR_HEIGHT,
'width': ANCHOR_WIDTH - dw * ANCHOR_WIDTH,
'height': ANCHOR_HEIGHT - dh * ANCHOR_HEIGHT,
'conf': conf,
'label': np.argmax(_sigmoid(label)) ,
'labels': label })
return rectangles
def non_max_suppression(rectangles, max_output_size, iou_threshold=0.5):
if not rectangles:
return rectangles
boxes = [[r['y'],
r['x'],
r['y'] + r['height'],
r['x'] + r['width']] for r in rectangles]
scores = [r['conf'] for r in rectangles]
indices = tf.image.non_max_suppression(np.array(boxes),
np.array(scores),
max_output_size,
iou_threshold)
return [rectangles[i] for i in indices]<categorify> | rnd_seed_cv = 1234
rnd_seed_reg = 1234
kf = KFold(n_splits=5, random_state=rnd_seed_cv, shuffle=True)
df_train.drop(columns='id', inplace=True)
df_test.drop(columns='id', inplace=True)
df_test['target'] = 0 | Tabular Playground Series - Jan 2021 |
14,044,928 | annotation = boxes['shark'][3]
encoded = encode_anchors(annotation,
img_shape=(IMG_HEIGHT, IMG_WIDTH),
iou_thr=0.1)
decoded = decode_prediction(encoded, conf_thr=0.7)
decoded = sorted(decoded, key = lambda e: -e['conf'])
plt.figure(figsize=(6, 6), dpi=240)
plt.imshow(draw_boxes(annotation, decoded))
plt.title('{} {}x{}'.format(
annotation['filename'], img.shape[0], img.shape[1])) ;<compute_train_metric> | def node(train, valid, df_test):
data_config, trainer_config, optimizer_config, model_config = get_configs(train)
tabular_model = TabularModel(
data_config=data_config,
model_config=model_config,
optimizer_config=optimizer_config,
trainer_config=trainer_config
)
tabular_model.fit(train=train, validation=valid, optimizer=QHAdam,
optimizer_params={"nus":(0.7, 1.0), "betas":(0.95, 0.998)})
result = tabular_model.evaluate(valid)
return np.sqrt(result[0]["test_mean_squared_error"]), tabular_model.predict(valid)["target_prediction"].values, tabular_model.predict(df_test)["target_prediction"].values, tabular_model
def lgbm(train, valid, df_test):
lgb_model = LGBMRegressor(n_estimators=10000,
learning_rate=0.005,
early_stopping_rounds=50,
feature_pre_filter = False,
num_leaves=102,
min_child_samples=20,
colsample_bytree = 0.4,
subsample = 1,
subsample_freq = 0,
lambda_l1 = 4.6,
lambda_l2 = 1.9,
random_state=42)
lgb_model.fit(train.drop(columns='target'), train['target'], eval_set=(valid.drop(columns='target'),valid.loc[:,'target']))
lgb_preds = lgb_model.predict(valid.drop(columns='target'))
score = mean_squared_error(valid['target'].values, lgb_preds, squared=False)
return score, lgb_model.predict(valid.drop(columns='target')) , lgb_model.predict(df_test.drop(columns='target'))
def cb(train, valid, df_test):
best_params = {
'grow_policy': 'Lossguide',
'boosting_type': 'Plain',
'depth': 20,
'l2_leaf_reg': 3.699746597668451,
'min_data_in_leaf': 4,
'random_strength': 4.9263987954247455,
'rsm': 1.0,
"n_estimators": 10000,
"learning_rate": 0.5,
"od_type": "Iter",
"od_wait": 50,
}
catboost_model = CatBoostRegressor(**best_params)
catboost_model.fit(train.drop(columns='target'), train['target'], eval_set=(valid.drop(columns='target'),valid.loc[:,'target']))
cb_preds = catboost_model.predict(valid.drop(columns='target'))
score = mean_squared_error(valid['target'].values, cb_preds, squared=False)
return score, catboost_model.predict(valid.drop(columns='target')) , catboost_model.predict(df_test.drop(columns='target')) | Tabular Playground Series - Jan 2021 |
14,044,928 | K = tf.keras.backend
def confidence_loss(y_true, y_pred):
conf_loss = K.binary_crossentropy(y_true[..., 6],
y_pred[..., 6],
from_logits=True)
return conf_loss
def smooth_l1(y_true, y_pred):
abs_loss = K.abs(y_true[..., -4:] - y_pred[..., -4:])
square_loss = 0.5 * K.square(y_true[..., -4:] - y_pred[..., -4:])
mask = K.cast(K.greater(abs_loss, 1.) , 'float32')
total_loss =(abs_loss - 0.5)* mask + 0.5 * square_loss *(1.- mask)
return K.sum(total_loss, axis=-1)
def classification_loss(y_tr, y_pr, alpha=0.25, gamma=2.0):
y_true = y_tr[..., :6]
y_pred = y_pr[..., :6]
cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(
labels=y_true, logits=y_pred
)
probs = tf.nn.softmax(y_pred)
alpha = tf.where(tf.equal(y_true, 1.0), alpha,(1.0 - alpha))
pt = tf.where(tf.equal(y_true, 1.0), probs, 1 - probs)
loss = alpha * tf.pow(1.0 - pt, gamma)* cross_entropy
return tf.reduce_sum(loss, axis=-1)
def class_loss(y_tr, y_pr):
y_true = y_tr[..., :6]
y_pred = y_pr[..., :6]
cross_entropy = K.categorical_crossentropy(y_true[..., :6],
y_pred[..., :6],
from_logits=True)
return cross_entropy
def total_loss(y_true, y_pred, neg_pos_ratio=3):
batch_size = K.shape(y_true)[0]
y_true = K.reshape(y_true,(batch_size, -1, 11))
y_pred = K.reshape(y_pred,(batch_size, -1, 11))
cls_loss = classification_loss(y_true, y_pred)
conf_loss = confidence_loss(y_true, y_pred)
loc_loss = smooth_l1(y_true, y_pred)
pos_conf_loss = K.sum(conf_loss * y_true[..., 6], axis=-1)
pos_class_loss = K.sum(cls_loss * y_true[..., 6], axis=-1)
pos_loc_loss = K.sum(loc_loss * y_true[..., 6], axis=-1)
anchors = K.shape(y_true)[1]
num_pos = K.sum(y_true[..., 6], axis=-1)
num_pos_avg = K.mean(num_pos)
num_neg = K.min([neg_pos_ratio *(num_pos_avg)+ 1., K.cast(anchors, 'float32')])
neg_conf_loss, _ = tf.nn.top_k(conf_loss *(1.- y_true[..., 6]),
k=K.cast(num_neg, 'int32'))
neg_conf_loss = K.sum(neg_conf_loss, axis=-1)
total_conf_loss =(neg_conf_loss + pos_conf_loss)/(num_neg + num_pos + 1e-32)
cls_loss = pos_class_loss /(num_pos + 1e-32)
loc_loss = pos_loc_loss /(num_pos + 1e-32)
return total_conf_loss + 0.5 * loc_loss + cls_loss
<prepare_x_and_y> | CV_node = []
CV_lgb = []
CV_cb = []
preds_train_node = []
preds_train_lgb = []
preds_train_cb = []
preds_test_node = []
preds_test_lgb = []
preds_test_cb = []
cross_validated_preds = []
t1 = time.time()
for train_index, test_index in kf.split(df_train):
train = df_train.iloc[train_index]
valid = df_train.iloc[test_index]
cv_val = valid.copy()
node_score, node_train_pred, node_test_pred, tabular_model = node(train, valid, df_test)
CV_node.append(node_score)
cv_val['pred_node'] = node_train_pred
preds_train_node.append(node_train_pred)
preds_test_node.append(node_test_pred)
transformer = CategoricalEmbeddingTransformer(tabular_model)
train_transform = transformer.fit_transform(train)
val_transform = transformer.transform(valid)
df_test_transform = transformer.transform(df_test)
lgbm_score, lgbm_train_pred, lgbm_test_pred = lgbm(train_transform, val_transform, df_test_transform)
CV_lgb.append(lgbm_score)
cv_val['pred_lgb'] = lgbm_train_pred
preds_train_lgb.append(lgbm_train_pred)
preds_test_lgb.append(lgbm_test_pred)
cb_score, cb_train_pred, cb_test_pred = cb(train_transform, val_transform, df_test_transform)
CV_cb.append(cb_score)
cv_val['pred_cb'] = cb_train_pred
preds_train_cb.append(cb_train_pred)
preds_test_cb.append(cb_test_pred)
cross_validated_preds.append(cv_val)
t2 = time.time()
print('Elapsed time [s]: ', t2-t1 ) | Tabular Playground Series - Jan 2021 |
14,044,928 | def load_img(path, target_size=(IMG_WIDTH, IMG_HEIGHT)) :
img = cv2.imread(path, cv2.IMREAD_COLOR)[...,::-1]
img_shape = img.shape
img_resized = cv2.resize(img, target_size)
return img_shape, tf.keras.applications.resnet_v2.preprocess_input(img_resized.astype(np.float32))
def data_generator(boxes, batch_size=32):
boxes = sum(boxes.values() , [])
while True:
shuffle(boxes)
for i in range(len(boxes)//batch_size):
X, y = [], []
for j in range(i*batch_size,(i+1)*batch_size):
img_shape, img = load_img(boxes[j]['filename'])
y_ = encode_anchors(boxes[j], img_shape)
y.append(y_)
X.append(img)
yield np.array(X), np.array(y )<choose_model_class> | print('CV performance [RMSE]: ', np.mean(CV_node, axis=0))
print('CV performance [RMSE]: ', np.mean(CV_lgb, axis=0))
print('CV performance [RMSE]: ', np.mean(CV_cb, axis=0)) | Tabular Playground Series - Jan 2021 |
14,044,928 | output = tf.keras.layers.BatchNormalization()(feature_tensor)
output = tf.keras.layers.Conv2D(11,
kernel_size=(1, 1),
activation='linear',
kernel_regularizer='l2' )(output)
model = tf.keras.models.Model(inputs=features.inputs, outputs=output)
<define_search_space> | cross_val_pred_df = pd.concat(cross_validated_preds, sort=False)
cross_val_pred_df.to_csv("cross_val_preds.csv")
joblib.dump(preds_test_node, "preds_test_node.sav")
joblib.dump(preds_test_lgb, "preds_test_lgb.sav")
joblib.dump(preds_test_cb, "preds_test_cb.sav" ) | Tabular Playground Series - Jan 2021 |
14,044,928 | lr=3e-3<choose_model_class> | avg_cb_pred = np.mean(preds_test_cb, axis=0)
avg_lgb_pred = np.mean(preds_test_lgb, axis=0)
avg_node_pred = np.mean(preds_test_node, axis=0)
pred_test = np.average([avg_node_pred, avg_lgb_pred, avg_cb_pred], axis=0, weights=[-0.15447081, 1.1021915 , 0.06145868] ) | Tabular Playground Series - Jan 2021 |
14,044,928 | def lr_exp_decay(epoch, lr):
k = 0.5
return lr * np.exp(-k*epoch)
batch_size = 32
steps_per_epoch = sum(map(len, boxes.values()), 0)/ batch_size
gen = data_generator(boxes, batch_size=batch_size)
checkpoint = tf.keras.callbacks.ModelCheckpoint(
'fishdetector.hdf5',
monitor='loss',
verbose=47,
save_best_only=True,
save_weights_only=False,
mode='auto',
save_freq=10)
adam = tf.keras.optimizers.Adam(lr=lr, beta_1=0.9, beta_2=0.999)
model.compile(optimizer=adam,
loss=total_loss,
metrics=[confidence_loss, classification_loss, smooth_l1])
<train_model> | df_sub = pd.read_csv('.. /input/tabular-playground-series-jan-2021/sample_submission.csv')
df_sub.target = pred_test
df_sub.head() | Tabular Playground Series - Jan 2021 |
14,044,928 | model.fit(gen,
steps_per_epoch=steps_per_epoch,
epochs=2,
callbacks=[checkpoint, tf.keras.callbacks.LearningRateScheduler(lr_exp_decay, verbose=1)] )<predict_on_test> | df_sub.to_csv('submission.csv', index=False ) | Tabular Playground Series - Jan 2021 |
14,038,334 | test_images = glob('.. /input/fish-data/test_stg1/test_stg1/*.jpg')[:4]
plt.figure(figsize=(6, 4 * len(test_images)) , dpi=240)
for i, filename in enumerate(test_images):
_, sample_img = load_img(filename)
pred = model.predict(np.array([sample_img,]))
decoded = decode_prediction(pred[0], conf_thr=0.1)
decoded = non_max_suppression(decoded,
max_output_size=1,
iou_threshold=0.5)
plt.subplot(len(test_images), 1, i + 1)
img = draw_boxes({'filename': filename}, decoded,(IMG_WIDTH, IMG_HEIGHT))
plt.imshow(img)
plt.title('Предсказание на тесте {}'.format(filename.split('/')[-1])) ;<categorify> | train = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/train.csv', index_col='id')
test = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/test.csv', index_col='id' ) | Tabular Playground Series - Jan 2021 |
14,038,334 | def make_predictions() :
ptable = pd.DataFrame(columns=['image', 'ALB', 'BET', 'DOL', 'LAG', 'NoF', 'OTHER', 'SHARK','YFT'])
for i, file in enumerate(tqdm(glob('.. /input/fish-data/test_stg1/test_stg1/*.jpg'))):
bn = os.path.basename(file)
_, sample_img = load_img(file)
pred = model.predict(np.array([sample_img,])) [0]
decoded = decode_prediction(pred, conf_thr=0.015)
decoded = non_max_suppression(decoded,
max_output_size=1,
iou_threshold=0.5)
decoded = decoded[0]['labels']
ptable.loc[i, 'image'] = bn
ptable.loc[i, 'ALB'] = decoded[5]
ptable.loc[i, 'BET'] = decoded[1]
ptable.loc[i, 'DOL'] = decoded[4]
ptable.loc[i, 'LAG'] = decoded[3]
ptable.loc[i, 'SHARK'] = decoded[0]
ptable.loc[i, 'YFT'] = decoded[2]
ptable.loc[i, 'NoF'] = 0.123081
ptable.loc[i, 'OTHER'] = 0.079142
i += 1
for j, file in enumerate(tqdm(glob('.. /input/fish-data/test_stg2/test_stg2/*.jpg'))):
bn = os.path.basename(file)
bn = "test_stg2/" + bn
_, sample_img = load_img(file)
pred = model.predict(np.array([sample_img,])) [0]
decoded = decode_prediction(pred, conf_thr=0.015)
decoded = non_max_suppression(decoded,
max_output_size=1,
iou_threshold=0.5)
decoded = decoded[0]['labels']
ptable.loc[i + j, 'image'] = bn
ptable.loc[i + j, 'ALB'] = decoded[5]
ptable.loc[i + j, 'BET'] = decoded[1]
ptable.loc[i + j, 'DOL'] = decoded[4]
ptable.loc[i + j, 'LAG'] = decoded[3]
ptable.loc[i + j, 'SHARK'] = decoded[0]
ptable.loc[i + j, 'YFT'] = decoded[2]
ptable.loc[i + j, 'NoF'] = 0.123081
ptable.loc[i + j, 'OTHER'] = 0.079142
return ptable<save_to_csv> | import seaborn as sns | Tabular Playground Series - Jan 2021 |
14,038,334 | pred_table = make_predictions()
pred_table.to_csv("neto_submit.csv", index=False)
print(os.listdir("./"))<import_modules> | train[train['target'] <= 4.5] | Tabular Playground Series - Jan 2021 |
14,038,334 | import numpy as np
import pandas as pd
import six
import time
from random import randint
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from skimage.transform import resize
from keras import Model
from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
from keras.models import load_model
from keras.layers import Input,Dropout,BatchNormalization,Activation,Add
from keras.preprocessing.image import load_img
from keras.optimizers import Adam
from keras.utils.vis_utils import plot_model
from keras.preprocessing.image import ImageDataGenerator
from keras.layers import Input, Conv2D, Conv2DTranspose, MaxPooling2D, concatenate, Dropout,BatchNormalization
from keras.layers import Conv2D, Concatenate, MaxPooling2D
from keras.layers import UpSampling2D, Dropout, BatchNormalization
from tqdm.notebook import tqdm
from keras import initializers
from keras import regularizers
from keras import constraints
from keras.utils import conv_utils
from keras.utils.data_utils import get_file
from keras.engine.topology import get_source_inputs
from keras.engine import InputSpec
from keras import backend as K
from keras.regularizers import l2
from keras import optimizers
from keras.engine.topology import Input
from keras.engine.training import Model
from keras.layers.convolutional import Conv2D, UpSampling2D, Conv2DTranspose
from keras.layers.core import Activation, SpatialDropout2D
from keras.layers.merge import concatenate,add
from keras.layers.normalization import BatchNormalization
from keras.layers.pooling import MaxPooling2D
import tensorflow as tf
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.model_selection import KFold<load_from_disk> | train.drop([241352, 284103, 300936, 307139, 355831], axis = 0, inplace=True)
train[train['target'] <= 4.5] | Tabular Playground Series - Jan 2021 |
14,038,334 | ! unzip -q.. /input/tgs-salt-identification-challenge/train.zip -d train/
! unzip -q.. /input/tgs-salt-identification-challenge/test.zip -d test/<load_from_csv> | target = train['target']
train.drop('target', axis=1, inplace=True ) | Tabular Playground Series - Jan 2021 |
14,038,334 | train = pd.read_csv(".. /input/tgs-salt-identification-challenge/train.csv")
depths = pd.read_csv(".. /input/tgs-salt-identification-challenge/depths.csv")
sub = pd.read_csv(".. /input/tgs-salt-identification-challenge/sample_submission.csv")
image_path = "/kaggle/working/train/images/"
mask_path = "/kaggle/working/train/masks/"
image_test_path = "/kaggle/working/test/images/"
model_path = 'unet_model.model'
submission_file = 'submission.csv'
t_start = time.time()
img_size = 101
epochs = 50
batch_size = 64<merge> | X_train, X_valid, y_train, y_valid = train_test_split(train, target, test_size=0.15, random_state=0 ) | Tabular Playground Series - Jan 2021 |
14,038,334 | train = train[['id']].join(depths.set_index('id'), on='id')
test = sub[['id']].join(depths.set_index('id'), on='id' )<feature_engineering> | lgbm = LGBMRegressor(tree_method='gpu_hist',learning_rate=0.07, max_depth=15, random_state=0, n_estimators=2000, n_jobs=-1)
lgbm.fit(X_train, y_train, eval_set=[(X_valid, y_valid)])
lgbm.score(X_valid, y_valid ) | Tabular Playground Series - Jan 2021 |
14,038,334 | train["images"] = [np.array(load_img(image_path+"{}.png".format(idx), color_mode="grayscale"), dtype=np.uint8)/ 255 for idx in tqdm(train.id)]
train["masks"] = [np.array(load_img(mask_path+"{}.png".format(idx), color_mode="grayscale"), dtype=np.uint8)/ 255 for idx in tqdm(train.id)]<feature_engineering> | xgb = XGBRegressor(learning_rate=0.005, max_depth=8, n_estimators=6000, n_jobs=-1, tree_method='gpu_hist', random_state=3)
xgb.fit(X_train, y_train, eval_set=[(X_valid, y_valid)])
xgb.score(X_valid, y_valid ) | Tabular Playground Series - Jan 2021 |
14,038,334 | train["coverage"] = train.masks.map(np.sum)/ pow(img_size, 2 )<categorify> | ensemble = VotingRegressor(estimators=[("xgb", xgb),("lgbm", lgbm)], weights=[1.1,1])
ensemble.fit(X_train, y_train)
ensemble.score(X_valid, y_valid ) | Tabular Playground Series - Jan 2021 |
14,038,334 | def cov_to_class(val):
for i in range(0, 11):
if val * 10 <= i :
return i
train["coverage_class"] = train.coverage.map(cov_to_class )<split> | model = ensemble.fit(train, target)
model.score(train, target ) | Tabular Playground Series - Jan 2021 |
14,038,334 | ids_train, ids_valid, x_train, x_valid, y_train, y_valid, cover_train, cover_test, depth_train, depth_test = train_test_split(
train.id.values,
np.array(train.images.tolist() ).reshape(-1,img_size, img_size, 1),
np.array(train.masks.tolist() ).reshape(-1, img_size, img_size, 1),
train.coverage.values,
train.z.values,
test_size = 0.1 , stratify=train.coverage_class, random_state=42 )<concatenate> | pred = model.predict(test)
pred | Tabular Playground Series - Jan 2021 |
14,038,334 | x_train = np.append(x_train, [np.fliplr(x)for x in x_train], axis=0)
y_train = np.append(y_train, [np.fliplr(x)for x in y_train], axis=0 )<define_search_model> | id = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/test.csv')['id'] | Tabular Playground Series - Jan 2021 |
14,038,334 | <choose_model_class><EOS> | output = pd.DataFrame({'id': id, 'target': pred})
output.to_csv("submission.csv", index=False)
print("saved" ) | Tabular Playground Series - Jan 2021 |
14,481,856 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<choose_model_class> | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))
input_path = Path('/kaggle/input/tabular-playground-series-jan-2021/' ) | Tabular Playground Series - Jan 2021 |
14,481,856 | def _bn_relu(input):
norm = BatchNormalization(axis=CHANNEL_AXIS )(input)
return Activation("relu" )(norm)
def _conv_bn_relu(**conv_params):
filters = conv_params["filters"]
kernel_size = conv_params["kernel_size"]
strides = conv_params.setdefault("strides",(1, 1))
kernel_initializer = conv_params.setdefault("kernel_initializer", "he_normal")
padding = conv_params.setdefault("padding", "same")
kernel_regularizer = conv_params.setdefault("kernel_regularizer", l2(1.e-4))
def f(input):
conv = Conv2D(filters=filters, kernel_size=kernel_size,
strides=strides, padding=padding,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer )(input)
return _bn_relu(conv)
return f
def _bn_relu_conv(**conv_params):
filters = conv_params["filters"]
kernel_size = conv_params["kernel_size"]
strides = conv_params.setdefault("strides",(1, 1))
kernel_initializer = conv_params.setdefault("kernel_initializer", "he_normal")
padding = conv_params.setdefault("padding", "same")
kernel_regularizer = conv_params.setdefault("kernel_regularizer", l2(1.e-4))
def f(input):
activation = _bn_relu(input)
return Conv2D(filters=filters, kernel_size=kernel_size,
strides=strides, padding=padding,
kernel_initializer=kernel_initializer,
kernel_regularizer=kernel_regularizer )(activation)
return f
def _shortcut(input, residual):
input_shape = K.int_shape(input)
residual_shape = K.int_shape(residual)
stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))
stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))
equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]
shortcut = input
if stride_width > 1 or stride_height > 1 or not equal_channels:
shortcut = Conv2D(filters=residual_shape[CHANNEL_AXIS],
kernel_size=(1, 1),
strides=(stride_width, stride_height),
padding="valid",
kernel_initializer="he_normal",
kernel_regularizer=l2(0.0001))(input)
return add([shortcut, residual])
def basic_block(filters, init_strides=(1, 1), is_first_block_of_first_layer=False):
def f(input):
if is_first_block_of_first_layer:
conv1 = Conv2D(filters=filters, kernel_size=(3, 3),
strides=init_strides,
padding="same",
kernel_initializer="he_normal",
kernel_regularizer=l2(1e-4))(input)
else:
conv1 = _bn_relu_conv(filters=filters, kernel_size=(3, 3),
strides=init_strides )(input)
residual = _bn_relu_conv(filters=filters, kernel_size=(3, 3))(conv1)
return _shortcut(input, residual)
return f
def _residual_block(block_function, filters, repetitions, is_first_layer=False):
def f(input):
for i in range(repetitions):
init_strides =(1, 1)
if i == 0 and not is_first_layer:
init_strides =(2, 2)
input = block_function(filters=filters, init_strides=init_strides,
is_first_block_of_first_layer=(is_first_layer and i == 0))(input)
return input
return f
def _handle_dim_ordering() :
global ROW_AXIS
global COL_AXIS
global CHANNEL_AXIS
if K.image_data_format() == 'channels_last':
ROW_AXIS = 1
COL_AXIS = 2
CHANNEL_AXIS = 3
else:
CHANNEL_AXIS = 1
ROW_AXIS = 2
COL_AXIS = 3
def _get_block(identifier):
if isinstance(identifier, six.string_types):
res = globals().get(identifier)
if not res:
raise ValueError('Invalid {}'.format(identifier))
return res
return identifier
class ResnetBuilder(object):
@staticmethod
def build(input_shape, block_fn, repetitions,input_tensor):
_handle_dim_ordering()
if len(input_shape)!= 3:
raise Exception("Input shape should be a tuple(nb_channels, nb_rows, nb_cols)")
if K.image_data_format() == 'channels_last':
input_shape =(input_shape[1], input_shape[2], input_shape[0])
block_fn = _get_block(block_fn)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
conv1 = _conv_bn_relu(filters=64, kernel_size=(7, 7), strides=(2, 2))(img_input)
pool1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same" )(conv1)
block = pool1
filters = 64
for i, r in enumerate(repetitions):
block = _residual_block(block_fn, filters=filters, repetitions=r, is_first_layer=(i == 0))(block)
filters *= 2
block = _bn_relu(block)
model = Model(inputs=img_input, outputs=block)
return model
@staticmethod
def build_resnet_34(input_shape,input_tensor):
return ResnetBuilder.build(input_shape, basic_block, [3, 4, 6, 3],input_tensor )<compute_train_metric> | train = pd.read_csv(input_path / 'train.csv', index_col='id')
print(train.shape)
train.head() | Tabular Playground Series - Jan 2021 |
14,481,856 | def get_iou_vector(A, B):
batch_size = A.shape[0]
metric = []
for batch in range(batch_size):
t, p = A[batch], B[batch]
intersection = np.logical_and(t, p)
union = np.logical_or(t, p)
iou =(np.sum(intersection > 0)+ 1e-10)/(np.sum(union > 0)+ 1e-10)
thresholds = np.arange(0.5, 1, 0.05)
s = []
for thresh in thresholds:
s.append(iou > thresh)
metric.append(np.mean(s))
return np.mean(metric)
def my_iou_metric(label, pred):
return tf.py_function(get_iou_vector, [label, pred > 0.3], tf.float64)
def my_iou_metric_2(label, pred):
return tf.py_function(get_iou_vector, [label, pred > 0.1], tf.float64 )<choose_model_class> | test = pd.read_csv(input_path / 'test.csv', index_col='id')
print(test.shape)
test.head() | Tabular Playground Series - Jan 2021 |
14,481,856 | def UResNet34(input_shape=(128, 128, 1), classes=1, decoder_filters=16, decoder_block_type='upsampling',
encoder_weights="imagenet", input_tensor=None, activation='sigmoid', **kwargs):
backbone = ResnetBuilder.build_resnet_34(input_shape=input_shape,input_tensor=input_tensor)
input_layer = backbone.input
output_layer = build_model(input_layer, 16,0.5)
model = Model(input_layer, output_layer)
model.compile(loss="binary_crossentropy", optimizer='adam', metrics=[my_iou_metric])
return model<choose_model_class> | train.isnull().sum() | Tabular Playground Series - Jan 2021 |
14,481,856 | model1 = UResNet34(input_shape =(1,img_size,img_size))
model1.summary()<choose_model_class> | trainNorm = train.copy()
for feature_name in train.columns:
mean_value = train[feature_name].mean()
std_value = train[feature_name].std()
trainNorm[feature_name] =(train[feature_name] - mean_value)/ std_value
trainNorm.head() | Tabular Playground Series - Jan 2021 |
14,481,856 | early_stopping = EarlyStopping(monitor='my_iou_metric', mode = 'max',patience=10, verbose=1)
model_checkpoint = ModelCheckpoint(model_path,monitor='my_iou_metric',
mode = 'max', save_best_only=True, verbose=1)
reduce_lr = ReduceLROnPlateau(monitor='my_iou_metric', mode = 'max',factor=0.5, patience=5, min_lr=0.0001, verbose=1)
history = model1.fit(x_train, y_train,
validation_data=(x_valid, y_valid),
epochs=epochs,
batch_size=batch_size,
callbacks=[model_checkpoint,reduce_lr],
verbose=1 )<choose_model_class> | testNorm = test.copy()
for feature_name in test.columns:
mean_value = test[feature_name].mean()
std_value = test[feature_name].std()
testNorm[feature_name] =(test[feature_name] - mean_value)/ std_value
testNorm.head() | Tabular Playground Series - Jan 2021 |
14,481,856 | model1 = load_model(model_path,custom_objects={'my_iou_metric': my_iou_metric})
input_x = model1.layers[0].input
output_layer = model1.layers[-1].input
model = Model(input_x, output_layer)
model.compile(loss=lovasz_loss, optimizer='adam', metrics=[my_iou_metric_2])
model.summary()<choose_model_class> | X_train, X_test, y_train, y_test = train_test_split(trainNorm, target, test_size=0.2, random_state=7)
print('X_train: ', X_train.shape)
print('X_test: ', X_test.shape)
print('y_train: ', y_train.shape)
print('y_test: ', y_test.shape ) | Tabular Playground Series - Jan 2021 |
14,481,856 | early_stopping = EarlyStopping(monitor='val_my_iou_metric_2', mode = 'max',patience=20, verbose=1)
model_checkpoint = ModelCheckpoint(model_path,monitor='val_my_iou_metric_2',
mode = 'max', save_best_only=True, verbose=1)
reduce_lr = ReduceLROnPlateau(monitor='val_my_iou_metric_2', mode = 'max',factor=0.5, patience=5, min_lr=0.0001, verbose=1)
history = model.fit(x_train, y_train,
validation_data=(x_valid, y_valid),
epochs=epochs,
batch_size=batch_size,
callbacks=[model_checkpoint,reduce_lr,early_stopping],
verbose=1 )<predict_on_test> | def rmse_cv(model,X,y):
rmse = np.sqrt(-cross_val_score(model, X, y, scoring="neg_mean_squared_error", cv=5))
return rmse | Tabular Playground Series - Jan 2021 |
14,481,856 | def predict_result(model,x_test,img_size):
x_test_reflect = np.array([np.fliplr(x)for x in x_test])
preds_test = model.predict(x_test ).reshape(-1, img_size, img_size)
preds_test2_refect = model.predict(x_test_reflect ).reshape(-1, img_size, img_size)
preds_test += np.array([ np.fliplr(x)for x in preds_test2_refect])
return preds_test<predict_on_test> | models = [LinearRegression() , Ridge() , Lasso() , ElasticNet() , SGDRegressor() , BayesianRidge() ,
cb.CatBoostRegressor() , RandomForestRegressor() , ]
names = ["LR", "Ridge", "Lasso", "ElasticNet", "SGD","BayesianRidge", "catboost","RandomForestRegressor"] | Tabular Playground Series - Jan 2021 |
14,481,856 | model = load_model(model_path,custom_objects={'my_iou_metric_2': my_iou_metric_2, 'lovasz_loss': lovasz_loss})
preds_valid = predict_result(model,x_valid,img_size )<compute_train_metric> | %%time
ModScores = {}
for name, model in zip(names, models):
score = rmse_cv(model, X_train, y_train)
ModScores[name] = score.mean()
print("{}: {:.2f}".format(name,score.mean()))
print("_"*100)
for key, value in sorted(ModScores.items() , key = itemgetter(1), reverse = False):
print(key, round(value,3)) | Tabular Playground Series - Jan 2021 |
14,481,856 | thresholds_ori = np.linspace(0.3, 0.7, 31)
thresholds = np.log(thresholds_ori/(1-thresholds_ori))
ious = np.array([iou_metric_batch(y_valid, preds_valid > threshold)for threshold in tqdm(thresholds)])
print(ious )<categorify> | model = cb.CatBoostRegressor()
model.fit(X_train, y_train)
final_predictions = model.predict(X_test)
final_mse = mean_squared_error(y_test, final_predictions)
final_rmse = np.sqrt(final_mse)
print("RMSE on X_test ", round(final_rmse, 4)) | Tabular Playground Series - Jan 2021 |
14,481,856 | def rle_encode(im):
pixels = im.flatten(order = 'F')
pixels = np.concatenate([[0], pixels, [0]])
runs = np.where(pixels[1:] != pixels[:-1])[0] + 1
runs[1::2] -= runs[::2]
return ' '.join(str(x)for x in runs )<predict_on_test> | final_predictions = model.predict(testNorm)
final_predictions.shape
subm = pd.read_csv(input_path / 'sample_submission.csv')
print(subm.shape)
subm.head()
id_col=subm.id
subm=id_col.to_frame()
subm['target'] = final_predictions
subm.set_index('id',inplace=True)
subm.head()
subm.to_csv('CBSubmission.csv')
LoadSub = pd.read_csv('CBSubmission.csv')
LoadSub.set_index('id',inplace=True)
LoadSub.head() | Tabular Playground Series - Jan 2021 |
14,481,856 | preds_test = predict_result(model,x_test,img_size)
t1 = time.time()
pred_dict = {idx: rle_encode(np.round(preds_test[i])> threshold_best)for i, idx in enumerate(tqdm(test.id.values)) }
t2 = time.time()
print(f"Usedtime = {t2-t1} s" )<save_to_csv> | model = models.Sequential()
model.add(layers.Dense(512, activation='relu', input_shape=(X_train.shape[1],)))
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dropout(0.2))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(1))
model.summary()
model.compile(optimizer=optimizers.Adam() , loss='mse', metrics=['mae'])
print("model compiled" ) | Tabular Playground Series - Jan 2021 |
14,481,856 | submit = pd.DataFrame.from_dict(pred_dict,orient='index')
submit.index.names = ['id']
submit.columns = ['rle_mask']
submit.to_csv(submission_file )<load_from_csv> | history = model.fit(X_train, y_train,
validation_split=0.2,
verbose=1,
epochs=10 ) | Tabular Playground Series - Jan 2021 |
14,481,856 | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv' )<prepare_x_and_y> | final_predictions = model.predict(X_test)
final_mse = mean_squared_error(y_test, final_predictions)
final_rmse = np.sqrt(final_mse)
print("RMSE on X_test ", round(final_rmse, 4)) | Tabular Playground Series - Jan 2021 |
14,481,856 | x_train = train.drop('label', axis=1)/255.0
y_label = train['label'].values
x_test = test/255.0<define_variables> | final_predictions = model.predict(testNorm)
final_predictions.shape | Tabular Playground Series - Jan 2021 |
14,481,856 | datagen = ImageDataGenerator(
rotation_range=15,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
)<import_modules> | subm = pd.read_csv(input_path / 'sample_submission.csv')
print(subm.shape)
subm.head() | Tabular Playground Series - Jan 2021 |
14,481,856 | import tensorflow as tf<choose_model_class> | id_col=subm.id
subm=id_col.to_frame()
subm['target'] = final_predictions
subm.set_index('id',inplace=True)
subm.head() | Tabular Playground Series - Jan 2021 |
14,481,856 | class ResidualUnit(tf.keras.layers.Layer):
def __init__(self, filters, strides=1, activation='relu', **kwargs):
super().__init__(**kwargs)
self.activation = tf.keras.activations.get(activation)
self.main_layers = [
tf.keras.layers.Conv2D(filters, 3, strides=strides, padding='SAME', use_bias=False),
tf.keras.layers.BatchNormalization() ,
self.activation,
tf.keras.layers.Conv2D(filters, 3, strides=1, padding='SAME', use_bias=False),
tf.keras.layers.BatchNormalization() ,
self.activation,
tf.keras.layers.Conv2D(filters, 3, strides=1, padding='SAME', use_bias=False),
tf.keras.layers.BatchNormalization() ,
]
self.skip_layers = []
if strides > 1:
self.skip_layers = [
tf.keras.layers.Conv2D(filters, 1, strides=strides, padding='SAME', use_bias=False),
tf.keras.layers.BatchNormalization() ,
]
def call(self, inputs):
Z = inputs
for layer in self.main_layers:
Z=layer(Z)
skip_Z = inputs
for layer in self.skip_layers:
skip_Z = layer(skip_Z)
return self.activation(Z +skip_Z )<choose_model_class> | subm.to_csv('NNSubmission.csv' ) | Tabular Playground Series - Jan 2021 |
14,445,592 | model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Conv2D(64,(7,7), input_shape=(28, 28, 1), padding='SAME'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.MaxPooling2D(2, 2))
prev_filters = 64
for filters in [64]*2 + [128]*2 + [256]*2:
print(filters)
strides = 1 if filters == prev_filters else 2
model.add(ResidualUnit(filters, strides=strides))
prev_filters = filters
model.add(tf.keras.layers.GlobalAvgPool2D())
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dropout(0.5*0.5))
model.add(tf.keras.layers.Dense(int(filters/2), activation='relu'))
model.add(tf.keras.layers.Dense(10, activation='softmax'))<choose_model_class> | import plotly.express as px
import plotly.graph_objects as go
import plotly.figure_factory as ff
from plotly.subplots import make_subplots
import matplotlib.pyplot as plt
from pandas_profiling import ProfileReport
import seaborn as sns
from sklearn import metrics
from scipy import stats
from copy import deepcopy
from sklearn.ensemble import RandomForestRegressor
from xgboost import XGBRegressor
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
import optuna
from optuna import Trial, visualization
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score,confusion_matrix
from sklearn.metrics import accuracy_score, mean_squared_error | 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.