kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,445,592 | model.compile(loss='sparse_categorical_crossentropy',
optimizer='adam',
metrics=['acc'])
checkpoint = ModelCheckpoint(
filepath=f'resnet-{int(time.time())}.dhf5',
monitor='loss',
save_best_only=True
)
annealer = LearningRateScheduler(lambda x: 1e-3 * 0.8**x)
callbacks = [checkpoint, annealer]<train_model> | 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')
sub_df = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/sample_submission.csv')
train_df.head() | Tabular Playground Series - Jan 2021 |
14,445,592 | batch_size = 64
history = model.fit(datagen.flow(X_train, y_label, batch_size=batch_size),
epochs = 30,
verbose = 1, steps_per_epoch=X_train.shape[0] // batch_size
, callbacks=callbacks, )<compute_test_metric> | feature_cols = train_df.drop(['id', 'target'], axis=1 ).columns
x = train_df[feature_cols]
y = train_df['target']
print(x.shape, y.shape ) | Tabular Playground Series - Jan 2021 |
14,445,592 | model.evaluate(X_train, y_label )<predict_on_test> | train_indexs = train_df.index
test_indexs = test_df.index
df = pd.concat(objs=[train_df, test_df], axis=0 ).reset_index(drop=True)
df = df.drop('id', axis=1)
len(train_indexs), len(test_indexs ) | Tabular Playground Series - Jan 2021 |
14,445,592 | def predict_proba(X, model, num_samples):
preds = [model(X, training=True)for _ in range(num_samples)]
return np.stack(preds ).mean(axis=0)
def predict_class(X, model, num_samples):
proba_preds = predict_proba(X, model, num_samples)
return np.argmax(proba_preds, axis=1 )<predict_on_test> | def fix_skew(features):
numerical_columns = features.select_dtypes(include=['int64','float64'] ).columns
skewed_features = features[numerical_columns].apply(lambda x: stats.skew(x)).sort_values(ascending=False)
high_skew = skewed_features[abs(skewed_features)> 0.5]
skewed_features = high_skew.index
for column in skewed_features:
features[column] = boxcox1p(features[column], boxcox_normmax(features[column] + 1))
return features | Tabular Playground Series - Jan 2021 |
14,445,592 | y_pred = predict_class(X_test, model, 10 )<save_to_csv> | param_grid = {
'n_estimators': [5, 10, 15, 20],
'max_depth': [2, 5, 7, 9]
}
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)
clf = XGBRegressor(random_state = 42)
clf.fit(x_train, y_train ) | Tabular Playground Series - Jan 2021 |
14,445,592 | res = pd.DataFrame(y_pred, columns=['Label'])
res.index = res.index + 1
res.index.rename('ImageId', inplace=True)
res.to_csv('res.csv' )<choose_model_class> | predictions = clf.predict(x_test)
errors = abs(predictions - y_test)
print('Mean Absolute Error:', round(np.mean(errors), 2), 'degrees.')
| Tabular Playground Series - Jan 2021 |
14,445,592 | successive_outputs = [layer.output for layer in model.layers[0:]]
visualization_model = tf.keras.models.Model(inputs = model.input, outputs = successive_outputs)
img = random.choice(X_train)
plt.imshow(img, cmap=plt.cm.binary)
plt.show()<predict_on_test> | def objective(trial,data=x,target=y):
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.5,0.6,0.7,0.8,0.9,1.0]
),
'subsample': trial.suggest_categorical(
'subsample', [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': trial.suggest_categorical(
"n_estimators", [150, 200, 300, 3000]
),
'max_depth': trial.suggest_categorical(
'max_depth', [4,5,7,9,11,13,15,17]
),
'random_state': 42,
'min_child_weight': trial.suggest_int(
'min_child_weight', 1, 300
),
}
model = 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 |
14,445,592 | successive_feature_maps = visualization_model.predict(img)
layer_names = [layer.name for layer in model.layers]
for layer_name, feature_map in zip(layer_names, successive_feature_maps):
if len(feature_map.shape)== 4:
n_features = feature_map.shape[-1]
size = feature_map.shape[1]
pic_num_per_row = n_features // 8 + 1
display_grid_arr = []
display_grid = np.zeros(( size, size * pic_num_per_row))
for i in range(n_features):
if i>0 and(i % pic_num_per_row == 0 or i == n_features):
display_grid_arr.append(display_grid)
display_grid = np.zeros(( size, size * pic_num_per_row))
index = i % pic_num_per_row
x = feature_map[0, :, :, i]
x -= x.mean()
x /= x.std()
x *= 64
x += 128
x = np.clip(x, 0, 255 ).astype('uint8')
display_grid[:, index * size :(index + 1)* size] = x
row_num = len(display_grid_arr)
scale = 200./ n_features
fig, axes = plt.subplots(row_num, 1, figsize=(scale * pic_num_per_row, scale * row_num))
fig.suptitle(layer_name, fontsize=40)
for i in range(row_num):
axes[i].imshow(display_grid_arr[i], aspect='auto', cmap='viridis' )<predict_on_test> | study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=25)
print('Number of finished trials:', len(study.trials))
print('Best trial:', study.best_trial.params ) | Tabular Playground Series - Jan 2021 |
14,445,592 | y_pred = model.predict_classes(X_train )<import_modules> | study.best_params | Tabular Playground Series - Jan 2021 |
14,445,592 | from sklearn.model_selection import cross_val_score
from sklearn.model_selection import cross_val_predict
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score<compute_test_metric> | best_params = study.best_params
best_params['tree_method'] = 'gpu_hist'
best_params['random_state'] = 42
clf = XGBRegressor(**(best_params))
clf.fit(x, y ) | Tabular Playground Series - Jan 2021 |
14,445,592 | conf_max = confusion_matrix(y_label, y_pred)
conf_max<define_variables> | preds = pd.Series(clf.predict(test_df.drop('id', axis=1)) , name='target')
preds = pd.concat([test_df['id'], preds], axis=1 ) | Tabular Playground Series - Jan 2021 |
14,445,592 | <prepare_x_and_y><EOS> | preds.to_csv("submission.csv", index=False ) | Tabular Playground Series - Jan 2021 |
14,479,967 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<import_modules> | %matplotlib inline | Tabular Playground Series - Jan 2021 |
14,479,967 | import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.layers import Conv2D,MaxPooling2D,Flatten,Dense,Dropout
import matplotlib.pyplot as plt
import keras
from keras.utils.np_utils import to_categorical<load_from_csv> | !pip install --upgrade xgboost
xgb.__version__
| Tabular Playground Series - Jan 2021 |
14,479,967 | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
test1 = test.copy()<prepare_x_and_y> | shap.initjs() | Tabular Playground Series - Jan 2021 |
14,479,967 | x_train=train.drop(['label'],1)
y_train=train['label']
x_train=x_train.values.reshape(-1,28,28,1)
test=test.values.reshape(-1,28,28,1)
x_train=x_train/255
test=test/255
<choose_model_class> | 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 |
14,479,967 | model=models.Sequential([
Conv2D(32,(5,5), activation='relu' , input_shape=(28,28,1)) ,
MaxPooling2D(pool_size=(2,2)) ,
Conv2D(64,(5,5), activation ='relu'),
MaxPooling2D(pool_size=(2,2)) ,
Dropout(0.25),
Conv2D(64,(3,3), activation ='relu'),
MaxPooling2D(pool_size=(2,2)) ,
Dropout(0.25),
Flatten() ,
Dense(64, activation='relu'),
Dense(10, activation='softmax')
] )<train_model> | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape | Tabular Playground Series - Jan 2021 |
14,479,967 | model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
model.fit(x_train, y_train, epochs=60, batch_size=64 )<save_to_csv> | Best_trial= {'lambda': 0.0030282073258141168,
'alpha': 0.01563845128469084,
'colsample_bytree': 0.55,
'subsample': 0.7,
'learning_rate': 0.01,
'max_depth': 15,
'random_state': 2020,
'min_child_weight': 257,
'tree_method':'gpu_hist',
'predictor': 'gpu_predictor'} | Tabular Playground Series - Jan 2021 |
14,479,967 | y_test = model.predict(test)
y_test = np.argmax(y_test, axis = 1)
index_list = []
for i in list(test1.index):
index_list.append(i+1)
submission_df = pd.DataFrame({
"ImageId": index_list,
"Label": y_test
})
submission_df.to_csv("submission_cnn.csv", index = False )<import_modules> | test = xgb.DMatrix(test[columns] ) | Tabular Playground Series - Jan 2021 |
14,479,967 | import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
from keras.utils.np_utils import to_categorical<load_from_csv> | NUM_FOLDS = 8
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.DMatrix(train_df, label=train_target)
val_df = xgb.DMatrix(val_df, label=val_target)
model = xgb.train(Best_trial, train_df, 1500)
temp_oof = model.predict(val_df)
temp_test = model.predict(test)
train_oof[val_ind] = temp_oof
test_preds += temp_test/NUM_FOLDS
print(mean_squared_error(temp_oof, val_target, squared=False)) | Tabular Playground Series - Jan 2021 |
14,479,967 | train=pd.read_csv('.. /input/digit-recognizer/train.csv')
test=pd.read_csv('.. /input/digit-recognizer/test.csv' )<prepare_x_and_y> | mean_squared_error(train_oof, target, squared=False)
| Tabular Playground Series - Jan 2021 |
14,479,967 | x_train=train.drop(['label'],1)
y_train=train['label']<prepare_x_and_y> | np.save('train_oof', train_oof)
np.save('test_preds', test_preds ) | Tabular Playground Series - Jan 2021 |
14,479,967 | x_train=np.array(x_train)
test=np.array(test )<feature_engineering> | %%time
shap_preds = model.predict(test, pred_contribs=True ) | Tabular Playground Series - Jan 2021 |
14,479,967 | x_train=x_train/255
test=test/255<categorify> | test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
| Tabular Playground Series - Jan 2021 |
14,479,967 | target=x_train.reshape(-1,28,28,1)
test=test.reshape(-1,28,28,1)
y_train=np.array(y_train)
label=to_categorical(y_train)
label.shape<import_modules> | test = xgb.DMatrix(test[columns] ) | Tabular Playground Series - Jan 2021 |
14,479,967 | from keras.models import Sequential
from keras.layers import Conv2D,MaxPooling2D,Flatten,Dense,Dropout<choose_model_class> | %%time
shap_interactions = model.predict(test, pred_interactions=True ) | Tabular Playground Series - Jan 2021 |
14,479,967 | model=Sequential([
Conv2D(32,(5,5), activation='relu' , input_shape=(28,28,1)) ,
MaxPooling2D(pool_size=(2,2)) ,
Conv2D(64,(5,5), activation ='relu'),
MaxPooling2D(pool_size=(2,2)) ,
Dropout(0.25),
Conv2D(64,(3,3), activation ='relu'),
MaxPooling2D(pool_size=(2,2)) ,
Dropout(0.25),
Flatten() ,
Dense(64, activation='relu'),
Dense(10, activation='softmax')
] )<choose_model_class> | del shap_interactions, shap_preds
gc.collect()
gc.collect() | Tabular Playground Series - Jan 2021 |
14,479,967 | model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'] )<train_model> | 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 |
14,479,967 | model.fit(target,label,epochs=40,batch_size=64 )<predict_on_test> | train['cont13_cont4'] = train['cont13']*train['cont4']
train['cont13_cont11'] = train['cont13']*train['cont11']
train['cont13_cont7'] = train['cont13']*train['cont7']
train['cont13_cont2'] = train['cont13']*train['cont2']
train['cont13_cont10'] = train['cont13']*train['cont10']
test['cont13_cont4'] = test['cont13']*test['cont4']
test['cont13_cont11'] = test['cont13']*test['cont11']
test['cont13_cont7'] = test['cont13']*test['cont7']
test['cont13_cont2'] = test['cont13']*test['cont2']
test['cont13_cont10'] = test['cont13']*test['cont10'] | Tabular Playground Series - Jan 2021 |
14,479,967 | Y_pred = model.predict(test)
Y_pred_classes = np.argmax(Y_pred,axis = 1 )<load_from_csv> | test = xgb.DMatrix(test[columns] ) | Tabular Playground Series - Jan 2021 |
14,479,967 | submission_data = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv' )<feature_engineering> | Best_trial= {'lambda': 0.0030282073258141168,
'alpha': 0.01563845128469084,
'colsample_bytree': 0.55,
'subsample': 0.7,
'learning_rate': 0.01,
'max_depth': 15,
'random_state': 2020,
'min_child_weight': 257,
'tree_method':'gpu_hist',
'predictor': 'gpu_predictor'} | Tabular Playground Series - Jan 2021 |
14,479,967 | submission_data['Label']=Y_pred_classes<save_to_csv> | kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.DMatrix(train_df, label=train_target)
val_df = xgb.DMatrix(val_df, label=val_target)
model = xgb.train(Best_trial, train_df, 1600)
temp_oof = model.predict(val_df)
temp_test = model.predict(test)
train_oof_2[val_ind] = temp_oof
test_preds_2 += temp_test/NUM_FOLDS
print(mean_squared_error(temp_oof, val_target, squared=False)) | Tabular Playground Series - Jan 2021 |
14,479,967 | submission_data.to_csv('submit.csv' ,index=False )<predict_on_test> | mean_squared_error(train_oof_2, target, squared=False)
| Tabular Playground Series - Jan 2021 |
14,479,967 | def test_output(i):
plt.imshow(x_train[i],cmap='gray')
predicted=np.argmax(model.predict(target[i].reshape(-1,28,28,1)))
actual=np.argmax(label[i])
plt.xlabel(f'predicted= {predicted} Actual= {actual}' )<import_modules> | mean_squared_error(0.6*train_oof+0.4*train_oof_2, target, squared=False)
| Tabular Playground Series - Jan 2021 |
14,479,967 | from PIL import Image, ImageGrab<predict_on_test> | np.save('train_oof_2', train_oof_2)
np.save('test_preds_2', test_preds_2 ) | Tabular Playground Series - Jan 2021 |
14,479,967 | def predict_digit1(img):
img = Image.open(img)
plt.imshow(img)
img = img.convert('L', dither=Image.NONE)
img = img.resize(( 28,28))
img = np.array(img)
img=np.invert(img)
predicted=np.argmax(model.predict(img.reshape(-1,28,28,1)))
plt.xlabel(f'Predicted= {predicted}' )<randomize_order> | sub['target'] = test_preds
sub.to_csv('submission.csv', index=False ) | Tabular Playground Series - Jan 2021 |
14,479,967 | predict_digit1('.. /input/temporary/Images/images.jfif' )<define_variables> | sub['target'] = test_preds_2
sub.to_csv('submission_2.csv', index=False ) | Tabular Playground Series - Jan 2021 |
14,479,967 | <define_variables><EOS> | sub['target'] = 0.6*test_preds+0.4*test_preds_2
sub.to_csv('submission_average.csv', index=False ) | Tabular Playground Series - Jan 2021 |
13,952,385 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<define_variables> | warnings.filterwarnings('ignore')
pd.set_option('display.max_rows', 50)
pd.set_option('display.max_columns', 50)
| Tabular Playground Series - Jan 2021 |
13,952,385 | predict_digit1('.. /input/temporary/Images/1.jpg' )<set_options> | df_train = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv')
df_test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv')
continuous_features = [feature for feature in df_train.columns if feature.startswith('cont')]
target = 'target'
print(f'Training Set Shape = {df_train.shape}')
print(f'Training Set Memory Usage = {df_train.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'Test Set Shape = {df_test.shape}')
print(f'Test Set Memory Usage = {df_test.memory_usage().sum() / 1024 ** 2:.2f} MB' ) | Tabular Playground Series - Jan 2021 |
13,952,385 | warnings.filterwarnings('ignore')
<define_variables> | class Preprocessor:
def __init__(self, train, test, n_splits, shuffle, random_state, scaler, discretize_features, create_features):
self.train = train.copy(deep=True)
self.test = test.copy(deep=True)
self.n_splits = n_splits
self.shuffle = shuffle
self.random_state = random_state
self.scaler = scaler() if scaler else None
self.discretize_features = discretize_features
self.create_features = create_features
def drop_outliers(self):
outlier_idx = self.train[self.train[target] < 4].index
self.train.drop(outlier_idx, inplace=True)
self.train.reset_index(drop=True, inplace=True)
print(f'Dropped {len(outlier_idx)} outliers')
del outlier_idx
def create_folds(self):
kf = KFold(n_splits=self.n_splits, shuffle=self.shuffle, random_state=self.random_state)
for fold,(_, val_idx)in enumerate(kf.split(self.train), 1):
self.train.loc[val_idx, 'fold'] = fold
self.train['fold'] = self.train['fold'].astype(np.uint8)
def scale(self):
df_all = pd.concat([self.train[continuous_features], self.test[continuous_features]], ignore_index=True, axis=0)
self.scaler.fit(df_all[continuous_features])
self.train.loc[:, continuous_features] = self.scaler.transform(self.train.loc[:, continuous_features].values)
self.test.loc[:, continuous_features] = self.scaler.transform(self.test.loc[:, continuous_features].values)
print(f'Scaled {len(continuous_features)} features with {self.scaler.__class__.__name__}')
del df_all
def create_peak_features(self):
for df in [self.train, self.test]:
df['cont2_peak'] =(( df_train['cont2'].round(2)== 0.36)|(df_train['cont2'].round(2)== 0.42)|(df_train['cont2'].round(2)== 0.49)|\
(df_train['cont2'].round(2)== 0.55)|(df_train['cont2'].round(2)== 0.56)|(df_train['cont2'].round(2)== 0.62)|\
(df_train['cont2'].round(2)== 0.68)|(df_train['cont2'].round(2)== 0.74)).astype(np.uint8)
df['cont5_peak'] =(df_train['cont5'].round(2)== 0.28 ).astype(np.uint8)
peak_features = ['cont2_peak', 'cont5_peak']
print(f'Created {len(peak_features)} peak features')
def create_idx_features(self):
for df in [self.train, self.test]:
df['cont_argmin'] = np.argmin(df[continuous_features].values, axis=1)
df['cont_argmax'] = np.argmax(df[continuous_features].values, axis=1)
idx_features = ['cont_argmin', 'cont_argmax']
print(f'Created {len(idx_features)} idx features with argmin and argmax')
def create_gmm_features(self):
n_component_mapping = {
1: 4,
2: 10,
3: 6,
4: 4,
5: 3,
6: 2,
7: 3,
8: 4,
9: 4,
10: 8,
11: 5,
12: 4,
13: 6,
14: 6
}
for i in range(1, 15):
gmm = GaussianMixture(n_components=n_component_mapping[i], random_state=self.random_state)
gmm.fit(pd.concat([self.train[f'cont{i}'], self.test[f'cont{i}']], axis=0 ).values.reshape(-1, 1))
self.train[f'cont{i}_class'] = gmm.predict(self.train[f'cont{i}'].values.reshape(-1, 1))
self.test[f'cont{i}_class'] = gmm.predict(self.test[f'cont{i}'].values.reshape(-1, 1))
gmm_features = [f'cont{i}_class' for i in range(1, 15)]
print(f'Created {len(gmm_features)} gmm features with GaussianMixture')
def transform(self):
self.drop_outliers()
self.create_folds()
if self.create_features:
self.create_peak_features()
self.create_idx_features()
if self.discretize_features:
self.create_gmm_features()
if self.scaler:
self.scale()
return self.train.copy(deep=True), self.test.copy(deep=True)
| Tabular Playground Series - Jan 2021 |
13,952,385 | training_folder = '.. /input/cassava-leaf-disease-classification/train_images/'<train_model> | cross_validation_seed = 0
preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed,
scaler=None,
create_features=False, discretize_features=False)
df_train_processed, df_test_processed = preprocessor.transform()
print(f'
Preprocessed Training Set Shape = {df_train_processed.shape}')
print(f'Preprocessed Training Set Memory Usage = {df_train_processed.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'Preprocessed Test Set Shape = {df_test_processed.shape}')
print(f'Preprocessed Test Set Memory Usage = {df_test_processed.memory_usage().sum() / 1024 ** 2:.2f} MB
' ) | Tabular Playground Series - Jan 2021 |
13,952,385 | img = Image.open(".. /input/cassava-leaf-disease-classification/train_images/1277648239.jpg")
plt.imshow(img)
plt.show()<load_from_csv> | class TreeModels:
def __init__(self, predictors, target, model, model_parameters, boosting_rounds, early_stopping_rounds, seeds):
self.predictors = predictors
self.target = target
self.model = model
self.model_parameters = model_parameters
self.boosting_rounds = boosting_rounds
self.early_stopping_rounds = early_stopping_rounds
self.seeds = seeds
def _train_and_predict_lgb(self, X_train, y_train, X_test):
seed_avg_oof_predictions = np.zeros(X_train.shape[0])
seed_avg_test_predictions = np.zeros(X_test.shape[0])
seed_avg_importance = pd.DataFrame(data=np.zeros(len(self.predictors)) , index=self.predictors, columns=['Importance'])
for seed in self.seeds:
print(f'{"-" * 30}
Running LightGBM model with seed: {seed}
{"-" * 30}
')
self.model_parameters['seed'] = seed
self.model_parameters['feature_fraction_seed'] = seed
self.model_parameters['bagging_seed'] = seed
self.model_parameters['drop_seed'] = seed
self.model_parameters['data_random_seed'] = seed
for fold in sorted(X_train['fold'].unique()):
trn_idx, val_idx = X_train.loc[X_train['fold'] != fold].index, X_train.loc[X_train['fold'] == fold].index
trn = lgb.Dataset(X_train.loc[trn_idx, self.predictors], label=y_train.loc[trn_idx])
val = lgb.Dataset(X_train.loc[val_idx, self.predictors], label=y_train.loc[val_idx])
model = lgb.train(params=self.model_parameters,
train_set=trn,
valid_sets=[trn, val],
num_boost_round=self.boosting_rounds,
early_stopping_rounds=self.early_stopping_rounds,
verbose_eval=500)
val_predictions = model.predict(X_train.loc[val_idx, self.predictors])
seed_avg_oof_predictions[val_idx] +=(val_predictions / len(self.seeds))
test_predictions = model.predict(X_test[self.predictors])
seed_avg_test_predictions +=(test_predictions / X_train['fold'].nunique() / len(self.seeds))
seed_avg_importance['Importance'] +=(model.feature_importance(importance_type='gain')/ X_train['fold'].nunique() / len(self.seeds))
fold_score = mean_squared_error(y_train.loc[val_idx], val_predictions, squared=False)
print(f'
LGB Fold {int(fold)} - X_trn: {X_train.loc[trn_idx, self.predictors].shape} X_val: {X_train.loc[val_idx, self.predictors].shape} - Score: {fold_score:.6} - Seed: {seed}
')
df_train_processed['LGBPredictions'] = seed_avg_oof_predictions
df_test_processed['LGBPredictions'] = seed_avg_test_predictions
oof_score = mean_squared_error(y_train, df_train_processed['LGBPredictions'], squared=False)
print(f'{"-" * 30}
LGB OOF RMSE: {oof_score:.6}({len(self.seeds)} Seed Average)
{"-" * 30}')
self._plot_importance(seed_avg_importance)
self._plot_predictions(df_train_processed[target], df_train_processed['LGBPredictions'], df_test_processed['LGBPredictions'])
def _train_and_predict_cb(self, X_train, y_train, X_test):
seed_avg_oof_predictions = np.zeros(X_train.shape[0])
seed_avg_test_predictions = np.zeros(X_test.shape[0])
seed_avg_importance = pd.DataFrame(data=np.zeros(len(self.predictors)) , index=self.predictors, columns=['Importance'])
for seed in self.seeds:
print(f'{"-" * 30}
Running CatBoost model with seed: {seed}
{"-" * 30}
')
self.model_parameters['random_seed'] = seed
for fold in sorted(X_train['fold'].unique()):
trn_idx, val_idx = X_train.loc[X_train['fold'] != fold].index, X_train.loc[X_train['fold'] == fold].index
trn = cb.Pool(X_train.loc[trn_idx, self.predictors], label=y_train.loc[trn_idx])
val = cb.Pool(X_train.loc[val_idx, self.predictors], label=y_train.loc[val_idx])
model = cb.CatBoostRegressor(**self.model_parameters)
model.fit(X=trn, eval_set=val)
val_predictions = model.predict(val)
seed_avg_oof_predictions[val_idx] +=(val_predictions / len(self.seeds))
test_predictions = model.predict(cb.Pool(X_test[self.predictors]))
seed_avg_test_predictions +=(test_predictions / X_train['fold'].nunique() / len(self.seeds))
seed_avg_importance['Importance'] +=(model.get_feature_importance() / X_train['fold'].nunique() / len(self.seeds))
fold_score = mean_squared_error(df_train_processed.loc[val_idx, self.target], val_predictions, squared=False)
print(f'
CB Fold {int(fold)} - X_trn: {X_train.loc[trn_idx, self.predictors].shape} X_val: {X_train.loc[val_idx, self.predictors].shape} - Score: {fold_score:.6} - Seed: {seed}
')
df_train_processed['CBPredictions'] = seed_avg_oof_predictions
df_test_processed['CBPredictions'] = seed_avg_test_predictions
oof_score = mean_squared_error(y_train, df_train_processed['CBPredictions'], squared=False)
print(f'{"-" * 30}
CB OOF RMSE: {oof_score:.6}({len(self.seeds)} Seed Average)
{"-" * 30}')
self._plot_importance(seed_avg_importance)
self._plot_predictions(df_train_processed[target], df_train_processed['CBPredictions'], df_test_processed['CBPredictions'])
def _train_and_predict_xgb(self, X_train, y_train, X_test):
seed_avg_oof_predictions = np.zeros(X_train.shape[0])
seed_avg_test_predictions = np.zeros(X_test.shape[0])
seed_avg_importance = pd.DataFrame(data=np.zeros(len(self.predictors)) , index=self.predictors, columns=['Importance'])
for seed in self.seeds:
print(f'{"-" * 30}
Running XGBoost model with seed: {seed}
{"-" * 30}
')
self.model_parameters['seed'] = seed
for fold in sorted(X_train['fold'].unique()):
trn_idx, val_idx = X_train.loc[X_train['fold'] != fold].index, X_train.loc[X_train['fold'] == fold].index
trn = xgb.DMatrix(X_train.loc[trn_idx, self.predictors], label=y_train.loc[trn_idx])
val = xgb.DMatrix(X_train.loc[val_idx, self.predictors], label=y_train.loc[val_idx])
model = xgb.train(params=self.model_parameters,
dtrain=trn,
evals=[(trn, 'train'),(val, 'val')],
num_boost_round=self.boosting_rounds,
early_stopping_rounds=self.early_stopping_rounds,
verbose_eval=500)
val_predictions = model.predict(xgb.DMatrix(X_train.loc[val_idx, self.predictors]))
seed_avg_oof_predictions[val_idx] +=(val_predictions / len(self.seeds))
test_predictions = model.predict(xgb.DMatrix(X_test[self.predictors]))
seed_avg_test_predictions +=(test_predictions / X_train['fold'].nunique() / len(self.seeds))
seed_avg_importance['Importance'] +=(np.array(list(model.get_score(importance_type='gain' ).values())) / X_train['fold'].nunique() / len(self.seeds))
fold_score = mean_squared_error(df_train_processed.loc[val_idx, self.target], val_predictions, squared=False)
print(f'
XGB Fold {int(fold)} - X_trn: {X_train.loc[trn_idx, self.predictors].shape} X_val: {X_train.loc[val_idx, self.predictors].shape} - Score: {fold_score:.6} - Seed: {seed}
')
df_train_processed['XGBPredictions'] = seed_avg_oof_predictions
df_test_processed['XGBPredictions'] = seed_avg_test_predictions
oof_score = mean_squared_error(y_train, df_train_processed['XGBPredictions'], squared=False)
print(f'{"-" * 30}
XGB OOF RMSE: {oof_score:.6}({len(self.seeds)} Seed Average)
{"-" * 30}')
self._plot_importance(seed_avg_importance)
self._plot_predictions(df_train_processed[target], df_train_processed['XGBPredictions'], df_test_processed['XGBPredictions'])
def _train_and_predict_rf(self, X_train, y_train, X_test):
seed_avg_oof_predictions = np.zeros(X_train.shape[0])
seed_avg_test_predictions = np.zeros(X_test.shape[0])
for seed in self.seeds:
print(f'{"-" * 30}
Running RandomForest model with seed: {seed}
{"-" * 30}
')
self.model_parameters['random_state'] = seed
for fold in sorted(X_train['fold'].unique()):
trn_idx, val_idx = X_train.loc[X_train['fold'] != fold].index, X_train.loc[X_train['fold'] == fold].index
X_trn, y_trn = X_train.loc[trn_idx, self.predictors].astype(np.float32), y_train.loc[trn_idx].astype(np.float32)
X_val, y_val = X_train.loc[val_idx, self.predictors].astype(np.float32), y_train.loc[val_idx].astype(np.float32)
model = cuml.ensemble.RandomForestRegressor(**self.model_parameters)
model.fit(X_trn, y_trn)
val_predictions = model.predict(X_val)
seed_avg_oof_predictions[val_idx] +=(val_predictions / len(self.seeds))
test_predictions = model.predict(X_test[self.predictors])
seed_avg_test_predictions +=(test_predictions / X_train['fold'].nunique() / len(self.seeds))
fold_score = mean_squared_error(df_train_processed.loc[val_idx, self.target], val_predictions, squared=False)
print(f'RF Fold {int(fold)} - X_trn: {X_train.loc[trn_idx, self.predictors].shape} X_val: {X_train.loc[val_idx, self.predictors].shape} - Score: {fold_score:.6}')
df_train_processed['RFPredictions'] = seed_avg_oof_predictions
df_test_processed['RFPredictions'] = seed_avg_test_predictions
oof_score = mean_squared_error(y_train, df_train_processed['RFPredictions'], squared=False)
print(f'{"-" * 30}
RF OOF RMSE: {oof_score:.6}({len(self.seeds)} Seed Average)
{"-" * 30}')
self._plot_predictions(df_train_processed[target], df_train_processed['RFPredictions'], df_test_processed['RFPredictions'])
def _plot_importance(self, df_importance):
df_importance.sort_values(by='Importance', inplace=True, ascending=False)
plt.figure(figsize=(25, 6))
sns.barplot(x='Importance', y=df_importance.index, data=df_importance, palette='Blues_d')
plt.xlabel('')
plt.tick_params(axis='x', labelsize=20)
plt.tick_params(axis='y', labelsize=20)
plt.title(f'{self.model} Feature Importance(Gain)', size=20, pad=20)
plt.show()
def _plot_predictions(self, train_labels, train_predictions, test_predictions):
fig, axes = plt.subplots(ncols=2, figsize=(25, 6))
sns.scatterplot(train_labels, train_predictions, ax=axes[0])
sns.distplot(train_predictions, label='Train Predictions', ax=axes[1])
sns.distplot(test_predictions, label='Test Predictions', ax=axes[1])
axes[0].set_xlabel(f'Train Labels', size=18)
axes[0].set_ylabel(f'Train Predictions', size=18)
axes[1].set_xlabel('')
axes[1].legend(prop={'size': 18})
for i in range(2):
axes[i].tick_params(axis='x', labelsize=15)
axes[i].tick_params(axis='y', labelsize=15)
axes[0].set_title(f'Train Labels vs Train Predictions', size=20, pad=20)
axes[1].set_title(f'Predictions Distributions', size=20, pad=20)
plt.show()
def run(self, X_train, y_train, X_test):
if self.model == 'LGB':
self._train_and_predict_lgb(X_train, y_train, X_test)
elif self.model == 'CB':
self._train_and_predict_cb(X_train, y_train, X_test)
elif self.model == 'XGB':
self._train_and_predict_xgb(X_train, y_train, X_test)
elif self.model == 'RF':
self._train_and_predict_rf(X_train, y_train, X_test)
| Tabular Playground Series - Jan 2021 |
13,952,385 | samples_df = pd.read_csv(".. /input/cassava-leaf-disease-classification/train.csv")
samples_df = shuffle(samples_df, random_state=42)
samples_df["filepath"] = training_folder+samples_df["image_id"]
samples_df[:10]<prepare_x_and_y> | TRAIN_LGB = False
if TRAIN_LGB:
model = 'LGB'
lgb_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_lgb, df_test_lgb = lgb_preprocessor.transform()
print(f'
{model} Training Set Shape = {df_train_lgb.shape}')
print(f'{model} Training Set Memory Usage = {df_train_lgb.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'{model} Test Set Shape = {df_test_lgb.shape}')
print(f'{model} Test Set Memory Usage = {df_test_lgb.memory_usage().sum() / 1024 ** 2:.2f} MB
')
X_train_lgb = df_train_lgb.copy(deep=True)
y_train_lgb = df_train_lgb[target].copy(deep=True)
X_test_lgb = df_test_lgb.copy(deep=True)
lgb_parameters = {
'predictors': continuous_features,
'target': target,
'model': model,
'model_parameters': {
'num_leaves': 2 ** 8,
'learning_rate': 0.001,
'bagging_fraction': 0.6,
'bagging_freq': 3,
'feature_fraction': 0.5,
'feature_fraction_bynode': 0.8,
'min_data_in_leaf': 100,
'min_data_per_group': 1,
'min_gain_to_split': 0.001,
'lambda_l1': 6,
'lambda_l2': 0.0005,
'max_bin': 768,
'max_depth': -1,
'objective': 'regression',
'seed': None,
'feature_fraction_seed': None,
'bagging_seed': None,
'drop_seed': None,
'data_random_seed': None,
'boosting_type': 'gbdt',
'verbose': 1,
'metric': 'rmse',
'n_jobs': -1,
},
'boosting_rounds': 20000,
'early_stopping_rounds': 200,
'seeds': [541992, 721991, 1337]
}
lgb_model = TreeModels(**lgb_parameters)
lgb_model.run(X_train_lgb, y_train_lgb, X_test_lgb)
del df_train_lgb, df_test_lgb, X_train_lgb, y_train_lgb, X_test_lgb
del lgb_preprocessor, lgb_parameters, lgb_model
print('Saving LightGBM OOF and Test predictions to current working directory.')
df_train_processed[['id', 'LGBPredictions']].to_csv('lgb_oof_predictions.csv', index=False)
df_test_processed[['id', 'LGBPredictions']].to_csv('lgb_test_predictions.csv', index=False)
else:
print('Loading LightGBM OOF and Test predictions from current working directory.')
df_train_processed['LGBPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/lgb_oof_predictions.csv')['LGBPredictions']
df_test_processed['LGBPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/lgb_test_predictions.csv')['LGBPredictions']
oof_score = mean_squared_error(df_train_processed['target'], df_train_processed['LGBPredictions'], squared=False)
print(f'LGB OOF RMSE: {oof_score:.6}')
TreeModels._plot_predictions(None, df_train_processed[target], df_train_processed['LGBPredictions'], df_test_processed['LGBPredictions'])
| Tabular Playground Series - Jan 2021 |
13,952,385 | y=samples_df['label'].values
y = to_categorical(y )<count_unique_values> | TRAIN_CB = False
if TRAIN_CB:
model = 'CB'
cb_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_cb, df_test_cb = cb_preprocessor.transform()
print(f'
{model} Training Set Shape = {df_train_cb.shape}')
print(f'{model} Training Set Memory Usage = {df_train_cb.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'{model} Test Set Shape = {df_test_cb.shape}')
print(f'{model} Test Set Memory Usage = {df_test_cb.memory_usage().sum() / 1024 ** 2:.2f} MB
')
X_train_cb = df_train_cb[continuous_features + ['fold']].copy(deep=True)
y_train_cb = df_train_cb[target].copy(deep=True)
X_test_cb = df_test_cb[continuous_features].copy(deep=True)
cb_parameters = {
'predictors': continuous_features,
'target': target,
'model': model,
'model_parameters': {
'n_estimators': 20000,
'learning_rate': 0.006,
'depth': 10,
'subsample': 0.8,
'colsample_bylevel': 0.5,
'l2_leaf_reg': 0.1,
'metric_period': 1000,
'boost_from_average': True,
'use_best_model': True,
'eval_metric': 'RMSE',
'loss_function': 'RMSE',
'od_type': 'Iter',
'od_wait': 200,
'random_seed': None,
'verbose': 1,
},
'boosting_rounds': None,
'early_stopping_rounds': None,
'seeds': [541992, 721991, 1337, 42, 0]
}
cb_model = TreeModels(**cb_parameters)
cb_model.run(X_train_cb, y_train_cb, X_test_cb)
del df_train_cb, df_test_cb, X_train_cb, y_train_cb, X_test_cb
del cb_preprocessor, cb_parameters, cb_model
print('Saving CatBoost OOF and Test predictions to current working directory.')
df_train_processed[['id', 'CBPredictions']].to_csv('cb_oof_predictions.csv', index=False)
df_test_processed[['id', 'CBPredictions']].to_csv('cb_test_predictions.csv', index=False)
else:
print('Loading CatBoost OOF and Test predictions from current working directory.')
df_train_processed['CBPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/cb_oof_predictions.csv')['CBPredictions']
df_test_processed['CBPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/cb_test_predictions.csv')['CBPredictions']
oof_score = mean_squared_error(df_train_processed['target'], df_train_processed['CBPredictions'], squared=False)
print(f'CB OOF RMSE: {oof_score:.6}')
TreeModels._plot_predictions(None, df_train_processed[target], df_train_processed['CBPredictions'], df_test_processed['CBPredictions'])
| Tabular Playground Series - Jan 2021 |
13,952,385 | batch_size = 8
image_size = 512
input_shape =(image_size, image_size, 3)
dropout_rate = 0.4
classes_to_predict = sorted(samples_df.label.unique() )<split> | TRAIN_XGB = False
if TRAIN_XGB:
model = 'XGB'
xgb_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_xgb, df_test_xgb = xgb_preprocessor.transform()
print(f'
{model} Training Set Shape = {df_train_xgb.shape}')
print(f'{model} Training Set Memory Usage = {df_train_xgb.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'{model} Test Set Shape = {df_test_xgb.shape}')
print(f'{model} Test Set Memory Usage = {df_test_xgb.memory_usage().sum() / 1024 ** 2:.2f} MB
')
X_train_xgb = df_train_xgb[continuous_features + ['fold']].copy(deep=True)
y_train_xgb = df_train_xgb[target].copy(deep=True)
X_test_xgb = df_test_xgb[continuous_features].copy(deep=True)
xgb_parameters = {
'predictors': continuous_features,
'target': target,
'model': model,
'model_parameters': {
'learning_rate': 0.002,
'colsample_bytree': 0.6,
'colsample_bylevel': 0.6,
'colsample_bynode': 0.6,
'sumbsample': 0.8,
'max_depth': 14,
'gamma': 0,
'min_child_weight': 200,
'lambda': 0,
'alpha': 0,
'objective': 'reg:squarederror',
'seed': None,
'boosting_type': 'gbtree',
'tree_method': 'gpu_hist',
'silent': True,
'verbose': 1,
'n_jobs': -1,
},
'boosting_rounds': 25000,
'early_stopping_rounds': 200,
'seeds': [541992, 721991, 1337]
}
xgb_model = TreeModels(**xgb_parameters)
xgb_model.run(X_train_xgb, y_train_xgb, X_test_xgb)
del df_train_xgb, df_test_xgb, X_train_xgb, y_train_xgb, X_test_xgb
del xgb_preprocessor, xgb_parameters, xgb_model
print('Saving XGBoost OOF and Test predictions to current working directory.')
df_train_processed[['id', 'XGBPredictions']].to_csv('xgb_oof_predictions.csv', index=False)
df_test_processed[['id', 'XGBPredictions']].to_csv('xgb_test_predictions.csv', index=False)
else:
print('Loading XGBoost OOF and Test predictions from current working directory.')
df_train_processed['XGBPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/xgb_oof_predictions.csv')['XGBPredictions']
df_test_processed['XGBPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/xgb_test_predictions.csv')['XGBPredictions']
oof_score = mean_squared_error(df_train_processed['target'], df_train_processed['XGBPredictions'], squared=False)
print(f'XGB OOF RMSE: {oof_score:.6}')
TreeModels._plot_predictions(None, df_train_processed[target], df_train_processed['XGBPredictions'], df_test_processed['XGBPredictions'])
| Tabular Playground Series - Jan 2021 |
13,952,385 | X_train, X_test, y_train, y_test = train_test_split(samples_df, y, random_state=42, test_size=0.2 )<prepare_x_and_y> | TRAIN_RF = False
if TRAIN_RF:
model = 'RF'
rf_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_rf, df_test_rf = rf_preprocessor.transform()
print(f'
{model} Training Set Shape = {df_train_rf.shape}')
print(f'{model} Training Set Memory Usage = {df_train_rf.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'{model} Test Set Shape = {df_test_rf.shape}')
print(f'{model} Test Set Memory Usage = {df_test_rf.memory_usage().sum() / 1024 ** 2:.2f} MB
')
X_train_rf = df_train_rf[continuous_features + ['fold']].copy(deep=True)
y_train_rf = df_train_rf[target].copy(deep=True)
X_test_rf = df_test_rf[continuous_features].copy(deep=True)
rf_parameters = {
'predictors': continuous_features,
'target': target,
'model': model,
'model_parameters': {
'n_estimators': 400,
'split_algo': 0,
'split_criterion': 2,
'bootstrap': True,
'bootstrap_features': False,
'max_depth': 13,
'max_leaves': -1,
'max_features': 0.5,
'n_bins': 2 ** 6,
'random_state': None,
'verbose': True,
},
'boosting_rounds': None,
'early_stopping_rounds': None,
'seeds': [541992, 721991, 1337, 42, 0]
}
rf_model = TreeModels(**rf_parameters)
rf_model.run(X_train_rf, y_train_rf, X_test_rf)
del df_train_rf, df_test_rf, X_train_rf, y_train_rf, X_test_rf
del rf_preprocessor, rf_parameters, rf_model
print('Saving RandomForest OOF and Test predictions to current working directory.')
df_train_processed[['id', 'RFPredictions']].to_csv('rf_oof_predictions.csv', index=False)
df_test_processed[['id', 'RFPredictions']].to_csv('rf_test_predictions.csv', index=False)
else:
print('Loading RandomForest OOF and Test predictions from current working directory.')
df_train_processed['RFPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/rf_oof_predictions.csv')['RFPredictions']
df_test_processed['RFPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/rf_test_predictions.csv')['RFPredictions']
oof_score = mean_squared_error(df_train_processed['target'], df_train_processed['RFPredictions'], squared=False)
print(f'RF OOF RMSE: {oof_score:.6}')
TreeModels._plot_predictions(None, df_train_processed[target], df_train_processed['RFPredictions'], df_test_processed['RFPredictions'])
| Tabular Playground Series - Jan 2021 |
13,952,385 | training_data = tf.data.Dataset.from_tensor_slices(( X_train.filepath.values, y_train))
validation_data = tf.data.Dataset.from_tensor_slices(( X_test.filepath.values, y_test))<categorify> | class LinearModels:
def __init__(self, predictors, target, model, model_parameters):
self.predictors = predictors
self.target = target
self.model = model
self.model_parameters = model_parameters
def _train_and_predict_ridge_regression(self, X_train, y_train, X_test):
X = pd.concat([X_train[continuous_features], X_test[continuous_features]], ignore_index=True, axis=0)
embedder = RandomTreesEmbedding(n_estimators=800,
max_depth=8,
min_samples_split=100,
n_jobs=-1,
random_state=0,
verbose=False)
embedder.fit(X)
del X
X_test = embedder.transform(X_test.loc[:, continuous_features] ).astype(np.uint8)
oof_predictions = np.zeros(X_train.shape[0])
test_predictions = np.zeros(X_test.shape[0])
for fold in sorted(X_train['fold'].unique()):
trn_idx, val_idx = X_train.loc[X_train['fold'] != fold].index, X_train.loc[X_train['fold'] == fold].index
X_trn = embedder.transform(X_train.loc[trn_idx, continuous_features] ).astype(np.uint8)
y_trn = y_train.loc[trn_idx]
X_val = embedder.transform(X_train.loc[val_idx, continuous_features] ).astype(np.uint8)
y_val = y_train.loc[val_idx]
model = Ridge(**self.model_parameters)
model.fit(X_trn, y_trn)
val_predictions = model.predict(X_val)
oof_predictions[val_idx] += val_predictions
fold_test_predictions = model.predict(X_test)
test_predictions +=(fold_test_predictions / X_train['fold'].nunique())
fold_score = mean_squared_error(y_val, val_predictions, squared=False)
print(f'RR Fold {int(fold)} - X_trn: {X_trn.shape} X_val: {X_val.shape} - Score: {fold_score:.6}')
df_train_processed['RRPredictions'] = oof_predictions
df_test_processed['RRPredictions'] = test_predictions
oof_score = mean_squared_error(y_train, df_train_processed['RRPredictions'], squared=False)
print(f'{"-" * 30}
RR OOF RMSE: {oof_score:.6}
{"-" * 30}')
self._plot_predictions(df_train_processed[target], df_train_processed['RRPredictions'], df_test_processed['RRPredictions'])
def _train_and_predict_svm(self, X_train, y_train, X_test):
oof_predictions = np.zeros(X_train.shape[0])
test_predictions = np.zeros(X_test.shape[0])
for fold in sorted(X_train['fold'].unique()):
trn_idx, val_idx = X_train.loc[X_train['fold'] != fold].index, X_train.loc[X_train['fold'] == fold].index
X_trn = X_train.loc[trn_idx, self.predictors]
y_trn = y_train.loc[trn_idx]
X_val = X_train.loc[val_idx, self.predictors]
y_val = y_train.loc[val_idx]
model = cuml.SVR(**self.model_parameters)
model.fit(X_trn, y_trn)
val_predictions = model.predict(X_val)
oof_predictions[val_idx] += val_predictions
fold_test_predictions = model.predict(X_test)
test_predictions +=(fold_test_predictions / X_train['fold'].nunique())
fold_score = mean_squared_error(y_val, val_predictions, squared=False)
print(f'SVM Fold {int(fold)} - X_trn: {X_trn.shape} X_val: {X_val.shape} - Score: {fold_score:.6}')
df_train_processed['SVMPredictions'] = oof_predictions
df_test_processed['SVMPredictions'] = test_predictions
oof_score = mean_squared_error(y_train, df_train_processed['SVMPredictions'], squared=False)
print(f'{"-" * 30}
SVM OOF RMSE: {oof_score:.6}
{"-" * 30}')
self._plot_predictions(df_train_processed[target], df_train_processed['SVMPredictions'], df_test_processed['SVMPredictions'])
def _plot_predictions(self, train_labels, train_predictions, test_predictions):
fig, axes = plt.subplots(ncols=2, figsize=(25, 6))
sns.scatterplot(train_labels, train_predictions, ax=axes[0])
sns.distplot(train_predictions, label='Train Predictions', ax=axes[1])
sns.distplot(test_predictions, label='Test Predictions', ax=axes[1])
axes[0].set_xlabel(f'Train Labels', size=18)
axes[0].set_ylabel(f'Train Predictions', size=18)
axes[1].set_xlabel('')
axes[1].legend(prop={'size': 18})
for i in range(2):
axes[i].tick_params(axis='x', labelsize=15)
axes[i].tick_params(axis='y', labelsize=15)
axes[0].set_title(f'Train Labels vs Train Predictions', size=20, pad=20)
axes[1].set_title(f'Predictions Distributions', size=20, pad=20)
plt.show()
def run(self, X_train, y_train, X_test):
if self.model == 'Ridge':
self._train_and_predict_ridge_regression(X_train, y_train, X_test)
elif self.model == 'SVM':
self._train_and_predict_svm(X_train, y_train, X_test)
| Tabular Playground Series - Jan 2021 |
13,952,385 | def load_image_and_label_from_path(image_path, label):
img = tf.io.read_file(image_path)
img = tf.image.decode_jpeg(img, channels=3)
return img,label
AUTOTUNE = tf.data.experimental.AUTOTUNE
training_data = training_data.map(load_image_and_label_from_path, num_parallel_calls=AUTOTUNE)
validation_data = validation_data.map(load_image_and_label_from_path, num_parallel_calls=AUTOTUNE )<define_variables> | FIT_RR = False
if FIT_RR:
model = 'Ridge'
ridge_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=None,
create_features=False, discretize_features=False)
df_train_ridge, df_test_ridge = ridge_preprocessor.transform()
print(f'
{model} Training Set Shape = {df_train_ridge.shape}')
print(f'{model} Training Set Memory Usage = {df_train_ridge.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'{model} Test Set Shape = {df_test_ridge.shape}')
print(f'{model} Test Set Memory Usage = {df_test_ridge.memory_usage().sum() / 1024 ** 2:.2f} MB
')
X_train_rr = df_train_ridge[continuous_features + ['fold']].copy(deep=True)
y_train_rr = df_train_ridge[target].copy(deep=True)
X_test_rr = df_test_ridge[continuous_features].copy(deep=True)
ridge_parameters = {
'predictors': continuous_features,
'target': target,
'model': model,
'model_parameters': {
'alpha': 7000
}
}
ridge_model = LinearModels(**ridge_parameters)
ridge_model.run(X_train_rr, y_train_rr, X_test_rr)
del df_train_ridge, df_test_ridge, X_train_ridge, y_train_ridge, X_test_ridge
del ridge_preprocessor, ridge_parameters, ridge_model
print('Saving RidgeRegression OOF and Test predictions to current working directory.')
df_train_processed[['id', 'RRPredictions']].to_csv('rr_oof_predictions.csv', index=False)
df_test_processed[['id', 'RRPredictions']].to_csv('rr_test_predictions.csv', index=False)
else:
print('Loading RidgeRegression OOF and Test predictions from current working directory.')
df_train_processed['RRPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/rr_oof_predictions.csv')['RRPredictions']
df_test_processed['RRPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/rr_test_predictions.csv')['RRPredictions']
oof_score = mean_squared_error(df_train_processed['target'], df_train_processed['RRPredictions'], squared=False)
print(f'RR OOF RMSE: {oof_score:.6}')
LinearModels._plot_predictions(None, df_train_processed[target], df_train_processed['RRPredictions'], df_test_processed['RRPredictions'])
| Tabular Playground Series - Jan 2021 |
13,952,385 | training_data_batches = training_data.shuffle(buffer_size=1000 ).batch(batch_size ).prefetch(buffer_size=AUTOTUNE)
validation_data_batches = validation_data.shuffle(buffer_size=1000 ).batch(batch_size ).prefetch(buffer_size=AUTOTUNE )<normalization> | FIT_SVM = False
if FIT_SVM:
model = 'SVM'
svm_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=StandardScaler,
create_features=False, discretize_features=True)
df_train_svm, df_test_svm = svm_preprocessor.transform()
print(f'
{model} Training Set Shape = {df_train_svm.shape}')
print(f'{model} Training Set Memory Usage = {df_train_svm.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'{model} Test Set Shape = {df_test_svm.shape}')
print(f'{model} Test Set Memory Usage = {df_test_svm.memory_usage().sum() / 1024 ** 2:.2f} MB
')
X_train_svm = df_train_svm[continuous_features + ['fold'] + [f'{cont}_class' for cont in continuous_features]].copy(deep=True)
y_train_svm = df_train_svm[target].copy(deep=True)
X_test_svm = df_test_svm[continuous_features + [f'{cont}_class' for cont in continuous_features]].copy(deep=True)
svm_parameters = {
'predictors': continuous_features + [f'{cont}_class' for cont in continuous_features],
'target': target,
'model': model,
'model_parameters': {
'C': 0.5
}
}
svm_model = LinearModels(**svm_parameters)
svm_model.run(X_train_svm, y_train_svm, X_test_svm)
del df_train_svm, df_test_svm, X_train_svm, y_train_svm, X_test_svm
del svm_preprocessor, svm_parameters, svm_model
print('Saving SVM OOF and Test predictions to current working directory.')
df_train_processed[['id', 'SVMPredictions']].to_csv('svm_oof_predictions.csv', index=False)
df_test_processed[['id', 'SVMPredictions']].to_csv('svm_test_predictions.csv', index=False)
else:
print('Loading SVM OOF and Test predictions from current working directory.')
df_train_processed['SVMPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/svm_oof_predictions.csv')['SVMPredictions']
df_test_processed['SVMPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/svm_test_predictions.csv')['SVMPredictions']
oof_score = mean_squared_error(df_train_processed['target'], df_train_processed['SVMPredictions'], squared=False)
print(f'SVM OOF RMSE: {oof_score:.6}')
LinearModels._plot_predictions(None, df_train_processed[target], df_train_processed['SVMPredictions'], df_test_processed['SVMPredictions'])
| Tabular Playground Series - Jan 2021 |
13,952,385 | adapt_data = tf.data.Dataset.from_tensor_slices(X_train.filepath.values)
def adapt_mode(image_path):
img = tf.io.read_file(image_path)
img = tf.image.decode_jpeg(img, channels=3)
img = layers.experimental.preprocessing.Rescaling(1.0 / 255 )(img)
return img
adapt_data = adapt_data.map(adapt_mode, num_parallel_calls=AUTOTUNE)
adapt_data_batches = adapt_data.shuffle(buffer_size=1000 ).batch(batch_size ).prefetch(buffer_size=AUTOTUNE )<set_options> | class NeuralNetworks:
def __init__(self, predictors, target, model, model_parameters, seeds):
self.predictors = predictors
self.target = target
self.model = model
self.model_parameters = model_parameters
self.seeds = seeds
def _set_seed(self, seed):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
def _rmse_loss(self, y_true, y_pred):
return K.sqrt(K.mean(K.square(y_true - y_pred)))
def _dense_block(self, x, units, activation, dropout_rate, kernel_regularizer, batch_normalization, weight_normalization, gaussian_noise):
if weight_normalization:
x = tfa.layers.WeightNormalization(Dense(units=units, activation=activation, kernel_regularizer=kernel_regularizer))(x)
else:
x = Dense(units=units, activation=activation, kernel_regularizer=kernel_regularizer )(x)
if batch_normalization:
x = BatchNormalization()(x)
if dropout_rate > 0:
x = Dropout(rate=dropout_rate )(x)
if gaussian_noise > 0:
x = GaussianNoise(gaussian_noise )(x)
return x
def _get_tmlp(self, input_shape, output_shape):
inputs = []
cont1_discretized_input = Input(shape=(1,), name='cont1_discretized_input')
cont1_embedding_dim = 2
cont1_discretized_embedding = Embedding(input_dim=4, output_dim=cont1_embedding_dim, input_length=1, name='cont1_discretized_embedding' )(cont1_discretized_input)
cont1_discretized_embedding = Reshape(target_shape=(cont1_embedding_dim,))(cont1_discretized_embedding)
inputs.append(cont1_discretized_embedding)
cont2_discretized_input = Input(shape=(1,), name='cont2_discretized_input')
cont2_embedding_dim = 4
cont2_discretized_embedding = Embedding(input_dim=10, output_dim=cont2_embedding_dim, input_length=1, name='cont2_discretized_embedding' )(cont2_discretized_input)
cont2_discretized_embedding = Reshape(target_shape=(cont2_embedding_dim,))(cont2_discretized_embedding)
inputs.append(cont2_discretized_embedding)
cont3_discretized_input = Input(shape=(1,), name='cont3_discretized_input')
cont3_embedding_dim = 3
cont3_discretized_embedding = Embedding(input_dim=6, output_dim=cont3_embedding_dim, input_length=1, name='cont3_discretized_embedding' )(cont3_discretized_input)
cont3_discretized_embedding = Reshape(target_shape=(cont3_embedding_dim,))(cont3_discretized_embedding)
inputs.append(cont3_discretized_embedding)
cont4_discretized_input = Input(shape=(1,), name='cont4_discretized_input')
cont4_embedding_dim = 2
cont4_discretized_embedding = Embedding(input_dim=4, output_dim=cont4_embedding_dim, input_length=1, name='cont4_discretized_embedding' )(cont4_discretized_input)
cont4_discretized_embedding = Reshape(target_shape=(cont4_embedding_dim,))(cont4_discretized_embedding)
inputs.append(cont4_discretized_embedding)
cont5_discretized_input = Input(shape=(1,), name='cont5_discretized_input')
cont5_embedding_dim = 2
cont5_discretized_embedding = Embedding(input_dim=3, output_dim=cont5_embedding_dim, input_length=1, name='cont5_discretized_embedding' )(cont5_discretized_input)
cont5_discretized_embedding = Reshape(target_shape=(cont5_embedding_dim,))(cont5_discretized_embedding)
inputs.append(cont5_discretized_embedding)
cont6_discretized_input = Input(shape=(1,), name='cont6_discretized_input')
cont6_embedding_dim = 2
cont6_discretized_embedding = Embedding(input_dim=2, output_dim=cont6_embedding_dim, input_length=1, name='cont6_discretized_embedding' )(cont6_discretized_input)
cont6_discretized_embedding = Reshape(target_shape=(cont6_embedding_dim,))(cont6_discretized_embedding)
inputs.append(cont6_discretized_embedding)
cont7_discretized_input = Input(shape=(1,), name='cont7_discretized_input')
cont7_embedding_dim = 2
cont7_discretized_embedding = Embedding(input_dim=3, output_dim=cont7_embedding_dim, input_length=1, name='cont7_discretized_embedding' )(cont7_discretized_input)
cont7_discretized_embedding = Reshape(target_shape=(cont7_embedding_dim,))(cont7_discretized_embedding)
inputs.append(cont7_discretized_embedding)
cont8_discretized_input = Input(shape=(1,), name='cont8_discretized_input')
cont8_embedding_dim = 2
cont8_discretized_embedding = Embedding(input_dim=4, output_dim=cont8_embedding_dim, input_length=1, name='cont8_discretized_embedding' )(cont8_discretized_input)
cont8_discretized_embedding = Reshape(target_shape=(cont8_embedding_dim,))(cont8_discretized_embedding)
inputs.append(cont8_discretized_embedding)
cont9_discretized_input = Input(shape=(1,), name='cont9_discretized_input')
cont9_embedding_dim = 2
cont9_discretized_embedding = Embedding(input_dim=4, output_dim=cont9_embedding_dim, input_length=1, name='cont9_discretized_embedding' )(cont9_discretized_input)
cont9_discretized_embedding = Reshape(target_shape=(cont9_embedding_dim,))(cont9_discretized_embedding)
inputs.append(cont9_discretized_embedding)
cont10_discretized_input = Input(shape=(1,), name='cont10_discretized_input')
cont10_embedding_dim = 3
cont10_discretized_embedding = Embedding(input_dim=8, output_dim=cont10_embedding_dim, input_length=1, name='cont10_discretized_embedding' )(cont10_discretized_input)
cont10_discretized_embedding = Reshape(target_shape=(cont10_embedding_dim,))(cont10_discretized_embedding)
inputs.append(cont10_discretized_embedding)
cont11_discretized_input = Input(shape=(1,), name='cont11_discretized_input')
cont11_embedding_dim = 3
cont11_discretized_embedding = Embedding(input_dim=5, output_dim=cont11_embedding_dim, input_length=1, name='cont11_discretized_embedding' )(cont11_discretized_input)
cont11_discretized_embedding = Reshape(target_shape=(cont11_embedding_dim,))(cont11_discretized_embedding)
inputs.append(cont11_discretized_embedding)
cont12_discretized_input = Input(shape=(1,), name='cont12_discretized_input')
cont12_embedding_dim = 2
cont12_discretized_embedding = Embedding(input_dim=4, output_dim=cont12_embedding_dim, input_length=1, name='cont12_discretized_embedding' )(cont12_discretized_input)
cont12_discretized_embedding = Reshape(target_shape=(cont12_embedding_dim,))(cont12_discretized_embedding)
inputs.append(cont12_discretized_embedding)
cont13_discretized_input = Input(shape=(1,), name='cont13_discretized_input')
cont13_embedding_dim = 3
cont13_discretized_embedding = Embedding(input_dim=6, output_dim=cont13_embedding_dim, input_length=1, name='cont13_discretized_embedding' )(cont13_discretized_input)
cont13_discretized_embedding = Reshape(target_shape=(cont13_embedding_dim,))(cont13_discretized_embedding)
inputs.append(cont13_discretized_embedding)
cont14_discretized_input = Input(shape=(1,), name='cont14_discretized_input')
cont14_embedding_dim = 3
cont14_discretized_embedding = Embedding(input_dim=6, output_dim=cont14_embedding_dim, input_length=1, name='cont14_discretized_embedding' )(cont14_discretized_input)
cont14_discretized_embedding = Reshape(target_shape=(cont14_embedding_dim,))(cont14_discretized_embedding)
inputs.append(cont14_discretized_embedding)
continuous_inputs = Input(shape=(14,), name='continuous_inputs')
inputs.append(continuous_inputs)
sparse_inputs = Input(shape=(input_shape -(14 * 2),), name='sparse_inputs')
inputs.append(sparse_inputs)
x = Concatenate()(inputs)
x = self._dense_block(x, units=256, activation='elu', dropout_rate=0.50, kernel_regularizer=None, batch_normalization=True, weight_normalization=True, gaussian_noise=0.01)
x = self._dense_block(x, units=256, activation='elu', dropout_rate=0.50, kernel_regularizer=None, batch_normalization=True, weight_normalization=True, gaussian_noise=0.01)
outputs = Dense(output_shape, activation='linear' )(x)
model = Model(inputs=[continuous_inputs,
cont1_discretized_input,
cont2_discretized_input,
cont3_discretized_input,
cont4_discretized_input,
cont5_discretized_input,
cont6_discretized_input,
cont7_discretized_input,
cont8_discretized_input,
cont9_discretized_input,
cont10_discretized_input,
cont11_discretized_input,
cont12_discretized_input,
cont13_discretized_input,
cont14_discretized_input,
sparse_inputs],
outputs=outputs,
name='TMLP')
optimizer = tfa.optimizers.AdamW(learning_rate=self.model_parameters['learning_rate'], weight_decay=self.model_parameters['weight_decay'])
model.compile(optimizer=optimizer, loss=self._rmse_loss, metrics=None)
return model
def _get_rmlp(self, input_shape, output_shape):
inputs = Input(shape=(input_shape,), name='inputs')
x = self._dense_block(inputs, units=128, activation='elu', dropout_rate=0.30, kernel_regularizer=None, batch_normalization=True, weight_normalization=False, gaussian_noise=0)
x = self._dense_block(x, units=128, activation='elu', dropout_rate=0.30, kernel_regularizer=None, batch_normalization=True, weight_normalization=False, gaussian_noise=0)
outputs = Dense(output_shape, activation='linear' )(x)
model = Model(inputs=inputs, outputs=outputs, name='RMLP')
optimizer = Adam(learning_rate=self.model_parameters['learning_rate'])
model.compile(optimizer=optimizer, loss=self._rmse_loss, metrics=None)
return model
def train_and_predict_tmlp(self, X_train, y_train, X_test):
all_model_histories = {}
seed_avg_oof_predictions = np.zeros(X_train.shape[0])
seed_avg_test_predictions = np.zeros(X_test.shape[0])
oof_predictions = np.zeros(X_train.shape[0])
test_predictions = np.zeros(X_test.shape[0])
for seed in self.seeds:
X = pd.concat([X_train[continuous_features], X_test[continuous_features]], ignore_index=True, axis=0)
embedder = RandomTreesEmbedding(n_estimators=300,
max_depth=3,
min_samples_split=100,
n_jobs=-1,
random_state=seed,
verbose=True)
embedder.fit(X)
del X
train_sparse_features = embedder.transform(X_train.loc[:, continuous_features] ).astype(np.uint8 ).toarray()
X_train = pd.concat([X_train, pd.DataFrame(train_sparse_features)], axis=1)
sparse_feature_columns = list(np.arange(train_sparse_features.shape[1]))
self.predictors += sparse_feature_columns
del train_sparse_features
test_sparse_features = embedder.transform(X_test.loc[:, continuous_features] ).astype(np.uint8 ).toarray()
del embedder
X_test = pd.concat([X_test, pd.DataFrame(test_sparse_features)], axis=1)
del test_sparse_features
print(f'{"-" * 30}
Running TMLP model with seed: {seed}
{"-" * 30}
')
self._set_seed(seed)
model_histories = []
for fold in sorted(X_train['fold'].unique()):
trn_idx, val_idx = X_train.loc[X_train['fold'] != fold].index, X_train.loc[X_train['fold'] == fold].index
X_trn, y_trn = X_train.loc[trn_idx, self.predictors], y_train.loc[trn_idx]
X_val, y_val = X_train.loc[val_idx, self.predictors], y_train.loc[val_idx]
model = self._get_mlp(input_shape=X_trn.shape[1], output_shape=1)
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=self.model_parameters['reduce_lr_factor'],
patience=self.model_parameters['reduce_lr_patience'],
min_lr=self.model_parameters['reduce_lr_min'],
mode='min',
verbose=True)
early_stopping = EarlyStopping(monitor='val_loss',
mode='min',
min_delta=self.model_parameters['early_stopping_min_delta'],
patience=self.model_parameters['early_stopping_patience'],
restore_best_weights=True,
verbose=True)
history = model.fit([X_trn[self.predictors[:14]],
X_trn['cont1_class'],
X_trn['cont2_class'],
X_trn['cont3_class'],
X_trn['cont4_class'],
X_trn['cont5_class'],
X_trn['cont6_class'],
X_trn['cont7_class'],
X_trn['cont8_class'],
X_trn['cont9_class'],
X_trn['cont10_class'],
X_trn['cont11_class'],
X_trn['cont12_class'],
X_trn['cont13_class'],
X_trn['cont14_class'],
X_trn[sparse_feature_columns]],
y_trn,
validation_data=([X_val[self.predictors[:14]],
X_val['cont1_class'],
X_val['cont2_class'],
X_val['cont3_class'],
X_val['cont4_class'],
X_val['cont5_class'],
X_val['cont6_class'],
X_val['cont7_class'],
X_val['cont8_class'],
X_val['cont9_class'],
X_val['cont10_class'],
X_val['cont11_class'],
X_val['cont12_class'],
X_val['cont13_class'],
X_val['cont14_class'],
X_val[sparse_feature_columns]],
y_val),
epochs=self.model_parameters['epochs'],
batch_size=self.model_parameters['batch_size'],
callbacks=[reduce_lr, early_stopping],
verbose=True)
val_predictions = model.predict([X_val[self.predictors[:14]],
X_val['cont1_class'],
X_val['cont2_class'],
X_val['cont3_class'],
X_val['cont4_class'],
X_val['cont5_class'],
X_val['cont6_class'],
X_val['cont7_class'],
X_val['cont8_class'],
X_val['cont9_class'],
X_val['cont10_class'],
X_val['cont11_class'],
X_val['cont12_class'],
X_val['cont13_class'],
X_val['cont14_class'],
X_val[sparse_feature_columns]])
seed_avg_oof_predictions[val_idx] +=(val_predictions.flatten() / len(self.seeds))
test_predictions = model.predict([X_test[self.predictors[:14]],
X_test['cont1_class'],
X_test['cont2_class'],
X_test['cont3_class'],
X_test['cont4_class'],
X_test['cont5_class'],
X_test['cont6_class'],
X_test['cont7_class'],
X_test['cont8_class'],
X_test['cont9_class'],
X_test['cont10_class'],
X_test['cont11_class'],
X_test['cont12_class'],
X_test['cont13_class'],
X_test['cont14_class'],
X_test[sparse_feature_columns]])
seed_avg_test_predictions +=(test_predictions.flatten() / X_train['fold'].nunique() / len(self.seeds))
model_histories.append(history)
fold_score = mean_squared_error(df_train_processed.loc[val_idx, self.target], val_predictions, squared=False)
print(f'
TMLP Fold {int(fold)} - X_trn: {X_train.loc[trn_idx, self.predictors].shape} X_val: {X_train.loc[val_idx, self.predictors].shape} - Score: {fold_score:.6} - Seed: {seed}
')
all_model_histories[seed] = model_histories
df_train_processed['TMLPPredictions'] = seed_avg_oof_predictions
df_test_processed['TMLPPredictions'] = seed_avg_test_predictions
oof_score = mean_squared_error(y_train, df_train_processed['TMLPPredictions'], squared=False)
print(f'{"-" * 30}
TMLP OOF RMSE: {oof_score:.6}({len(self.seeds)} Seed Average)
{"-" * 30}')
self._plot_learning_curve(all_model_histories)
self._plot_predictions(df_train_processed[target], df_train_processed['TMLPPredictions'], df_test_processed['TMLPPredictions'])
def train_and_predict_rmlp(self, X_train, y_train, X_test):
all_model_histories = {}
seed_avg_oof_predictions = np.zeros(X_train.shape[0])
seed_avg_test_predictions = np.zeros(X_test.shape[0])
oof_predictions = np.zeros(X_train.shape[0])
test_predictions = np.zeros(X_test.shape[0])
for seed in self.seeds:
print(f'{"-" * 30}
Running RMLP model with seed: {seed}
{"-" * 30}
')
self._set_seed(seed)
model_histories = []
for fold in sorted(X_train['fold'].unique()):
trn_idx, val_idx = X_train.loc[X_train['fold'] != fold].index, X_train.loc[X_train['fold'] == fold].index
X_trn, y_trn = X_train.loc[trn_idx, self.predictors], y_train.loc[trn_idx]
X_val, y_val = X_train.loc[val_idx, self.predictors], y_train.loc[val_idx]
model = self._get_rmlp(input_shape=X_trn.shape[1], output_shape=1)
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=self.model_parameters['reduce_lr_factor'],
patience=self.model_parameters['reduce_lr_patience'],
min_lr=self.model_parameters['reduce_lr_min'],
mode='min',
verbose=True)
early_stopping = EarlyStopping(monitor='val_loss',
mode='min',
min_delta=self.model_parameters['early_stopping_min_delta'],
patience=self.model_parameters['early_stopping_patience'],
restore_best_weights=True,
verbose=True)
history = model.fit(X_trn, y_trn,
validation_data=(X_val, y_val),
epochs=self.model_parameters['epochs'],
batch_size=self.model_parameters['batch_size'],
callbacks=[reduce_lr, early_stopping],
verbose=True)
val_predictions = model.predict(X_val)
seed_avg_oof_predictions[val_idx] +=(val_predictions.flatten() / len(self.seeds))
test_predictions = model.predict(X_test)
seed_avg_test_predictions +=(test_predictions.flatten() / X_train['fold'].nunique() / len(self.seeds))
model_histories.append(history)
fold_score = mean_squared_error(df_train_processed.loc[val_idx, self.target], val_predictions.flatten() , squared=False)
print(f'
RMLP Fold {int(fold)} - X_trn: {X_train.loc[trn_idx, self.predictors].shape} X_val: {X_train.loc[val_idx, self.predictors].shape} - Score: {fold_score:.6} - Seed: {seed}
')
all_model_histories[seed] = model_histories
df_train_processed['RMLPPredictions'] = seed_avg_oof_predictions
df_test_processed['RMLPPredictions'] = seed_avg_test_predictions
oof_score = mean_squared_error(y_train, df_train_processed['RMLPPredictions'], squared=False)
print(f'{"-" * 30}
RMLP OOF RMSE: {oof_score:.6}({len(self.seeds)} Seed Average)
{"-" * 30}')
self._plot_learning_curve(all_model_histories)
self._plot_predictions(df_train_processed[target], df_train_processed['RMLPPredictions'], df_test_processed['RMLPPredictions'])
def _plot_learning_curve(self, all_model_histories):
n_folds = 5
fig, axes = plt.subplots(nrows=n_folds, figsize=(32, 50), dpi=100)
for i in range(n_folds):
for seed, histories in all_model_histories.items() :
axes[i].plot(np.arange(1, len(histories[i].history['loss'])+ 1), histories[i].history['loss'], label=f'train_loss(Seed: {seed})', alpha=0.5)
axes[i].plot(np.arange(1, len(histories[i].history['val_loss'])+ 1), histories[i].history['val_loss'], label=f'val_loss(Seed: {seed})', alpha=0.5)
axes[i].set_xlabel('Epochs', size=20)
axes[i].set_ylabel('RMSE', size=20)
axes[i].set_yscale('log')
axes[i].tick_params(axis='x', labelsize=20)
axes[i].tick_params(axis='y', labelsize=20)
axes[i].legend(prop={'size': 20})
axes[i].set_title(f'Fold {i + 1} Learning Curve', fontsize=20, pad=10)
plt.show()
def _plot_predictions(self, train_labels, train_predictions, test_predictions):
fig, axes = plt.subplots(ncols=2, figsize=(25, 6))
sns.scatterplot(train_labels, train_predictions, ax=axes[0])
sns.distplot(train_predictions, label='Train Predictions', ax=axes[1])
sns.distplot(test_predictions, label='Test Predictions', ax=axes[1])
axes[0].set_xlabel(f'Train Labels', size=18)
axes[0].set_ylabel(f'Train Predictions', size=18)
axes[1].set_xlabel('')
axes[1].legend(prop={'size': 18})
for i in range(2):
axes[i].tick_params(axis='x', labelsize=15)
axes[i].tick_params(axis='y', labelsize=15)
axes[0].set_title(f'Train Labels vs Train Predictions', size=20, pad=20)
axes[1].set_title(f'Predictions Distributions', size=20, pad=20)
plt.show()
| Tabular Playground Series - Jan 2021 |
13,952,385 | data_augmentation_layers = tf.keras.Sequential(
[
layers.experimental.preprocessing.RandomCrop(height=image_size, width=image_size),
layers.experimental.preprocessing.RandomFlip("horizontal_and_vertical"),
layers.experimental.preprocessing.RandomRotation(0.25),
layers.experimental.preprocessing.RandomZoom(( -0.2, 0)) ,
layers.experimental.preprocessing.RandomContrast(( 0.2,0.2)) ,
brighten() ,
saturate() ,
]
)<train_model> | TRAIN_TMLP = False
if TRAIN_TMLP:
model = 'TMLP'
tmlp_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=StandardScaler,
create_features=False, discretize_features=True)
df_train_tmlp, df_test_tmlp = tmlp_preprocessor.transform()
print(f'
{model} Training Set Shape = {df_train_tmlp.shape}')
print(f'{model} Training Set Memory Usage = {df_train_tmlp.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'{model} Test Set Shape = {df_test_tmlp.shape}')
print(f'{model} Test Set Memory Usage = {df_test_tmlp.memory_usage().sum() / 1024 ** 2:.2f} MB
')
X_train_tmlp = df_train_tmlp[continuous_features + ['fold'] + [f'{cont}_class' for cont in continuous_features]].copy(deep=True)
y_train_tmlp = df_train_tmlp[target].copy(deep=True)
X_test_tmlp = df_test_tmlp[continuous_features + [f'{cont}_class' for cont in continuous_features]].copy(deep=True)
tmlp_parameters = {
'predictors': continuous_features + [f'{cont}_class' for cont in continuous_features],
'target': target,
'model': model,
'model_parameters': {
'learning_rate': 0.0009,
'weight_decay': 0.000001,
'epochs': 150,
'batch_size': 2 ** 10,
'reduce_lr_factor': 0.8,
'reduce_lr_patience': 5,
'reduce_lr_min': 0.000001,
'early_stopping_min_delta': 0.0001,
'early_stopping_patience': 15
},
'seeds': [541992]
}
tmlp_model = NeuralNetworks(**tmlp_parameters)
tmlp_model.train_and_predict_tmlp(X_train_tmlp, y_train_tmlp, X_test_tmlp)
del df_train_tmlp, df_test_tmlp, X_train_tmlp, y_train_tmlp, X_test_tmlp
del tmlp_preprocessor, tmlp_parameters, tmlp_model
print('Saving TMLP OOF and Test predictions to current working directory.')
df_train_processed[['id', 'TMLPPredictions']].to_csv('tmlp_oof_predictions.csv', index=False)
df_test_processed[['id', 'TMLPPredictions']].to_csv('tmlp_test_predictions.csv', index=False)
else:
print('Loading TMLP OOF and Test predictions from current working directory.')
df_train_processed['TMLPPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/tmlp_oof_predictions.csv')['MLPPredictions']
df_test_processed['TMLPPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/tmlp_test_predictions.csv')['MLPPredictions']
oof_score = mean_squared_error(df_train_processed['target'], df_train_processed['TMLPPredictions'], squared=False)
print(f'TMLP OOF RMSE: {oof_score:.6}')
NeuralNetworks._plot_predictions(None, df_train_processed[target], df_train_processed['TMLPPredictions'], df_test_processed['TMLPPredictions'])
| Tabular Playground Series - Jan 2021 |
13,952,385 | image = Image.open(".. /input/cassava-leaf-disease-classification/train_images/1481899695.jpg")
plt.imshow(image)
plt.show()<concatenate> | TRAIN_RMLP = False
if TRAIN_RMLP:
model = 'RMLP'
rmlp_preprocessor = Preprocessor(train=df_train, test=df_test,
n_splits=5, shuffle=True, random_state=cross_validation_seed, scaler=StandardScaler,
create_features=False, discretize_features=False)
df_train_rmlp, df_test_rmlp = rmlp_preprocessor.transform()
for feature in continuous_features:
df_train_rmlp[f'{feature}_square'] = df_train_rmlp[feature] ** 2
df_test_rmlp[f'{feature}_square'] = df_test_rmlp[feature] ** 2
print(f'
{model} Training Set Shape = {df_train_rmlp.shape}')
print(f'{model} Training Set Memory Usage = {df_train_rmlp.memory_usage().sum() / 1024 ** 2:.2f} MB')
print(f'{model} Test Set Shape = {df_test_rmlp.shape}')
print(f'{model} Test Set Memory Usage = {df_test_rmlp.memory_usage().sum() / 1024 ** 2:.2f} MB
')
X_train_rmlp = df_train_rmlp[continuous_features + ['fold'] + [f'{feat}_square' for feat in continuous_features]].copy(deep=True)
y_train_rmlp = df_train_rmlp[target].copy(deep=True)
X_test_rmlp = df_test_rmlp[continuous_features + [f'{feat}_square' for feat in continuous_features]].copy(deep=True)
rmlp_parameters = {
'predictors': continuous_features + [f'{feat}_square' for feat in continuous_features],
'target': target,
'model': model,
'model_parameters': {
'learning_rate': 0.01,
'epochs': 150,
'batch_size': 2 ** 10,
'reduce_lr_factor': 0.8,
'reduce_lr_patience': 5,
'reduce_lr_min': 0.000001,
'early_stopping_min_delta': 0.0001,
'early_stopping_patience': 15
},
'seeds': [541992, 721991, 1337, 42, 0]
}
rmlp_model = NeuralNetworks(**rmlp_parameters)
rmlp_model.train_and_predict_rmlp(X_train_rmlp, y_train_rmlp, X_test_rmlp)
del df_train_rmlp, df_test_rmlp, X_train_rmlp, y_train_rmlp, X_test_rmlp
del rmlp_preprocessor, rmlp_parameters, rmlp_model
print('Saving RMLP OOF and Test predictions to current working directory.')
df_train_processed[['id', 'RMLPPredictions']].to_csv('rmlp_oof_predictions.csv', index=False)
df_test_processed[['id', 'RMLPPredictions']].to_csv('rmlp_test_predictions.csv', index=False)
else:
print('Loading RMLP OOF and Test predictions from current working directory.')
df_train_processed['RMLPPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/rmlp_oof_predictions.csv')['RMLPPredictions']
df_test_processed['RMLPPredictions'] = pd.read_csv('.. /input/tabular-playground-series/Tabular Playground Series - Jan 2021/rmlp_test_predictions.csv')['RMLPPredictions']
oof_score = mean_squared_error(df_train_processed['target'], df_train_processed['RMLPPredictions'], squared=False)
print(f'RMLP OOF RMSE: {oof_score:.6}')
NeuralNetworks._plot_predictions(None, df_train_processed[target], df_train_processed['RMLPPredictions'], df_test_processed['RMLPPredictions'])
| Tabular Playground Series - Jan 2021 |
13,952,385 | image = tf.expand_dims(np.array(image), 0 )<normalization> | class SubmissionPipeline:
def __init__(self, train, test, blend, prediction_columns, add_public_best):
self.train = train
self.test = test
self.blend = blend
self.prediction_columns = prediction_columns
self.add_public_best = add_public_best
def weighted_average(self):
self.train['FinalPredictions'] =(0.77 * self.train['LGBPredictions'])+\
(0.04 * self.train['CBPredictions'])+\
(0.06 * self.train['XGBPredictions'])+\
(0.0 * self.train['RFPredictions'])+\
(0.0 * self.train['RRPredictions'])+\
(0.0 * self.train['SVMPredictions'])+\
(0.12 * self.train['TMLPPredictions'])+\
(0.01 * self.train['RMLPPredictions'])
self.test['FinalPredictions'] =(0.77 * self.test['LGBPredictions'])+\
(0.04 * self.test['CBPredictions'])+\
(0.06 * self.test['XGBPredictions'])+\
(0.0 * self.test['RFPredictions'])+\
(0.0 * self.test['RRPredictions'])+\
(0.0 * self.test['SVMPredictions'])+\
(0.12 * self.test['TMLPPredictions'])+\
(0.01 * self.test['RMLPPredictions'])
def geometric_average(self):
self.train['FinalPredictions'] = gmean(self.train[self.prediction_columns], axis=1)
self.test['FinalPredictions'] = gmean(self.test[self.prediction_columns], axis=1)
def weighted_average_public(self):
public_best = pd.read_csv('.. /input/h2o-machine-learning/submission.csv')
self.test['FinalPredictions'] =(self.test['FinalPredictions'] * 0.02)+(public_best['target'] * 0.98)
def transform(self):
if self.blend == 'weighted_average':
self.weighted_average()
elif self.blend == 'geometric_average':
self.geometric_average()
for prediction_column in prediction_columns:
oof_score = mean_squared_error(self.train[target], df_train_processed[prediction_column], squared=False)
print(f'{prediction_column.split("Predictions")[0]} OOF RMSE: {oof_score:.6}')
final_oof_score = mean_squared_error(self.train[target], df_train_processed['FinalPredictions'], squared=False)
print(f'{"-" * 30}
Final OOF RMSE: {final_oof_score:.6}
{"-" * 30}')
if self.add_public_best:
self.weighted_average_public()
return self.train[['id'] + self.prediction_columns + ['FinalPredictions']].copy(deep=True), self.test[['id'] + self.prediction_columns + ['FinalPredictions']].copy(deep=True)
submission_pipeline = SubmissionPipeline(train=df_train_processed, test=df_test_processed,
blend='weighted_average', prediction_columns=prediction_columns, add_public_best=True)
df_train_submission, df_test_submission = submission_pipeline.transform() | Tabular Playground Series - Jan 2021 |
13,952,385 | <choose_model_class><EOS> | df_test_processed['target'] = df_test_submission['FinalPredictions']
df_test_processed[['id', 'target']].to_csv('submission.csv', index=False)
df_test_processed[['id', 'target']].describe() | Tabular Playground Series - Jan 2021 |
14,517,964 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<load_pretrained> | plt.style.use('fivethirtyeight')
y_ = Fore.YELLOW
r_ = Fore.RED
g_ = Fore.GREEN
b_ = Fore.BLUE
m_ = Fore.MAGENTA
c_ = Fore.CYAN
sr_ = Style.RESET_ALL
warnings.filterwarnings('ignore')
| Tabular Playground Series - Jan 2021 |
14,517,964 | %%time
model.get_layer('efficientnetb4' ).get_layer('normalization' ).adapt(adapt_data_batches )<compute_train_metric> | path = '.. /input/tabular-playground-series-jan-2021/'
train_data = pd.read_csv(path + 'train.csv')
test_data = pd.read_csv(path + 'test.csv')
sample = pd.read_csv(path + 'sample_submission.csv' ) | Tabular Playground Series - Jan 2021 |
14,517,964 | def log_t(u, t):
epsilon = 1e-7
if t == 1.0:
return tf.math.log(u + epsilon)
else:
return(u**(1.0 - t)- 1.0)/(1.0 - t)
def bi_tempered_logistic_loss(y_pred, y_true, t1, label_smoothing=0.0):
y_pred = tf.cast(y_pred, tf.float32)
y_true = tf.cast(y_true, tf.float32)
if label_smoothing > 0.0:
num_classes = tf.cast(tf.shape(y_true)[-1], tf.float32)
y_true =(1 - num_classes /(num_classes - 1)* label_smoothing)* y_true + label_smoothing /(num_classes - 1)
temp1 =(log_t(y_true + 1e-7, t1)- log_t(y_pred, t1)) * y_true
temp2 =(1 /(2 - t1)) *(tf.math.pow(y_true, 2 - t1)- tf.math.pow(y_pred, 2 - t1))
loss_values = temp1 - temp2
return tf.math.reduce_sum(loss_values, -1)
class BiTemperedLogisticLoss(tf.keras.losses.Loss):
def __init__(self, t1=0.8, label_smoothing=0.2):
super(BiTemperedLogisticLoss, self ).__init__()
self.t1 = t1
self.label_smoothing = label_smoothing
def call(self, y_true, y_pred):
return bi_tempered_logistic_loss(y_pred, y_true, self.t1, self.label_smoothing )<choose_model_class> | train_data['cont13_cont4_mul'] = train_data['cont13']*train_data['cont4']
train_data['cont13_cont11_mul'] = train_data['cont13']*train_data['cont11']
train_data['cont13_cont7_mul'] = train_data['cont13']*train_data['cont7']
train_data['cont13_cont2_mul'] = train_data['cont13']*train_data['cont2']
train_data['cont13_cont10_mul'] = train_data['cont13']*train_data['cont10']
test_data['cont13_cont4_mul'] = test_data['cont13']*test_data['cont4']
test_data['cont13_cont11_mul'] = test_data['cont13']*test_data['cont11']
test_data['cont13_cont7_mul'] = test_data['cont13']*test_data['cont7']
test_data['cont13_cont2_mul'] = test_data['cont13']*test_data['cont2']
test_data['cont13_cont10_mul'] = test_data['cont13']*test_data['cont10'] | Tabular Playground Series - Jan 2021 |
14,517,964 | epochs = 8
decay_steps = int(round(len(X_train)/batch_size)) *epochs
cosine_decay = CosineDecay(initial_learning_rate=1e-5, decay_steps=decay_steps, alpha=0.3)
callbacks = [ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True)]
loss = BiTemperedLogisticLoss()
model.compile(loss=loss, optimizer=tf.keras.optimizers.Adam(cosine_decay), metrics=["accuracy"] )<train_model> | num_bins = int(1 + np.log2(len(train_data)))
train_data.loc[:,'bins'] = pd.cut(train_data['target'].to_numpy() ,bins=num_bins,labels=False)
features = [f'cont{x}' for x in range(1,15)]
features += [
'cont13_cont4_mul',
'cont13_cont11_mul',
'cont13_cont7_mul',
'cont13_cont2_mul',
'cont13_cont10_mul',
]
target_feature = 'target'
train_data = train_data.query('target >=5')
bins = train_data['bins'].to_numpy()
target = train_data[target_feature].to_numpy()
train_data = train_data[features].to_numpy()
test_data = test_data[features].to_numpy()
scaler = PowerTransformer()
train_data = scaler.fit_transform(train_data)
test_data = scaler.transform(test_data ) | Tabular Playground Series - Jan 2021 |
14,517,964 | history = model.fit(training_data_batches,
epochs = epochs,
validation_data = validation_data_batches,
callbacks = callbacks )<load_pretrained> | def rmse_score(y_true, y_pred):
return np.sqrt(mean_squared_error(y_true, y_pred)) | Tabular Playground Series - Jan 2021 |
14,517,964 | model.load_weights("best_model.h5" )<predict_on_test> | nfolds = 5
seed = 42
lgb_params={'objective':'regression',
'metrics':'rmse',
'boosting':'gbdt',
'min_data_per_group': 5,
'num_leaves': 256,
'max_depth': -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,
'verbose':-1,
'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}
xgb_params = {'lambda': 0.0030282073258141168,
'alpha': 0.01563845128469084,
'colsample_bytree': 0.55,
'subsample': 0.7,
'learning_rate': 0.01,
'max_depth': 15,
'random_state': 2020,
'min_child_weight': 257,
}
cat_params = {'iterations': 4000,
'depth': 7,
'verbose':200,
'learning_rate': 0.03618554870098452,
'random_strength': 29,
'bagging_temperature': 0.5528282676740153,
'od_type': 'IncToDec',
'early_stopping_rounds':100,
'random_state': seed
}
lgb_final_params={'objective':'regression',
'metrics':'rmse',
'num_leaves' : 287,
'max_bin' : 817,
'learning_rate' : 0.017005497730644668,
'max_depth' : 5,
'min_child_weight' : 5,
'feature_fraction' : 0.40159350277696726,
'bagging_fraction' : 0.780876382367899,
'bagging_freq' : 8,
'min_child_samples' : 56,
'lambda_l1' : 0.011468211453769755,
'lambda_l2' : 0.00026850241464538264,
'boosting':'gbdt',
'verbose':-1} | Tabular Playground Series - Jan 2021 |
14,517,964 | def run_predictions_over_image_list(image_list, folder):
predictions = []
with tqdm(total=len(image_list)) as pbar:
for image_filename in image_list:
pbar.update(1)
predictions.append(predict_and_vote(image_filename, folder))
return predictions<predict_on_test> | final_preds = np.zeros(test_data.shape[0])
kfold = StratifiedKFold(n_splits=nfolds,random_state=seed)
for f,(train_idx, valid_idx)in enumerate(kfold.split(X=train_data,y=bins)) :
print(f"Fold: {f}")
X_train, X_valid, y_train, y_valid = train_data[train_idx],train_data[valid_idx],target[train_idx],target[valid_idx]
print(f"{r_}LGBM TRAIN{sr_}")
lgb_train = lgb.Dataset(X_train,y_train)
lgb_valid = lgb.Dataset(X_valid,y_valid,reference=lgb_train)
lgb_model = lgb.train(lgb_params,
lgb_train,
valid_sets=[lgb_train,lgb_valid],
num_boost_round=10000,
verbose_eval=200,
early_stopping_rounds=100,
)
print(f"{g_}XGB TRAIN{sr_}")
xgb_train = xgb.DMatrix(X_train,label=y_train)
xgb_valid = xgb.DMatrix(X_valid,label=y_valid)
xgb_model = xgb.train(xgb_params,
xgb_train,
10000,
verbose_eval=200,
evals=[(xgb_train,'train'),(xgb_valid,'valid')],
early_stopping_rounds=100)
print(f"{y_}CAT TRAIN{sr_}")
cat_train = Pool(X_train,y_train)
cat_valid = Pool(X_valid,y_valid)
cat_model = CatBoost(cat_params)
cat_model.fit(cat_train,eval_set=cat_valid)
print("STACKING")
final_train = np.column_stack([lgb_model.predict(X_train),xgb_model.predict(xgb.DMatrix(X_train)) ,cat_model.predict(X_train)])
final_valid = np.column_stack([lgb_model.predict(X_valid),xgb_model.predict(xgb.DMatrix(X_valid)) ,cat_model.predict(X_valid)])
final_test = np.column_stack([lgb_model.predict(test_data),xgb_model.predict(xgb.DMatrix(test_data)) ,cat_model.predict(test_data)])
print(f"{b_}FINAL TRAINING{sr_}")
lgb_train = lgb.Dataset(final_train,y_train)
lgb_valid = lgb.Dataset(final_valid,y_valid)
lgb_final = lgb.train(lgb_final_params, lgb_train, valid_sets=[lgb_train,lgb_valid],early_stopping_rounds=100,
verbose_eval=200, num_boost_round=1000)
final_preds += lgb_final.predict(final_test)/nfolds | Tabular Playground Series - Jan 2021 |
14,517,964 | <define_variables><EOS> | sample.target = final_preds.ravel()
sample.to_csv("submission.csv",index=False)
sample.head() | Tabular Playground Series - Jan 2021 |
14,591,678 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<feature_engineering> | !pip install --upgrade xgboost
xgb.__version__ | Tabular Playground Series - Jan 2021 |
14,591,678 | test_folder = '.. /input/cassava-leaf-disease-classification/test_images/'
submission_df = pd.DataFrame(columns={"image_id","label"})
submission_df["image_id"] = os.listdir(test_folder)
submission_df["label"] = 0<predict_on_test> | sub = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/sample_submission.csv")
data = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/train.csv")
final_test = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/test.csv" ) | Tabular Playground Series - Jan 2021 |
14,591,678 | submission_df["label"] = run_predictions_over_image_list(submission_df["image_id"], test_folder )<save_to_csv> | print('Training Data')
print(data.isnull().sum())
print()
print()
print('Testing Data')
print(final_test.isnull().sum() ) | Tabular Playground Series - Jan 2021 |
14,591,678 | submission_df.to_csv("submission.csv", index=False )<define_variables> | columns = final_test.columns[1:]
train = data[columns]
target = data['target'] | Tabular Playground Series - Jan 2021 |
14,591,678 | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
<import_modules> | x_train, x_test, y_train, y_test =train_test_split(
train, target, random_state= 2021, test_size = 0.20)
xgb_initial = xgb.XGBRegressor()
xgb_initial.fit(x_train, y_train)
initial_preds = xgb_initial.predict(x_test ) | Tabular Playground Series - Jan 2021 |
14,591,678 | from datetime import datetime
from glob import glob
from scipy.ndimage.interpolation import zoom
from scipy.special import softmax
from skimage import io
from sklearn import metrics
from sklearn.metrics import log_loss
from sklearn.metrics import roc_auc_score, log_loss
from sklearn.model_selection import GroupKFold, StratifiedKFold
from torch import nn
from torch.cuda.amp import autocast, GradScaler
from torch.utils.data import Dataset, DataLoader
from torch.utils.data.sampler import SequentialSampler, RandomSampler
from torchvision import transforms
from tqdm import tqdm
import copy
import cv2
import joblib
import matplotlib.pyplot as plt
import numpy as np
import os
import pandas as pd
import pydicom
import random
import sklearn
import time
import timm
import torch
import torchvision
import warnings<init_hyperparams> | mean_squared_error(y_test, initial_preds, squared=False)
| Tabular Playground Series - Jan 2021 |
14,591,678 | CFG = {
'fold_num': 7,
'seed': 719,
'model_arch': 'tf_efficientnet_b3_ns',
'img_size': 512,
'epochs': 32,
'train_bs': 32,
'valid_bs': 32,
'lr': 1e-4,
'num_workers': 4,
'accum_iter': 1,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 8
}<load_from_csv> | def objective(trial, X_data = train, Y_data = target):
x_train, x_test, y_train, y_test = train_test_split(
X_data, Y_data, random_state= 2021, test_size = 0.20)
param = {
'tree_method':'gpu_hist',
'predictor': 'gpu_predictor',
'learning_rate': trial.suggest_discrete_uniform('learning_rate',0.01,0.50,0.05),
'colsample_bylevel': trial.suggest_discrete_uniform('colsample_bylevel',0.01,0.91, 0.1),
'colsample_bynode': trial.suggest_discrete_uniform('colsample_bytree',0.01,0.91, 0.1),
'colsample_bytree': trial.suggest_discrete_uniform('colsample_bytree',0.01,0.91, 0.1),
'max_depth': trial.suggest_int('max_depth', 1,10),
'subsample': trial.suggest_discrete_uniform('subsample', 0.20,1, 0.05),
'n_estimators': trial.suggest_categorical('n_estimators',[4000,5000,6000,7000]),
'min_child_weight': trial.suggest_int('min_child_weight', 1,401,step=2),
'lambda': trial.suggest_loguniform('lambda', 1e-8, 10.0),
'alpha': trial.suggest_loguniform('alpha', 1e-8, 10.0),
'random_state': trial.suggest_categorical('random_state',[2000,3000,4000]),
'gamma': trial.suggest_discrete_uniform('gamma',0.01,2.01, 0.1)
}
model = xgb.XGBRegressor(**param)
model.fit(x_train,y_train,eval_set=[(x_train,y_train)],early_stopping_rounds=100,verbose=False)
preds = model.predict(x_test)
rmse = mean_squared_error(y_test, preds,squared=False)
return rmse
| Tabular Playground Series - Jan 2021 |
14,591,678 | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head()<count_values> | study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials= 100 ) | Tabular Playground Series - Jan 2021 |
14,591,678 | train.label.value_counts()<load_from_csv> | print('Number of finished trials:', len(study.trials))
print('Best trial:', study.best_trial.params)
print('Best objective value:', study.best_value)
| Tabular Playground Series - Jan 2021 |
14,591,678 | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head()<set_options> | best_trial = study.best_trial.params
best_trial['tree_method'] = 'gpu_hist'
best_trial['predictor'] = 'gpu_predictor' | Tabular Playground Series - Jan 2021 |
14,591,678 | def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
def get_img(path):
im_bgr = cv2.imread(path)
im_rgb = im_bgr[:, :, ::-1]
return im_rgb
img = get_img('.. /input/cassava-leaf-disease-classification/train_images/1000015157.jpg')
plt.imshow(img)
plt.show()<categorify> | best_trial= {'learning_rate': 0.01,
'colsample_bylevel': 0.6100000000000001,
'colsample_bytree': 0.91,
'max_depth': 10,
'subsample': 0.8,
'min_child_weight': 67,
'lambda': 0.012157425362490908,
'alpha': 7.278941365308569e-08,
'random_state': 3000,
'gamma': 1,
'tree_method': 'gpu_hist',
'predictor': 'gpu_predictor'}
| Tabular Playground Series - Jan 2021 |
14,591,678 | class CassavaDataset(Dataset):
def __init__(
self, df, data_root, transforms=None, output_label=True
):
super().__init__()
self.df = df.reset_index(drop=True ).copy()
self.transforms = transforms
self.data_root = data_root
self.output_label = output_label
def __len__(self):
return self.df.shape[0]
def __getitem__(self, index: int):
if self.output_label:
target = self.df.iloc[index]['label']
path = "{}/{}".format(self.data_root, self.df.iloc[index]['image_id'])
img = get_img(path)
if self.transforms:
img = self.transforms(image=img)['image']
if self.output_label == True:
return img, target
else:
return img<set_options> | final_test = xgb.DMatrix(final_test[columns] ) | Tabular Playground Series - Jan 2021 |
14,591,678 | 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_inference_transforms() :
return Compose([
RandomResizedCrop(CFG['img_size'], CFG['img_size']),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(
shift_limit=0.025,
scale_limit=0.05,
rotate_limit=20,
p=0.5
),
HueSaturationValue(
hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.5
),
RandomBrightnessContrast(
brightness_limit=(-0.1,0.1),
contrast_limit=(-0.1, 0.1),
p=0.5
),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0
),
ToTensorV2(p=1.0)
], p=1.)<choose_model_class> | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape | Tabular Playground Series - Jan 2021 |
14,591,678 | class CassvaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, n_class)
def forward(self, x):
x = self.model(x)
return x<define_variables> | NUM_FOLDS=10
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
fold_rmse =[]
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.DMatrix(train_df, label=train_target)
val_df = xgb.DMatrix(val_df, label=val_target)
model = xgb.train(best_trial, train_df, 2000)
temp_oof = model.predict(val_df)
temp_test = model.predict(final_test)
train_oof[val_ind] = temp_oof
test_preds += temp_test/NUM_FOLDS
rmse_iter = mean_squared_error(temp_oof, val_target, squared=False)
print(rmse_iter)
fold_rmse.append(rmse_iter ) | Tabular Playground Series - Jan 2021 |
14,591,678 | model_path = [
".. /input/cassava-10-fold-label-smoothing-02/cassava_model_10_fold_labelsmoothing_0.2_small/tf_efficientnet_b3_ns_fold_0_5",
".. /input/cassava-10-fold-label-smoothing-02/cassava_model_10_fold_labelsmoothing_0.2_small/tf_efficientnet_b3_ns_fold_1_9",
".. /input/cassava-10-fold-label-smoothing-02/cassava_model_10_fold_labelsmoothing_0.2_small/tf_efficientnet_b3_ns_fold_2_9",
".. /input/cassava-10-fold-label-smoothing-02/cassava_model_10_fold_labelsmoothing_0.2_small/tf_efficientnet_b3_ns_fold_3_4",
".. /input/cassava-10-fold-label-smoothing-02/cassava_model_10_fold_labelsmoothing_0.2_small/tf_efficientnet_b3_ns_fold_4_3",
".. /input/cassava-10-fold-label-smoothing-02/cassava_model_10_fold_labelsmoothing_0.2_small/tf_efficientnet_b3_ns_fold_7_9",
".. /input/cassava-10-fold-label-smoothing-02/cassava_model_10_fold_labelsmoothing_0.2_small/tf_efficientnet_b3_ns_fold_8_8",
]<create_dataframe> | sub['target'] = test_preds
sub.to_csv('submission2_post_competition.csv', index=False ) | Tabular Playground Series - Jan 2021 |
14,591,678 | if __name__ == '__main__':
seed_everything(CFG['seed'])
tst_preds_all_folds = []
for fold in range(CFG['fold_num']):
test = pd.DataFrame()
test['image_id'] = sorted(list(
os.listdir('.. /input/cassava-leaf-disease-classification/test_images/')
))
test_ds = CassavaDataset(
test,
'.. /input/cassava-leaf-disease-classification/test_images/',
transforms=get_inference_transforms() ,
output_label=False
)
tst_loader = torch.utils.data.DataLoader(
test_ds,
batch_size=CFG['valid_bs'],
num_workers=CFG['num_workers'],
shuffle=False,
pin_memory=False,
)
device = torch.device(CFG['device'])
model = CassvaImgClassifier(CFG['model_arch'], train.label.nunique() ).to(device)
tst_preds = []
model.load_state_dict(torch.load(model_path[fold]))
with torch.no_grad() :
for _ in range(CFG['tta']):
tst_preds += [
inference_one_epoch(model, tst_loader, device)
]
tst_preds = np.mean(tst_preds, axis=0)
tst_preds_all_folds.append(tst_preds)
del model
torch.cuda.empty_cache()<drop_column> | def objective_2(trial, X_data = train, Y_data = target):
x_train, x_test, y_train, y_test = train_test_split(
X_data, Y_data, random_state= 2021, test_size = 0.20)
param = {
'tree_method':'gpu_hist',
'predictor': 'gpu_predictor',
'learning_rate': 0.01,
'colsample_bylevel': trial.suggest_discrete_uniform('colsample_bylevel',0.01,0.91, 0.1),
'colsample_bynode': trial.suggest_discrete_uniform('colsample_bytree',0.01,0.91, 0.1),
'colsample_bytree': trial.suggest_discrete_uniform('colsample_bytree',0.01,0.91, 0.1),
'max_depth': trial.suggest_int('max_depth', 1,10),
'subsample': trial.suggest_discrete_uniform('subsample', 0.20,1, 0.05),
'n_estimators': trial.suggest_categorical('n_estimators',[4000,5000,6000,7000]),
'min_child_weight': trial.suggest_int('min_child_weight', 1,401,step=2),
'lambda': trial.suggest_loguniform('lambda', 1e-8, 10.0),
'alpha': trial.suggest_loguniform('alpha', 1e-8, 10.0),
'random_state': trial.suggest_categorical('random_state',[2000,3000,4000]),
'gamma': trial.suggest_discrete_uniform('gamma',0.01,2.01, 0.1)
}
model = xgb.XGBRegressor(**param)
model.fit(x_train,y_train,eval_set=[(x_train,y_train)],early_stopping_rounds=100,verbose=False)
preds = model.predict(x_test)
rmse = mean_squared_error(y_test, preds,squared=False)
return rmse
| Tabular Playground Series - Jan 2021 |
14,591,678 | variable_list = %who_ls
for _ in variable_list:
if _ is not "tst_preds_all_folds":
del globals() [_]
%who_ls<import_modules> | study_2 = optuna.create_study(direction='minimize')
study_2.optimize(objective_2, n_trials= 100 ) | Tabular Playground Series - Jan 2021 |
14,591,678 | sys.path.append('.. /input/pytorch-image-models/pytorch-image-models-master')
warnings.filterwarnings('ignore')
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu' )<define_variables> | print('Number of finished trials:', len(study_2.trials))
print('Best trial:', study_2.best_trial.params)
print('Best objective value:', study_2.best_value)
| Tabular Playground Series - Jan 2021 |
14,591,678 | OUTPUT_DIR = './'
MODEL_DIR = '.. /input/cassava-resnext/'
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
TEST_PATH = '.. /input/cassava-leaf-disease-classification/test_images'<init_hyperparams> | best_trial_2 = study_2.best_trial.params
best_trial_2['tree_method'] = 'gpu_hist'
best_trial_2['predictor'] = 'gpu_predictor'
best_trial_2['learning_rate'] = 0.01 | Tabular Playground Series - Jan 2021 |
14,591,678 | class CFG:
debug=False
num_workers=8
model_name='resnext50_32x4d'
size=512
batch_size=32
seed=2020
target_size=5
target_col='label'
n_fold=5
trn_fold=[0, 1, 2, 3, 4]
inference=True
tta=8<load_from_csv> | train_oof = np.zeros(( 300000,))
test_preds_2 = 0
train_oof.shape | Tabular Playground Series - Jan 2021 |
14,591,678 | test = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
test['filepath'] = test.image_id.apply(lambda x: os.path.join('.. /input/cassava-leaf-disease-classification/test_images', f'{x}'))
<normalization> | best_trial_2 = {'colsample_bylevel': 0.91,
'colsample_bytree': 0.6100000000000001,
'max_depth': 10,
'subsample': 0.5,
'min_child_weight': 21,
'lambda': 2.4118345076896113e-05,
'alpha': 3.234942680594196e-08,
'random_state': 3000,
'gamma': 1.51,
'tree_method': 'gpu_hist',
'predictor': 'gpu_predictor',
'learning_rate': 0.01} | Tabular Playground Series - Jan 2021 |
14,591,678 | def get_transforms(*, data):
if data == 'valid':
return A.Compose([
A.Resize(CFG.size, CFG.size),
A.Transpose(p=0.5),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2()
] )<choose_model_class> | NUM_FOLDS=10
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
fold_rmse_2 =[]
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(train, target))):
train_df, val_df = train.iloc[train_ind][columns], train.iloc[val_ind][columns]
train_target, val_target = target[train_ind], target[val_ind]
train_df = xgb.DMatrix(train_df, label=train_target)
val_df = xgb.DMatrix(val_df, label=val_target)
model = xgb.train(best_trial_2, train_df, 2000)
temp_oof = model.predict(val_df)
temp_test = model.predict(final_test)
train_oof[val_ind] = temp_oof
test_preds_2 += temp_test/NUM_FOLDS
rmse_iter = mean_squared_error(temp_oof, val_target, squared=False)
print(rmse_iter)
fold_rmse_2.append(rmse_iter ) | Tabular Playground Series - Jan 2021 |
14,591,678 | class CustomResNext(nn.Module):
def __init__(self, model_name='resnext50_32x4d', pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=pretrained)
n_features = self.model.fc.in_features
self.model.fc = nn.Linear(n_features, CFG.target_size)
def forward(self, x):
x = self.model(x)
return x
<load_pretrained> | sub['target'] = test_preds_2
sub.to_csv('submission3_post_competition.csv', index=False ) | Tabular Playground Series - Jan 2021 |
14,185,943 | def load_state(model_path):
model = CustomResNext(CFG.model_name, pretrained=False)
try:
model.load_state_dict(torch.load(model_path)['model'], strict=True)
state_dict = torch.load(model_path)['model']
except:
state_dict = torch.load(model_path)['model']
state_dict = {k[7:] if k.startswith('module.')else k: state_dict[k] for k in state_dict.keys() }
return state_dict
def inference(model, states, test_loader, device):
tta_probs = []
for e in range(CFG.tta):
model.to(device)
tk0 = tqdm(enumerate(test_loader), total=len(test_loader))
probs = []
for i,(images)in tk0:
images = images.to(device)
avg_preds = []
for state in states:
model.load_state_dict(state)
model.eval()
with torch.no_grad() :
y_preds = model(images)
avg_preds.append(y_preds.softmax(1 ).to('cpu' ).numpy())
avg_preds = np.mean(avg_preds, axis=0)
probs.append(avg_preds)
probs = np.concatenate(probs)
tta_probs.append(probs)
tta_probs = np.mean(tta_probs, axis=0)
return tta_probs<load_pretrained> | mpl.rcParams['agg.path.chunksize'] = 10000 | Tabular Playground Series - Jan 2021 |
14,185,943 | model = CustomResNext(CFG.model_name, pretrained=False)
states = [load_state(MODEL_DIR+f'{CFG.model_name}_fold{fold}.pth')for fold in CFG.trn_fold]
test_dataset = TestDataset(test, transform=get_transforms(data='valid'))
test_loader = DataLoader(test_dataset, batch_size=CFG.batch_size, shuffle=False,
num_workers=CFG.num_workers, pin_memory=True)
predictions = inference(model, states, test_loader, device )<feature_engineering> | train_data = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/train.csv')
test_data = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/test.csv')
print("successfully loaded!" ) | Tabular Playground Series - Jan 2021 |
14,185,943 | submission = test[["image_id"]]
submission["label"] =(
np.mean(tst_preds_all_folds, axis=0)* 0.7
+ predictions * 0.3
).argmax(1 )<save_to_csv> | outlier = train_data.loc[train_data.target < 1.0]
print(outlier ) | Tabular Playground Series - Jan 2021 |
14,185,943 | submission.to_csv("submission.csv", index=False )<save_to_csv> | train_data.drop([170514], inplace = True ) | Tabular Playground Series - Jan 2021 |
14,185,943 | submission.to_csv("submission.csv", index=False )<define_variables> | y_train = train_data["target"]
train_data.drop(columns = ["target"], inplace = True ) | Tabular Playground Series - Jan 2021 |
14,185,943 | class CFG:
img_size = 512
num_classes = 5
num_workers = 4
batch_size = 64
epochs = 1
OUTPUT_DIR = './'
ROOT_DIR = '.. /input/cassava-leaf-disease-classification/'
TRAIN_PATH = '.. /input/cassava-leaf-disease-classification/train_images'
TEST_PATH = '.. /input/cassava-leaf-disease-classification/test_images'
MODEL_DIR = '.. /input/cassava-models'<normalization> | params = { 'n_estimators' : [1500, 2000, 2500],
'learning_rate' : [0.01, 0.02]
}
xgb = XGBRegressor(
objective = 'reg:squarederror',
subsample = 0.8,
colsample_bytree = 0.8,
learning_rate = 0.01,
tree_method = 'gpu_hist')
grid_search = GridSearchCV(xgb,
param_grid = params,
scoring = 'neg_root_mean_squared_error',
n_jobs = -1,
verbose = 10)
grid_search.fit(train_data, y_train)
print('
Best estimator:')
print(grid_search.best_estimator_)
print('
Best score:')
print(grid_search.best_score_)
print('
Best hyperparameters:')
print(grid_search.best_params_ ) | Tabular Playground Series - Jan 2021 |
14,185,943 | def get_augmentation(data):
if data=='test':
return A.Compose([
A.Resize(CFG.img_size, CFG.img_size),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0),
ToTensorV2()
])
test_aug = A.Compose([
A.Resize(CFG.img_size, CFG.img_size),
A.Transpose(p=0.5),
A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.HueSaturationValue(
hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.5
),
A.RandomBrightnessContrast(
brightness_limit=(-0.1,0.1),
contrast_limit=(-0.1, 0.1),
p=0.5
),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255.0,
p=1.0
),
ToTensorV2()
], p=1.)<categorify> | test_data_backup = test_data.copy()
train_data.drop(columns = ["id"], inplace = True)
test_data.drop(columns = ["id"], inplace = True ) | Tabular Playground Series - Jan 2021 |
14,185,943 | class TestDataset(Dataset):
def __init__(self, df, transform=None):
self.df = df
self.file_names = df['image_id'].values
self.transform = transform
def __len__(self):
return len(self.df)
def __getitem__(self, idx):
file_name = self.file_names[idx]
file_path = f'{TEST_PATH}/{file_name}'
image = Image.open(file_path ).convert('RGB')
image = np.array(image)
if self.transform:
augmented = self.transform(image=image)
image = augmented['image']
return image<choose_model_class> | clf = XGBRegressor(
objective = 'reg:squarederror',
subsample = 0.8,
learning_rate = 0.02,
max_depth = 7,
n_estimators = 2000,
tree_method = 'gpu_hist')
clf.fit(train_data, y_train)
y_pred_xgb = clf.predict(test_data)
print(y_pred_xgb ) | Tabular Playground Series - Jan 2021 |
14,185,943 | <choose_model_class><EOS> | solution = pd.DataFrame({"id":test_data_backup.id, "target":y_pred_xgb})
solution.to_csv("solution.csv", index = False)
print("saved successful!" ) | Tabular Playground Series - Jan 2021 |
14,163,466 | <SOS> metric: RMSE Kaggle data source: tabular-playground-series-jan-2021<choose_model_class> | !pip3 install seaborn==0.11.0
!pip install seaborn==0.11.0 | Tabular Playground Series - Jan 2021 |
14,163,466 | class EnsembledModel() :
def __init__(self, model_paths):
super().__init__()
self.num_models = len(model_paths)
self.leafmodel1 = get_leaf_model(model_paths[0])
self.leafmodel2 = get_leaf_model(model_paths[1])
self.effb4_model1 = get_efficient_b4_model(model_paths[2])
self.effb4_model2 = get_efficient_b4_model(model_paths[3])
self.effb4_model3 = get_efficient_b4_model(model_paths[4])
self.effb4_model4 = get_efficient_b4_model(model_paths[5])
self.effb4_model5 = get_efficient_b4_model(model_paths[6])
self.effb7_model1 = get_efficient_b7_model(model_paths[7])
self.effb7_model2 = get_efficient_b7_model(model_paths[8])
self.effb7_model3 = get_efficient_b7_model(model_paths[9])
self.res50_model1 = get_resnext_model(model_paths[10])
self.res50_model2 = get_resnext_model(model_paths[11])
self.res50_model3 = get_resnext_model(model_paths[12])
self.res50_model4 = get_resnext_model(model_paths[13])
self.res50_model5 = get_resnext_model(model_paths[14])
self.res50_lr_model1 = get_resnext_model(model_paths[15])
self.res50_lr_model2 = get_resnext_model(model_paths[16])
self.res50_lr_model3 = get_resnext_model(model_paths[17])
def predict(self, x):
with torch.no_grad() :
l1 = self.leafmodel1(x)
l2 = self.leafmodel2(x)
b4_e1 = self.effb4_model1(x)
b4_e2 = self.effb4_model2(x)
b4_e3 = self.effb4_model3(x)
b4_e4 = self.effb4_model4(x)
b4_e5 = self.effb4_model5(x)
r1 = self.res50_model1(x)
r2 = self.res50_model2(x)
r3 = self.res50_model3(x)
r4 = self.res50_model4(x)
r5 = self.res50_model5(x)
b7_e1 = self.effb7_model1(x)
b7_e2 = self.effb7_model2(x)
b7_e3 = self.effb7_model3(x)
lr_r1 = self.res50_lr_model1(x)
lr_r2 = self.res50_lr_model2(x)
lr_r3 = self.res50_lr_model3(x)
pred =(l1+l2 + b4_e1+b4_e2+b4_e3+b4_e4+b4_e5 + b7_e1+b7_e2+b7_e3 + r1+r2+r3+r4+r5 + lr_r1+lr_r2+lr_r3)/(self.num_models)
return pred<define_variables> | warnings.filterwarnings("ignore")
%matplotlib inline
red = Fore.RED
grn = Fore.GREEN
blu = Fore.BLUE
ylw = Fore.YELLOW
wht = Fore.WHITE
| Tabular Playground Series - Jan 2021 |
14,163,466 | model_paths = [
'.. /input/cassava-trained-models/with_torch_crossentropy_LeafDiseasesModel Eff-4_fold-1.pt',
'.. /input/cassava-trained-models/with_torch_crossentropy_LeafDiseasesModel Eff-4_fold-5.pt',
'.. /input/cassava-trained-models/LeafDiseasesModel Eff-4_fold-1.pt',
'.. /input/cassava-trained-models/LeafDiseasesModel Eff-4_fold-2.pt',
'.. /input/cassava-trained-models/LeafDiseasesModel Eff-4_fold-3.pt',
'.. /input/cassava-trained-models/LeafDiseasesModel Eff-4_fold-4.pt',
'.. /input/cassava-trained-models/LeafDiseasesModel Eff-4_fold-5.pt',
'.. /input/cassava-trained-models/LeafDiseasesModel Eff-7_fold-1.pt',
'.. /input/cassava-trained-models/LeafDiseasesModel Eff-7_fold-2.pt',
'.. /input/cassava-trained-models/LeafDiseasesModel Eff-7_fold-4.pt',
'.. /input/cassava-trained-models/Resnext50_fold-1.pth',
'.. /input/cassava-trained-models/Resnext50_fold-2.pth',
'.. /input/cassava-trained-models/Resnext50_fold-3.pth',
'.. /input/cassava-trained-models/Resnext50_fold-4.pth',
'.. /input/cassava-trained-models/Resnext50_fold-5.pth',
'.. /input/cassava-trained-models/Resnext50_with_lr_scheduler_fold-1.pth',
'.. /input/cassava-trained-models/Resnext50_with_lr_scheduler_fold-2.pth',
'.. /input/cassava-trained-models/Resnext50_with_lr_scheduler_fold-3.pth'
]
model = EnsembledModel(model_paths )<predict_on_test> | print(sns.__version__)
| Tabular Playground Series - Jan 2021 |
14,163,466 | def inference(model, data_loader):
epoch_preds = 0
for epoch in range(CFG.epochs):
preds = []
for images in tqdm(data_loader):
images = images.to(device)
logits = model.predict(images)
preds += [logits.softmax(1 ).detach().cpu().numpy() ]
all_img_preds = np.concatenate(preds, axis=0)
epoch_preds += all_img_preds
epoch_preds = epoch_preds / CFG.epochs
return epoch_preds<load_from_csv> | path = '.. /input/tabular-playground-series-jan-2021/'
train = pd.read_csv(path + 'train.csv')
test = pd.read_csv(path + 'test.csv')
sample = pd.read_csv(path + 'sample_submission.csv' ) | Tabular Playground Series - Jan 2021 |
14,163,466 | test = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
test_data = TestDataset(test, transform=get_augmentation(data='test'))
test_loader = DataLoader(test_data, batch_size=CFG.batch_size, num_workers=CFG.num_workers )<prepare_output> | print('number of null columns in train set :- ',np.sum(train.isnull().sum() > 0))
print('number of null columns in test set :-',np.sum(test.isnull().sum() > 0)) | 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.