kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
7,034,662 | output = pd.DataFrame({"id":test_data.id, "target":preds})
output.to_csv('submission.csv', index=False )<train_model> | learn.load('stage-1'); | Digit Recognizer |
7,034,662 | print('Finish!' )<set_options> | learn.unfreeze()
learn.lr_find() | Digit Recognizer |
7,034,662 | warnings.filterwarnings('ignore')
RANDOM_SEED = 123<load_from_csv> | %%time
learn.fit_one_cycle(35, max_lr=slice(1e-5, 0.02/10)) | Digit Recognizer |
7,034,662 | train = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/train.csv")
test = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/test.csv")
sample = pd.read_csv("/kaggle/input/tabular-playground-series-jan-2021/sample_submission.csv" )<feature_engineering> | learn.save('stage-2' ) | Digit Recognizer |
7,034,662 | train['magic1'] = train['cont10']/train['cont11']
train['magic2'] = train['cont11']/train['cont10']
train['magic3'] = train['cont1']/train['cont7']
train['magic4'] = train['cont7']/train['cont1']
train['magic5'] = train['cont4']/train['cont6']
test['magic1'] = test['cont10']/test['cont11']
test['magic2'] = test['cont11... | interp = ClassificationInterpretation.from_learner(learn ) | Digit Recognizer |
7,034,662 | train = train.drop('id', axis=1)
test = test.drop('id', axis=1)
X = train.drop('target', axis=1)
y = train.target<choose_model_class> | def make_submission_file(
learner,
filename=f'submission_{datetime.datetime.now().strftime("%Y%m%d_%H%M%S")}.csv',
preds=None
):
if preds is None:
preds, _ = learner.get_preds(ds_type=DatasetType.Test)
preds = np.argmax(preds, 1)
test_index = []
num = len(learn.data.test_ds)
for i in range(num):
test_index.appen... | Digit Recognizer |
7,034,662 | cat = CatBoostRegressor(iterations=1000 )<compute_train_metric> | make_submission_file(learn, filename="resnet18-fine-tuned.csv" ) | Digit Recognizer |
7,034,662 | model = [cat]
for mod in model:
score = cross_val_score(mod, X, y, cv=3, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("CAT RMSE Mean Score: ", np.mean(score))<compute_train_metric> | most_unsure = DatasetFormatter.from_most_unsure(learn ) | Digit Recognizer |
7,034,662 | model = [cat]
for mod in model:
score = cross_val_score(mod, X, y, cv=10, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("CAT RMSE Mean Score: ", np.mean(score))<choose_model_class> | err1 = 1 - 0.99442
err2 = 1 - 0.99571
print(f'Human in the loop improvement: {100*(err1-err2)/err1}%' ) | Digit Recognizer |
3,975,332 | lgbm = lightgbm.LGBMRegressor(random_state=RANDOM_SEED, n_jobs=-1, metric= 'rmse' )<compute_train_metric> | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
print(train_df.shape, test_df.shape ) | Digit Recognizer |
3,975,332 | model = [lgbm]
for mod in model:
score = cross_val_score(mod, X, y, cv=3, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("LGBM RMSE Mean Score: ", np.mean(score))<compute_train_metric> | train_df['label'].value_counts(sort=False ) | Digit Recognizer |
3,975,332 | model = [lgbm]
for mod in model:
score = cross_val_score(mod, X, y, cv=10, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("LGBM RMSE Mean Score: ", np.mean(score))<choose_model_class> | train_X = train_df.drop(['label'], axis=1 ).values
train_Y = train_df['label'].values
test_X = test_df.values
print(train_X.shape, train_Y.shape, test_X.shape ) | Digit Recognizer |
3,975,332 | xgbr = XGBRegressor(random_state=RANDOM_SEED )<compute_train_metric> | n_x = 28
train_X_digit = train_X.reshape(( -1, n_x, n_x, 1))
test_X_digit = test_X.reshape(( -1, n_x, n_x, 1))
print(train_X_digit.shape, test_X_digit.shape)
train_X_digit = train_X_digit / 255.
test_X_digit = test_X_digit / 255.
onehot_labels = to_categorical(train_Y)
print(onehot_labels.shape)
print(train_Y[181]... | Digit Recognizer |
3,975,332 | model = [xgbr]
for mod in model:
score = cross_val_score(mod, X, y, cv=3, scoring="neg_root_mean_squared_error", n_jobs=-1)
print("XGB RMSE Mean Score: ", np.mean(score))<create_dataframe> | data_augment = ImageDataGenerator(rotation_range=10, zoom_range=0.1,
width_shift_range=0.1, height_shift_range=0.1 ) | Digit Recognizer |
3,975,332 | dtrain = lightgbm.Dataset(data=X, label=y)
def hyp_lgbm(num_leaves, feature_fraction, bagging_fraction, max_depth, min_split_gain, min_child_weight, learning_rate):
params = {'application':'regression','num_iterations': 5000,
'early_stopping_round':100, 'metric':'rmse'}
params["num_leaves"] = int(round(num_leaves))
pa... | model = models.Sequential()
model.add(layers.Conv2D(32, kernel_size=5, padding='same', activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D(pool_size=(2,2)))
model.add(layers.Dropout(rate=0.4))
model.add(layers.Conv2D(64, kernel_size=5, activation='relu'))
model.add(layers.MaxPooling2D(pool_size... | Digit Recognizer |
3,975,332 | pds = {
'num_leaves':(5, 50),
'feature_fraction':(0.2, 1),
'bagging_fraction':(0.2, 1),
'max_depth':(2, 20),
'min_split_gain':(0.001, 0.1),
'min_child_weight':(10, 50),
'learning_rate':(0.01, 0.5),
}<init_hyperparams> | model.compile(optimizer='adam', loss='categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
3,975,332 | def cat_hyp(depth, bagging_temperature, l2_leaf_reg, learning_rate):
params = {"iterations": 100,
"loss_function": "RMSE",
"verbose": False}
params["depth"] = int(round(depth))
params["bagging_temperature"] = bagging_temperature
params["learning_rate"] = learning_rate
params["l2_leaf_reg"] = l2_leaf_reg
cat_feat = []
c... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',patience=3,factor=0.5,min_lr=0.00001,
verbose=1 ) | Digit Recognizer |
3,975,332 | pds = {'depth':(4, 10),
'bagging_temperature':(0.1,10),
'l2_leaf_reg':(0.1, 10),
'learning_rate':(0.1, 0.2)
}<train_on_grid> | X_dev = train_X_digit[:5000]
rem_X_train = train_X_digit[5000:]
print(X_dev.shape, rem_X_train.shape)
Y_dev = onehot_labels[:5000]
rem_Y_train = onehot_labels[5000:]
print(Y_dev.shape, rem_Y_train.shape ) | Digit Recognizer |
3,975,332 | dtrain = xgb.DMatrix(X, y, feature_names=X.columns.values)
def hyp_xgb(max_depth, subsample, colsample_bytree,min_child_weight, gamma, learning_rate):
params = {
'objective': 'reg:squarederror',
'eval_metric':'rmse',
'nthread':-1
}
params['max_depth'] = int(round(max_depth))
params['subsample'] = max(min(subsample, 1)... | epochs = 30
batch_size = 128
history = model.fit_generator(data_augment.flow(rem_X_train, rem_Y_train, batch_size=batch_size),
epochs=epochs, steps_per_epoch=rem_X_train.shape[0]//batch_size,
validation_data=(X_dev, Y_dev), callbacks=[learning_rate_reduction] ) | Digit Recognizer |
3,975,332 | pds ={
'min_child_weight':(3, 20),
'gamma':(0, 5),
'subsample':(0.7, 1),
'colsample_bytree':(0.1, 1),
'max_depth':(3, 10),
'learning_rate':(0.01, 0.5)
}<import_modules> | pred_dev = model.predict(X_dev)
pred_dev_labels = np.argmax(pred_dev, axis=1 ) | Digit Recognizer |
3,975,332 | from sklearn.ensemble import StackingRegressor
from sklearn.linear_model import LinearRegression<init_hyperparams> | result = pd.DataFrame(train_Y[:5000], columns=['Y_dev'])
result['Y_pred'] = pred_dev_labels
result['correct'] = result['Y_dev'] - result['Y_pred']
errors = result[result['correct'] != 0]
error_list = errors.index
print('Number of errors is ', len(errors))
print('The indices are ', error_list ) | Digit Recognizer |
3,975,332 | param_lgbm = {
'bagging_fraction': 0.973905385549851,
'feature_fraction': 0.2945585590881137,
'learning_rate': 0.03750332268701348,
'max_depth': int(7.66),
'min_child_weight': int(41.36),
'min_split_gain': 0.04033836353603582,
'num_leaves': int(46.42),
'application':'regression',
'num_iterations': 5000,
'metric': 'rmse... | predictions = model.predict(test_X_digit)
print(predictions.shape ) | Digit Recognizer |
3,975,332 | from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor, GradientBoostingRegressor
from sklearn.neural_network import MLPRegressor
from sklearn import svm
import lightgbm<define_search_model> | predicted_labels = np.argmax(predictions, axis=1 ) | Digit Recognizer |
3,975,332 | <train_model><EOS> | result = pd.read_csv('.. /input/sample_submission.csv')
result['Label'] = predicted_labels
result.to_csv('submission.csv', index=False ) | Digit Recognizer |
3,048,669 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<save_to_csv> | random.seed(42)
init_notebook_mode(connected=True)
| Digit Recognizer |
3,048,669 | sample['target'] = y_pred
sample.to_csv("submission.csv", index=False )<import_modules> | df_train = pd.read_csv('.. /input/train.csv')
df_comp = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
3,048,669 | import pandas as pd
import numpy as np
import datetime
import gc
import os
import random
import time
import warnings
import pandas as pd
import numpy as np
import lightgbm as lgb
import xgboost
import catboost
import seaborn as sns
from pandas import DataFrame
from sklearn.metrics import roc_auc_score, f1_score, precis... | df_train.isnull().sum().sum() | Digit Recognizer |
3,048,669 | train = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/train.csv')
test = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/test.csv')
train.shape,test.shape<init_hyperparams> | from sklearn.model_selection import train_test_split | Digit Recognizer |
3,048,669 | label = 'target'
seed = 0
local_test = True
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
seed_everything(seed)
params = {
'objective': 'regression',
'boosting_type': 'gbdt',
'metric': 'rmse',
'n_jobs': -1,
'learning_rate': 0.006,
'num_leaves': 2 ** 8,
'm... | from sklearn.model_selection import train_test_split | Digit Recognizer |
3,048,669 | def make_test(new_features):
features = base_features + new_features
oof_predictions = np.zeros(len(train))
final_predictions = np.zeros(len(test))
cv = KFold(n_splits=10,shuffle=True,random_state=seed)
if local_test:
n_estimators=1000
else:
n_estimators = 10000
lgb = LGBMRegressor(**params,n_estimators=n_estimators,d... | Y = df_train.label
X = df_train.drop('label', axis=1)
X = X / 255
X_comp = df_comp / 255
X_train, X_cross, Y_train, Y_cross = train_test_split(X, Y,test_size=0.1, random_state=42)
X_valid, X_test, Y_valid, Y_test = train_test_split(X_cross, Y_cross, test_size=0.5, random_state=42 ) | Digit Recognizer |
3,048,669 | local_test=False
score = [0.6970820000536615, 0.5829603998473519]
make_test([] )<import_modules> | from keras.models import Sequential, load_model
from keras.layers import Dense, Conv2D, MaxPool2D, Dropout, Flatten
from keras.utils import plot_model, to_categorical
from keras.utils.vis_utils import model_to_dot
from keras.preprocessing.image import ImageDataGenerator
from sklearn.metrics import confusion_matrix, acc... | Digit Recognizer |
3,048,669 | import os
import joblib
import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, AdaBoostRegressor
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.metrics... | X_train = X_train.values.reshape(X_train.shape[0],28,28,1)
X_valid = X_valid.values.reshape(X_valid.shape[0],28,28,1)
X_test = X_test.values.reshape(X_test.shape[0],28,28,1)
X_comp = X_comp.values.reshape(X_comp.shape[0],28,28,1)
Y_train = to_categorical(Y_train)
Y_valid = to_categorical(Y_valid)
Y_test = to_cate... | Digit Recognizer |
3,048,669 | train_df = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/train.csv')
test_df = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/test.csv')
submission = pd.read_csv('/kaggle/input/tabular-playground-series-jan-2021/sample_submission.csv' )<prepare_x_and_y> | datagen = ImageDataGenerator(height_shift_range=0.1,
width_shift_range=0.1,
rotation_range=10,
zoom_range=0.1,
fill_mode='constant',
cval=0
)
datagen.fit(X_train ) | Digit Recognizer |
3,048,669 | features = [feature for feature in train_df.columns if feature not in ['id', 'target']]
X_train = train_df[features]
y_train = train_df['target']
X_test = test_df[features]<count_missing_values> | model = Sequential()
droprate = 0.175
model.add(Conv2D(kernel_size=(2,2), filters=128, strides=(1,1), padding='same',activation='relu', input_shape=(28,28,1)))
model.add(Conv2D(kernel_size=(2,2), filters=128, strides=(1,1), padding='same',activation='relu'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))
model.... | Digit Recognizer |
3,048,669 | print('Missing value in train dataset:', sum(train_df.isnull().sum()))
print('Missing value in test dataset:', sum(test_df.isnull().sum()))<choose_model_class> | epochsN = 25
batch_sizeN = 63
history1 = model1.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_sizeN), validation_data=(X_valid, Y_valid), steps_per_epoch=len(X_train)/batch_sizeN, epochs=epochsN, verbose=2 ) | Digit Recognizer |
3,048,669 | cv = KFold(n_splits=5, shuffle=True, random_state=42 )<compute_train_metric> | model1.evaluate(X_test, Y_test, verbose=0 ) | Digit Recognizer |
3,048,669 | %%time
lin_reg = LinearRegression()
scores = cross_val_score(lin_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
lin_rmse_scores = np.sqrt(-scores)
print('Linear Regression performance:', lin_rmse_scores )<compute_train_metric> | model1.save('model_1.h5' ) | Digit Recognizer |
3,048,669 | %%time
tree_reg = DecisionTreeRegressor(random_state=42)
scores = cross_val_score(tree_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
tree_rmse_scores = np.sqrt(-scores)
print('Decision Tree Regressor performance:', tree_rmse_scores )<compute_train_metric> | del model
model = Sequential()
droprate = 0.15
model.add(Conv2D(kernel_size=(2,2), filters=128, strides=(1,1), padding='same',activation='relu', input_shape=(28,28,1)))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))
model.add(Dropout(droprate))
model.add(Conv2D(kernel_size=(2,2), filters=64, strides=(1,1), padd... | Digit Recognizer |
3,048,669 | %%time
forest_reg = RandomForestRegressor(random_state=42, n_jobs=-1)
scores = cross_val_score(forest_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
forest_rmse_scores = np.sqrt(-scores)
print('Random Forest performance:', forest_rmse_scores )<compute_train_metric> | epochsN = 35
batch_sizeN = 63
history2 = model2.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_sizeN), validation_data=(X_valid, Y_valid), steps_per_epoch=len(X_train)/batch_sizeN, epochs=epochsN, verbose=2 ) | Digit Recognizer |
3,048,669 | %%time
lgbm_reg = LGBMRegressor(random_state=42)
scores = cross_val_score(lgbm_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
lgbm_rmse_scores = np.sqrt(-scores)
print('LGBM performance:', lgbm_rmse_scores )<compute_train_metric> | model2.evaluate(X_test, Y_test, verbose=0 ) | Digit Recognizer |
3,048,669 | %%time
xgb_reg = XGBRegressor(random_state=42)
scores = cross_val_score(xgb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
xgb_rmse_scores = np.sqrt(-scores)
print('XGBoost performance:', xgb_rmse_scores )<compute_train_metric> | model2.save('model_2.h5' ) | Digit Recognizer |
3,048,669 | %%time
cb_reg = CatBoostRegressor(random_state=42, verbose=False)
scores = cross_val_score(cb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
cb_rmse_scores = np.sqrt(-scores)
print('CatBoost performance:', cb_rmse_scores )<compute_train_metric> | del model
model = Sequential()
droprate = 0.2
model.add(Conv2D(kernel_size=(2,2), filters=128, strides=(1,1), padding='same',activation='relu', input_shape=(28,28,1)))
model.add(Conv2D(kernel_size=(2,2), filters=128, strides=(1,1), padding='same',activation='relu'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))... | Digit Recognizer |
3,048,669 | %%time
ab_reg = AdaBoostRegressor(random_state=42)
scores = cross_val_score(ab_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
ab_rmse_scores = np.sqrt(-scores)
print('AdaBoost performance:', ab_rmse_scores )<choose_model_class> | epochsN = 40
batch_sizeN = 63
history3 = model3.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_sizeN), validation_data=(X_valid, Y_valid), steps_per_epoch=len(X_train)/batch_sizeN, epochs=epochsN, verbose=2 ) | Digit Recognizer |
3,048,669 | def build_and_compile_model(norm):
model = keras.Sequential([
norm,
layers.Dense(64, activation='relu'),
layers.Dense(64, activation='relu'),
layers.Dense(1)])
model.compile(loss='mean_squared_error',
optimizer=tf.keras.optimizers.Adam(0.001))
return model<train_model> | model3.evaluate(X_test, Y_test, verbose=0 ) | Digit Recognizer |
3,048,669 | %%time
normalizer = preprocessing.Normalization()
normalizer.adapt(np.array(X_train))
dnn_model = build_and_compile_model(normalizer)
history = dnn_model.fit(X_train, y_train, validation_split=0.2,
verbose=0, epochs=100 )<predict_on_test> | model3.save('model_3.h5' ) | Digit Recognizer |
3,048,669 | %%time
lin_reg = LinearRegression()
y_predict = cross_val_predict(lin_reg, X_train, y_train, cv=cv, n_jobs=-1 )<predict_on_test> | del model
model = Sequential()
droprate = 0.20
model.add(Conv2D(kernel_size=(2,2), filters=128, strides=(1,1), padding='same',activation='relu', input_shape=(28,28,1)))
model.add(Conv2D(kernel_size=(2,2), filters=128, strides=(1,1), padding='same',activation='relu'))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))... | Digit Recognizer |
3,048,669 | %%time
tree_reg = DecisionTreeRegressor(random_state=42)
y_predict = cross_val_predict(tree_reg, X_train, y_train, cv=cv, n_jobs=-1 )<predict_on_test> | epochsN = 90
batch_sizeN = 63
history4 = model4.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_sizeN), validation_data=(X_valid, Y_valid), steps_per_epoch=len(X_train)/batch_sizeN, epochs=epochsN, verbose=2 ) | Digit Recognizer |
3,048,669 | %%time
forest_reg = RandomForestRegressor(random_state=42, n_jobs=-1)
y_predict = cross_val_predict(forest_reg, X_train, y_train, cv=cv, n_jobs=-1 )<predict_on_test> | model4.evaluate(X_test, Y_test, verbose=0 ) | Digit Recognizer |
3,048,669 | %%time
lgbm_reg = LGBMRegressor(random_state=42)
y_predict = cross_val_predict(lgbm_reg, X_train, y_train, cv=cv, n_jobs=-1 )<predict_on_test> | model4.save('model_4.h5' ) | Digit Recognizer |
3,048,669 | %%time
xgb_reg = XGBRegressor(random_state=42)
y_predict = cross_val_predict(xgb_reg, X_train, y_train, cv=cv, n_jobs=-1 )<predict_on_test> | del model
model = Sequential()
droprate = 0.1
model.add(Conv2D(kernel_size=(2,2), filters=64, strides=(1,1), padding='same',activation='relu', input_shape=(28,28,1)))
model.add(Conv2D(kernel_size=(2,2), filters=64, strides=(2,2), padding='valid',activation='relu'))
model.add(Dropout(droprate))
model.add(Conv2D(kernel_... | Digit Recognizer |
3,048,669 | %%time
cb_reg = CatBoostRegressor(random_state=42, verbose=False)
y_predict = cross_val_predict(cb_reg, X_train, y_train, cv=cv, n_jobs=-1 )<predict_on_test> | epochsN = 90
batch_sizeN = 63
history5 = model5.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_sizeN), validation_data=(X_valid, Y_valid), steps_per_epoch=len(X_train)/batch_sizeN, epochs=epochsN, verbose=2 ) | Digit Recognizer |
3,048,669 | %%time
ab_reg = AdaBoostRegressor(random_state=42)
y_predict = cross_val_predict(ab_reg, X_train, y_train, cv=cv, n_jobs=-1 )<compute_train_metric> | model5.evaluate(X_test, Y_test, verbose=0 ) | Digit Recognizer |
3,048,669 | def objective(trial):
params = {
'random_state': 42,
'max_depth': trial.suggest_int('max_depth', 1, 14),
'learning_rate': trial.suggest_float('learning_rate', 0.01, 1.0)
}
lgbm_reg = LGBMRegressor()
lgbm_reg.set_params(**params)
scores = cross_val_score(lgbm_reg, X_train, y_train, scoring='neg_mean_squared_error', cv... | model5.save('model_5.h5' ) | Digit Recognizer |
3,048,669 | study = optuna.create_study(direction = 'minimize')
study.optimize(objective, n_trials = 1)
best_params = study.best_trial.params<compute_train_metric> | del model
model = Sequential()
droprate = 0.15
model.add(Conv2D(kernel_size=(2,2), filters=64, strides=(1,1), padding='same',activation='relu', input_shape=(28,28,1)))
model.add(Conv2D(kernel_size=(2,2), filters=64, strides=(1,1), padding='same',activation='relu'))
model.add(Conv2D(kernel_size=(2,2), filters=64, strid... | Digit Recognizer |
3,048,669 | %%time
lgbm_reg = LGBMRegressor()
lgbm_reg.set_params(**best_params)
scores = cross_val_score(lgbm_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
lgbm_rmse_scores = np.sqrt(-scores)
print('LGBM performance:', lgbm_rmse_scores )<compute_train_metric> | epochsN = 45
batch_sizeN = 63
history6 = model6.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_sizeN), validation_data=(X_valid, Y_valid), steps_per_epoch=len(X_train)/batch_sizeN, epochs=epochsN, verbose=2 ) | Digit Recognizer |
3,048,669 | def objective(trial):
params = {
'random_state': 42,
'max_depth': trial.suggest_int('max_depth', 1, 14),
'eta': trial.suggest_float('eta', 0.01, 1.0),
}
xgb_reg = XGBRegressor()
xgb_reg.set_params(**params)
scores = cross_val_score(xgb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
rmse = ... | model6.evaluate(X_test, Y_test, verbose=0 ) | Digit Recognizer |
3,048,669 | study = optuna.create_study(direction = 'minimize')
study.optimize(objective, n_trials = 1)
best_params = study.best_trial.params<compute_train_metric> | model6.save('model_6.h5' ) | Digit Recognizer |
3,048,669 | %%time
xgb_reg = XGBRegressor()
xgb_reg.set_params(**best_params)
scores = cross_val_score(xgb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=cv, n_jobs=-1)
xgb_rmse_scores = np.sqrt(-scores)
print('XGBoost performance:', xgb_rmse_scores )<feature_engineering> | del model
model = Sequential()
droprate = 0.35
model.add(Conv2D(kernel_size=(2,2), filters=64, strides=(1,1), padding='same',activation='relu', input_shape=(28,28,1)))
model.add(Conv2D(kernel_size=(2,2), filters=64, strides=(1,1), padding='same',activation='relu'))
model.add(Conv2D(kernel_size=(2,2), filters=64, strid... | Digit Recognizer |
3,048,669 | X_train['below8'] = np.where(y_train < 8, 1, 0 )<compute_train_metric> | epochsN = 60
batch_sizeN = 63
history7 = model7.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_sizeN), validation_data=(X_valid, Y_valid), steps_per_epoch=len(X_train)/batch_sizeN, epochs=epochsN, verbose=2 ) | Digit Recognizer |
3,048,669 | %%time
cb_reg = CatBoostRegressor(random_state=42, verbose=False)
scores = cross_val_score(cb_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=5)
cb_rmse_scores = np.sqrt(-scores)
print('CatBoost performance:', cb_rmse_scores )<import_modules> | model7.evaluate(X_test, Y_test, verbose=0 ) | Digit Recognizer |
3,048,669 | import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from xgboost import XGBRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error<load_from_csv> | model7.save('model_7.h5' ) | Digit Recognizer |
3,048,669 | train = pd.read_csv('.. /input/tabular-playground-series-jan-2021/train.csv', index_col='id')
test = pd.read_csv('.. /input/tabular-playground-series-jan-2021/test.csv', index_col='id' )<set_options> | trained_models = [model1, model2, model3, model4, model5, model6, model7] | Digit Recognizer |
3,048,669 | plt.style.use('ggplot')
plt.rcParams['axes.titlesize'] = 16
plt.rcParams['axes.labelsize'] = 12
plt.rcParams['xtick.labelsize'] = 'large'<count_missing_values> | acc_scores = pd.Series()
for num, model in enumerate(trained_models):
acc_scores.loc['Model ' + str(num + 1)] = accuracy_score(np.argmax(Y_test, axis=1), np.argmax(model.predict(X_test), axis=1)) | Digit Recognizer |
3,048,669 | print('Missing values on the train data:', train.isnull().sum().sum())
print('Missing values on the test data:', test.isnull().sum().sum() )<count_duplicates> | def summing_classifier(data, model_list):
total_pred_prob = model_list[0].predict(data)
for model in model_list[1:]:
total_pred_prob += model.predict(data)
return np.argmax(total_pred_prob, axis=1 ) | Digit Recognizer |
3,048,669 | print('Duplicated rows on the train data:', train.duplicated().sum())
print('Duplicated rows on the test data:', test.duplicated().sum() )<define_variables> | acc_scores.loc['Summing Classifier'] = accuracy_score(np.argmax(Y_test, axis=1), summing_classifier(X_test, trained_models))
acc_scores.loc['Summing Classifier'] | Digit Recognizer |
3,048,669 | q1 = train.quantile(0.25)
q3 = train.quantile(0.75)
iqr = q3 - q1
mask =(train >=(q1 - 1.5*iqr)) &(train <= q3 + 1.5*iqr)
train = train[mask.apply(all, axis=1)]
print('Train set without outliers shape:', train.shape )<split> | def voting_classifier(data, model_list):
pred_list = np.argmax(model_list[0].predict(data), axis=1 ).reshape(( 1,len(data)))
for model in model_list[1:]:
pred_list = np.append(pred_list, [np.argmax(model.predict(data), axis=1)], axis=0)
return np.array(list(map(lambda x: np.bincount(x ).argmax() , pred_list.T)) ) | Digit Recognizer |
3,048,669 | X_train, X_val, y_train, y_val = train_test_split(train[predictors],
train[target],
test_size = 0.2,
random_state=2021 )<choose_model_class> | acc_scores.loc['Voting Classifier'] = accuracy_score(np.argmax(Y_test, axis=1), voting_classifier(X_test, trained_models))
acc_scores.loc['Voting Classifier'] | Digit Recognizer |
3,048,669 | model = XGBRegressor(objective='reg:squarederror',
booster = "gbtree",
eval_metric = "rmse",
tree_method = "gpu_hist",
n_estimators = 1000,
learning_rate = 0.04,
eta = 0.1,
max_depth = 7,
subsample=0.85,
colsample_bytree = 0.85,
colsample_bylevel = 0.8,
alpha = 0,
random_state = 2021 )<train_model> | best_model_results = pd.DataFrame({'Label' : np.argmax(trained_models[ind_best_model].predict(X_comp), axis=1)})
best_model_results = best_model_results.reset_index().rename(columns={'index' : 'ImageId'})
best_model_results['ImageId'] = best_model_results['ImageId'] + 1
best_model_results.to_csv('best_model_result_ka... | Digit Recognizer |
3,048,669 | %time model.fit(X_train, y_train )<predict_on_test> | esmbl_sum_results = pd.DataFrame({'Label' : summing_classifier(X_comp, trained_models)})
esmbl_sum_results = esmbl_sum_results.reset_index().rename(columns={'index' : 'ImageId'})
esmbl_sum_results['ImageId'] = esmbl_sum_results['ImageId'] + 1
esmbl_sum_results.to_csv('esmbl_sum_result_kaggle.csv', index=False ) | Digit Recognizer |
3,048,669 | <save_to_csv><EOS> | esmbl_vote_results = pd.DataFrame({'Label' : voting_classifier(X_comp, trained_models)})
esmbl_vote_results = esmbl_vote_results.reset_index().rename(columns={'index' : 'ImageId'})
esmbl_vote_results['ImageId'] = esmbl_vote_results['ImageId'] + 1
esmbl_vote_results.to_csv('esmbl_vote_result_kaggle.csv', index=False ) | Digit Recognizer |
3,050,804 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<set_options> | warnings.filterwarnings('ignore')
%matplotlib inline
seed = 5
np.random.seed(seed ) | Digit Recognizer |
3,050,804 | warnings.filterwarnings("ignore" )<load_from_csv> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
print(train.shape, test.shape)
train.tail() | Digit Recognizer |
3,050,804 | train_data = pd.read_csv(path+'train.csv')
test_data = pd.read_csv(path+'test.csv')
samp_subm = pd.read_csv(path+'sample_submission.csv' )<count_values> | X_train =(train.iloc[:,1:].values ).astype('float32')
y_train = train.iloc[:,0].values.astype('int32')
X_train = X_train.reshape(-1, 28, 28,1)
X_train = X_train / 255.0
print(X_train.shape , y_train.shape)
test = test.values.reshape(-1, 28, 28, 1)
test = test.astype(float)
test /= 255.0
print(test.shape ) | Digit Recognizer |
3,050,804 | print('Number train samples:', len(train_data.index))
print('Number test samples:', len(test_data.index))
print('Number features:', len(train_data.columns))<count_missing_values> | y_train= to_categorical(y_train)
num_classes = y_train.shape[1]
print("Number of classes: ",num_classes ) | Digit Recognizer |
3,050,804 | print('Missing values on the train data:', train_data.isnull().sum().sum())
print('Missing values on the test data:', test_data.isnull().sum().sum() )<train_model> | X_train, X_val, Y_train, Y_val = train_test_split(X_train, y_train, test_size = 0.15, random_state=seed)
print("Shapes of train, validation dataset ")
print(X_train.shape , Y_train.shape)
print(X_val.shape , Y_val.shape ) | Digit Recognizer |
3,050,804 | pca = PCA().fit(train_data[train_data.columns[1:-1]])
plt.plot(np.cumsum(pca.explained_variance_ratio_))
plt.xlabel('No of components')
plt.ylabel('Cumulative explained variance')
plt.grid()
plt.show()<define_variables> | filters_1 = 32
filters_2 = 64
filters_3 = 128
model = models.Sequential()
model.add(conv.Convolution2D(filters_1,(3,3), activation="relu", input_shape=(28, 28, 1), border_mode='same'))
model.add(conv.Convolution2D(filters_1,(3,3), activation="relu", border_mode='same'))
model.add(conv.MaxPooling2D(strides=(2,2)))
mode... | Digit Recognizer |
3,050,804 | features = ['cont'+str(i)for i in range(1, 15)]
no_features = ['id', 'target']<feature_engineering> | %%time
print("apply augumentation or data noisy...")
datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizo... | Digit Recognizer |
3,050,804 | train_data['mean'] = train_data[features].mean(axis=1)
train_data['std'] = train_data[features].std(axis=1)
train_data['max'] = train_data[features].max(axis=1)
train_data['min'] = train_data[features].min(axis=1)
train_data['sum'] = train_data[features].sum(axis=1)
test_data['mean'] = test_data[features].mean(axi... | print("Running prediction test.... ")
predictions = model.predict_classes(test,verbose=1)
print("done" ) | Digit Recognizer |
3,050,804 | <predict_on_test><EOS> | np.savetxt('digits-mnist-cnn-3.csv', np.c_[range(1,len(predictions)+1),predictions], delimiter=',', header = 'ImageId,Label', comments = '', fmt='%d')
print("saved prediction to file")
sub = pd.read_csv("digits-mnist-cnn-3.csv")
sub.tail(10 ) | Digit Recognizer |
1,079,802 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<count_values> | %matplotlib inline | Digit Recognizer |
1,079,802 | print('Number of outliers:', len(train_data)-mask.sum() )<split> | from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
import keras | Digit Recognizer |
1,079,802 | X_train, X_val, y_train, y_val = train_test_split(X, y, test_size = 0.2, random_state=2021 )<choose_model_class> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
1,079,802 | model = XGBRegressor(objective='reg:squarederror',
booster = "gbtree",
eval_metric = "rmse",
tree_method = "gpu_hist",
n_estimators = 600,
learning_rate = 0.04,
eta = 0.1,
max_depth = 7,
subsample=0.85,
colsample_bytree = 0.85,
colsample_bylevel = 0.8,
alpha = 0,
random_state = 2021)
model.fit(X_train, y_train)
y_val... | Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1)
| Digit Recognizer |
1,079,802 | y_test = model.predict(X_test )<prepare_output> | X_train = X_train / 255.0
test = test / 255.0 | Digit Recognizer |
1,079,802 | output = samp_subm.copy()
output['target'] = y_test<save_to_csv> | Y_train = to_categorical(Y_train, num_classes = 10 ) | Digit Recognizer |
1,079,802 | output.to_csv('submission.csv', index=False )<import_modules> | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1 ) | Digit Recognizer |
1,079,802 | import os
import sys
import math
import pickle
import psutil
import random
import json
import numpy as np
import torch
from torch import nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
import pandas as pd
import riiideducation<define_variables> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(5,5),activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters = 64, kernel_size =(3,3),activation ='relu'... | Digit Recognizer |
1,079,802 | seed = 0
random.seed(seed)
torch.random.manual_seed(seed)
n_workers = os.cpu_count()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
cfg_path = '/kaggle/input/riiid-mydata/cfg.json'
train_path = '/kaggle/input/riiid-mydata/train.pkl'
tag_path = '/kaggle/input/riiid-mydata/tags.csv'
states_path ... | model.compile(optimizer = 'adam' , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
1,079,802 | class FFN(nn.Module):
def __init__(self, d_model, dropout=0.0):
super().__init__()
self.lr1 = nn.Linear(d_model, d_model)
self.relu = nn.ReLU()
self.lr2 = nn.Linear(d_model, d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, x):
x = self.lr1(x)
x = self.relu(x)
x = self.dropout(x)
x = self.lr2(x)
retu... | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
1,079,802 | class KaggleOnlineDataset(Dataset):
def __init__(self, train_path, tag_path, states_path, n_exercises, cols, max_len):
super().__init__()
self.df = pd.read_pickle(train_path)
self.test_df = None
tag_df = pd.read_csv(tag_path, usecols=['exercise_id', 'bundle_id', 'part', 'correct_rate', 'frequency'])
assert np.all(tag... | epochs = 40
batch_size = 80 | Digit Recognizer |
1,079,802 | def truncate_and_prepare_masks(items, valid_len, need_pad_mask=True, need_attn_mask=True):
max_len = valid_len.max()
device = max_len.device
out = [None if item is None else item[:, :max_len] for item in items]
pad_mask = torch.arange(max_len, device=device)>= valid_len if need_pad_mask else None
attn_mask = torch.triu... | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_t... | Digit Recognizer |
1,079,802 | cfg = json.load(open(cfg_path, 'r'))
model = AIKTModel(cfg['n_exercises'], N_LEVELS, MAX_LAG, N_LAYERS, D_MODEL, is_lite=IS_LITE ).to(device)
model.load_state_dict(torch.load(model_path))
model.eval()
testset = KaggleOnlineDataset(train_path, tag_path, states_path, cfg['n_exercises'], cfg['cols'], MAX_LEN)
env = riii... | history = model.fit_generator(datagen.flow(X_train,Y_train, batch_size=batch_size),
epochs = epochs, validation_data =(X_val,Y_val),
verbose = 2, steps_per_epoch=X_train.shape[0] // batch_size
, callbacks=[learning_rate_reduction] ) | Digit Recognizer |
1,079,802 | session=pd.read_csv("/kaggle/input/airbnb-recruiting-new-user-bookings/sessions.csv.zip")
print(session.shape)
session.head()<load_from_csv> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
1,079,802 | train_user=pd.read_csv("/kaggle/input/airbnb-recruiting-new-user-bookings/train_users_2.csv.zip")
print(train_user.shape)
train_user.head()<load_from_csv> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("cnn_mnist_datagen.csv",index=False ) | Digit Recognizer |
4,081,536 | test_user=pd.read_csv("/kaggle/input/airbnb-recruiting-new-user-bookings/test_users.csv.zip")
print(test_user.shape)
test_user.head()<categorify> | train=pd.read_csv('.. /input/train.csv')
test=pd.read_csv('.. /input/test.csv')
sub=pd.read_csv('.. /input/sample_submission.csv' ) | Digit Recognizer |
4,081,536 | class Custom_Proccess(BaseEstimator, TransformerMixin):
def transform(self,X,y=None):
X.gender.replace('-unknown-', 'OTHER', inplace=True)
X['age'].fillna(-1,inplace=True)
X['timestamp_first_active']=X['timestamp_first_active'].apply(lambda s:datetime(year=int(str(s)[0:4]), month=int(str(s)[4:6]),
day=int(str(s)[6:8]... | x=train.drop(['label'],axis=1)
x_test=test.copy() | Digit Recognizer |
4,081,536 | session.drop(['action_detail','device_type'],inplace=True,axis=1)
session.dropna(subset=['user_id','action'],inplace=True)
session.action_type=session.action_type.fillna('Other')
session.secs_elapsed=session.secs_elapsed.fillna(0 )<categorify> | x=x/255
x_test=x_test/255 | Digit Recognizer |
4,081,536 | session_group=session.groupby(['user_id','action_type'] ).agg({'action':'count','secs_elapsed':'sum'} ).reset_index()
session_df=pd.get_dummies(session_group,columns=['action_type'] ).groupby(['user_id'] ).sum().reset_index()
session_df.head()<merge> | y=train['label'] | Digit Recognizer |
4,081,536 | train_user_df=train_user.merge(session_df,left_on=['id'],
right_on=['user_id'],how='left' ).drop(['user_id'],axis=1 ).reset_index(drop=True)
train_user_df.shape<merge> | y=pd.Categorical(y ) | Digit Recognizer |
4,081,536 | test_user_df=test_user.merge(session_df,left_on=['id'],
right_on=['user_id'],how='left' ).drop(['user_id'],axis=1 ).reset_index(drop=True)
test_user_df.shape<data_type_conversions> | y=pd.get_dummies(y ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.