kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
1,437,082 | preds_list_base = []
preds_list_final_iteration = []
preds_list_all = []
for train_idx, val_idx in split.split(X_train):
X_tr = X_train.iloc[train_idx]
X_val = X_train.iloc[val_idx]
y_tr = y_train.iloc[train_idx]
y_val = y_train.iloc[val_idx]
Model = LGBMRegressor(**lgbm_params ).fit(X_tr, y_tr, eval_set=[(X_val, y_val... | train_images = np.concatenate(( train_imagesKeras,train_imagesKaggle), axis=0)
print("new Concatenated train_images ", train_images.shape)
print("_"*50)
train_labels = np.concatenate(( train_labelsKeras,train_labelsKaggle), axis=0)
print("new Concatenated train_labels ", train_labels.shape ) | Digit Recognizer |
1,437,082 | y_preds_base = np.array(preds_list_base ).mean(axis=0)
y_preds_base<prepare_output> | model = models.Sequential()
model.add(layers.Conv2D(32,(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.Dropout(0.5))
model.add(layers.MaxPooling2D(( 2, 2)))
model.add(layers.Conv2D(64,(3, 3), activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.MaxPooling2D(( 2, 2)))
model.add(la... | Digit Recognizer |
1,437,082 | y_preds_all = np.array(preds_list_all ).mean(axis=0)
y_preds_all<prepare_output> | num_epochs = 30
BatchSize = 2048
model.fit(train_images, train_labels, epochs=num_epochs, batch_size=BatchSize)
test_loss, test_acc = model.evaluate(test_imagesKeras, test_labelsKeras)
print("_"*80)
print("Accuracy on test ", test_acc ) | Digit Recognizer |
1,437,082 | y_preds_final_iteration = np.array(preds_list_final_iteration ).mean(axis=0)
y_preds_final_iteration<create_dataframe> | def build_model() :
model = models.Sequential()
model.add(layers.Conv2D(32,(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.Dropout(0.5))
model.add(layers.MaxPooling2D(( 2, 2)))
model.add(layers.Conv2D(64,(3, 3), activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.MaxPooling2D(( 2... | Digit Recognizer |
1,437,082 | submission = pd.DataFrame({'id':test.id,
'target':y_preds_final_iteration} )<save_to_csv> | train_data = train_images
train_targets = train_labels
k = 4
num_val_samples = len(train_data)// k
all_mae_histories = []
for i in range(k):
print('processing fold
val_data = train_data[i * num_val_samples:(i + 1)* num_val_samples]
val_targets = train_targets[i * num_val_samples:(i + 1)* num_val_samples]
partial_train_... | Digit Recognizer |
1,437,082 | submission.to_csv('submission.csv', index=False )<save_to_csv> | train_imagesFin = np.concatenate(( train_images,test_imagesKeras), axis=0)
print("train_imagesFin ", train_imagesFin.shape)
print("_"*50)
train_labelsFin = np.concatenate(( train_labels,test_labelsKeras), axis=0)
print("train_labelsFin ", train_labelsFin.shape ) | Digit Recognizer |
1,437,082 | submission.to_csv('submission.csv', index=False )<load_from_csv> | model = build_model()
model.fit(train_imagesFin, train_labelsFin, epochs=num_epochs, batch_size=BatchSize ) | Digit Recognizer |
1,437,082 | pd.read_csv('submission.csv' )<train_model> | RawPred = model.predict(test_imagesKaggle)
pred = []
numTest = RawPred.shape[0]
for i in range(numTest):
pred.append(np.argmax(RawPred[i]))
predictions = np.array(pred ) | Digit Recognizer |
1,437,082 | <find_best_model_class><EOS> | sample_submission = pd.read_csv('.. /input/sample_submission.csv')
result=pd.DataFrame({'ImageId':sample_submission.ImageId, 'Label':predictions})
result.to_csv("submission.csv",index=False)
print(result ) | Digit Recognizer |
1,278,972 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<find_best_params> | training_data = pd.read_csv('.. /input/train.csv')
test_data = pd.read_csv('.. /input/test.csv')
training_data.head() | Digit Recognizer |
1,278,972 | study = optuna.create_study(direction='minimize')
optimize = partial(objective, X=X_train, y=y_train, model=LGBMRegressor)
<init_hyperparams> | x_train = training_data.drop('label', axis = 1)
y_train = pd.DataFrame(data=training_data['label'])
display(y_train.head())
display(x_train.head() ) | Digit Recognizer |
1,278,972 | w1 = 0.2
w2 = 0.8<import_modules> | %matplotlib inline
i= 1
imshow(x_train.iloc[i].values.reshape(( 28, 28)))
print('This image corresponds to ', y_train.iloc[i] ) | Digit Recognizer |
1,278,972 | import numpy as np
import pandas as pd<load_from_csv> | cnn_model = Sequential()
cnn_model.add(Conv2D(128,(3,3), padding='same', input_shape=(28,28,1), data_format='channels_last', activation='relu'))
cnn_model.add(MaxPooling2D(pool_size=(2, 2)))
cnn_model.add(Dropout(0.2))
cnn_model.add(Conv2D(128,(3,3), padding='same', activation='relu'))
cnn_model.add(MaxPooling2D(pool_... | Digit Recognizer |
1,278,972 | %%time
df1 = pd.read_csv(".. /input/ensembling-starter-tps-feb-2021/submission.csv")
df2 = pd.read_csv(".. /input/playground-series-february-21/submission_040.csv")
blended_df = df1.copy(deep=True)
blended_df['target'] = w1*df1['target'] + w2*df2['target']
print(blended_df.head() )<save_to_csv> | y_train_categorical = to_categorical(y_train, num_classes=10)
reshaped_x = x_train.values.reshape(x_train.shape[0],28,28,1)/ 255
print(reshaped_x.shape)
print(y_train_categorical.shape)
cnn_model.fit(x=reshaped_x, y=y_train_categorical, batch_size=1000, epochs=32, verbose=1, validation_split=0.2 ) | Digit Recognizer |
1,278,972 | blended_df.to_csv("blended_df.csv", index=None )<import_modules> | reshaped_test_data = test_data.values.reshape(test_data.shape[0],28,28,1)/ 255
predictions = cnn_model.predict(reshaped_test_data)
display(predictions ) | Digit Recognizer |
1,278,972 | import plotly.express as px
import plotly.graph_objects as go
import plotly.figure_factory as ff
from plotly.subplots import make_subplots
import matplotlib.pyplot as plt
from colorama import Fore
from pandas_profiling import ProfileReport
import seaborn as sns
from sklearn import metrics
from scipy import stats
import... | predictions_formatted = np.argmax(predictions, axis=1)
display(predictions_formatted ) | Digit Recognizer |
1,278,972 | <concatenate><EOS> | submission = pd.DataFrame({'ImageId': np.arange(1,28001), 'Label': predictions_formatted})
submission.to_csv('submission_4.csv', index=False)
print('Done' ) | Digit Recognizer |
480,900 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<feature_engineering> | %matplotlib inline
print(os.path.dirname(os.getcwd())+':', os.listdir(os.path.dirname(os.getcwd())));
print(os.getcwd() +':', os.listdir(os.getcwd())) ; | Digit Recognizer |
480,900 | def modify_df(df):
df['cat4'] = df['cat4'].apply(lambda x: x if x == 'B' else 'Z')
df['cat5'] = df['cat5'].apply(lambda x: x if x in ['B', 'D'] else 'Z')
df['cat6'] = df['cat6'].apply(lambda x: x if x == 'A' else 'Z')
df['cat7'] = df['cat7'].apply(lambda x: x if x in ['E', 'D'] else 'Z')
df['cat8'] = df['cat8'].app... | if os.path.isfile('.. /input/train.csv'):
data_df = pd.read_csv('.. /input/train.csv')
print('train.csv loaded: data_df({0[0]},{0[1]})'.format(data_df.shape))
elif os.path.isfile('data/train.csv'):
data_df = pd.read_csv('data/train.csv')
print('train.csv loaded: data_df({0[0]},{0[1]})'.format(data_df.shape))
else:
pr... | Digit Recognizer |
480,900 | for feature in categorical_columns:
le = LabelEncoder()
le.fit(train_df[feature])
train_df[feature] = le.transform(train_df[feature])
test_df[feature] = le.transform(test_df[feature])
for feature in categorical_columns:
le = LabelEncoder()
le.fit(mod_train_df[feature])
mod_train_df[feature] = le.transform(mod_train... | def normalize_data(data):
data = data / data.max()
return data
def dense_to_one_hot(labels_dense, num_classes):
num_labels = labels_dense.shape[0]
index_offset = np.arange(num_labels)* num_classes
labels_one_hot = np.zeros(( num_labels, num_classes))
labels_one_hot.flat[index_offset + labels_dense.ravel() ] = 1
return ... | Digit Recognizer |
480,900 | x = train_df[feature_cols]
y = train_df['target']
feature_cols_mod = mod_train_df.drop(['id', 'target'], axis=1 ).columns
xmod, ymod = mod_train_df[feature_cols_mod], mod_train_df['target']
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42 )<train_model> | def generate_images(imgs):
image_generator = keras.preprocessing.image.ImageDataGenerator(
rotation_range = 10, width_shift_range = 0.1 , height_shift_range = 0.1,
zoom_range = 0.1)
imgs = image_generator.flow(imgs.copy() , np.zeros(len(imgs)) ,
batch_size=len(imgs), shuffle = False ).next()
return imgs[0]
fig,axs = ... | Digit Recognizer |
480,900 | clf = XGBRegressor(random_state=42, tree_method='gpu_hist')
clf.fit(x_train, y_train )<compute_train_metric> | logreg = sklearn.linear_model.LogisticRegression(verbose=0, solver='lbfgs',
multi_class='multinomial')
decision_tree = sklearn.tree.DecisionTreeClassifier()
extra_trees = sklearn.ensemble.ExtraTreesClassifier(verbose=0)
gradient_boost = sklearn.ensemble.GradientBoostingClassifier(verbose=0)
random_forest = sklearn.e... | Digit Recognizer |
480,900 | predictions = clf.predict(x_test)
score_rmse = math.sqrt(mean_squared_error(y_test, predictions))
print(Fore.GREEN + 'Base XGBoost RMSE: {}'.format(score_rmse))<predict_on_test> | class nn_class:
def __init__(self, nn_name = 'nn_1'):
self.s_f_conv1 = 3;
self.n_f_conv1 = 36;
self.s_f_conv2 = 3;
self.n_f_conv2 = 36;
self.s_f_conv3 = 3;
self.n_f_conv3 = 36;
self.n_n_fc1 = 576;
self.mb_size = 50
self.keep_prob = 0.33
self.learn_rate_array = [10*1e-4, 7.5*1e-4, 5*1e-4, 2.5*1e-4, 1*1e-4, 1*1e-4,
1*1e-... | Digit Recognizer |
480,900 | sub_xgb_base = clf.predict(test_df[feature_cols] )<train_model> | nn_name = ['tmp']
cv_num = 10
kfold = sklearn.model_selection.KFold(cv_num, shuffle=True, random_state=123)
for i,(train_index, valid_index)in enumerate(kfold.split(x_train_valid)) :
start = datetime.datetime.now() ;
x_train = x_train_valid[train_index]
y_train = y_train_valid[train_index]
x_valid = x_train_valid[vali... | Digit Recognizer |
480,900 | clf = LGBMRegressor(random_state=42, device='gpu')
clf.fit(x_train, y_train )<compute_train_metric> | if False:
!tensorboard --logdir=./logs | Digit Recognizer |
480,900 | predictions = clf.predict(x_test)
score_rmse = math.sqrt(mean_squared_error(y_test, predictions))
print(Fore.GREEN + 'Base LGBM RMSE: {}'.format(score_rmse))<define_variables> | mn = nn_name[0]
nn_graph = nn_class()
sess = nn_graph.load_session_from_file(mn)
W_conv1, W_conv2, W_conv3, _, _ = nn_graph.get_weights(sess)
sess.close()
print('W_conv1: min = ' + str(np.min(W_conv1)) + ' max = ' + str(np.max(W_conv1))
+ ' mean = ' + str(np.mean(W_conv1)) + ' std = ' + str(np.std(W_conv1)))
print('... | Digit Recognizer |
480,900 | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape<train_model> | mn = nn_name[0]
nn_graph = nn_class()
sess = nn_graph.load_session_from_file(mn)
y_valid_pred[mn] = nn_graph.forward(sess, x_valid)
sess.close()
y_valid_pred_label = one_hot_to_dense(y_valid_pred[mn])
y_valid_label = one_hot_to_dense(y_valid)
y_val_false_index = []
for i in range(y_valid_label.shape[0]):
if y_valid... | Digit Recognizer |
480,900 | NUM_FOLDS = 5
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=0)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(x, y))):
tmp_train_df, tmp_val_df = x.iloc[train_ind][feature_cols], x.iloc[val_ind][feature_cols]
train_target, val_target = y[train_ind], y[val_ind]
model = LGBMRegressor(random_state=42, d... | if os.path.isfile('.. /input/test.csv'):
test_df = pd.read_csv('.. /input/test.csv')
print('test.csv loaded: test_df{0}'.format(test_df.shape))
elif os.path.isfile('data/test.csv'):
test_df = pd.read_csv('data/test.csv')
print('test.csv loaded: test_df{0}'.format(test_df.shape))
else:
print('Error: test.csv not found... | Digit Recognizer |
480,900 | sub_df['target'] = test_preds
sub_df.to_csv('submission_lgbm_cv.csv', index=False)
sub_df.head()
sub_lgbm_cv = test_preds<init_hyperparams> | if False:
take_models = ['nn0','nn1','nn2','nn3','nn4','nn5','nn6','nn7','nn8','nn9']
kfold = sklearn.model_selection.KFold(len(take_models), shuffle=True, random_state = 123)
x_train_meta = np.array([] ).reshape(-1,10)
y_train_meta = np.array([] ).reshape(-1,10)
x_test_meta = np.zeros(( x_test.shape[0], 10))
print(... | Digit Recognizer |
480,900 | xgb_params = {
'booster':'gbtree',
'n_estimators':20000,
'max_depth':5,
'eta':0.008,
'gamma':3.5,
'objective':'reg:squarederror',
'verbosity':0,
'subsample':0.75,
'colsample_bytree':0.35,
'reg_lambda':0.23,
'reg_alpha':0.52,
'scale_pos_weight':1,
'objective':'reg:squarederror',
'eval_metric':'rmse',
'seed': 42,
'tree_m... | if False:
logreg = sklearn.linear_model.LogisticRegression(verbose=0, solver='lbfgs',
multi_class='multinomial')
take_meta_model = 'logreg'
model = sklearn.base.clone(base_models[take_meta_model])
model.fit(x_train_meta, one_hot_to_dense(y_train_meta))
y_train_pred['meta_model'] = model.predict_proba(x_train_meta)
y... | Digit Recognizer |
480,900 | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape
NUM_FOLDS = 5
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=42)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(x, y))):
tmp_train_df, tmp_val_df = x.iloc[train_ind][feature_cols], x.iloc[val_ind][feature_cols]
train_target, val_target = ... | if True:
mn = nn_name[0]
nn_graph = nn_class()
sess = nn_graph.load_session_from_file(mn)
y_test_pred = {}
y_test_pred_labels = {}
kfold = sklearn.model_selection.KFold(40, shuffle=False)
for i,(train_index, valid_index)in enumerate(kfold.split(x_test)) :
if i==0:
y_test_pred[mn] = nn_graph.forward(sess, x_test[valid... | Digit Recognizer |
480,900 | <init_hyperparams><EOS> | mn = nn_name[0]
y_test_pred_labels[mn] = one_hot_to_dense(y_test_pred[mn])
print(mn+': y_test_pred_labels[mn].shape = ', y_test_pred_labels[mn].shape)
unique, counts = np.unique(y_test_pred_labels[mn], return_counts=True)
print(dict(zip(unique, counts)))
np.savetxt('submission.csv',
np.c_[range(1,len(x_test)+1), y_... | Digit Recognizer |
1,195,173 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<train_model> | print(os.listdir(".. /input"))
| Digit Recognizer |
1,195,173 | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape
NUM_FOLDS = 5
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=42)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(xmod, ymod))):
tmp_train_df, tmp_val_df = xmod.iloc[train_ind][feature_cols_mod], xmod.iloc[val_ind][feature_cols_mod]
train_t... | img_rows, img_cols = 28, 28
| Digit Recognizer |
1,195,173 | sub_df['target'] = test_preds
sub_df.to_csv('submission_xgb_mod_cv_optimized.csv', index=False)
sub_df.head()
sub_xgb_mod_cv_optimized = test_preds<split> | def load_dataset(train_path,test_path):
global train,test,trainX,trainY,nb_classes
train = pd.read_csv(train_path ).values
test = pd.read_csv(test_path ).values
print("Train Shape :",train.shape)
trainX = train[:, 1:].reshape(train.shape[0], img_rows, img_cols, 1)
trainX = trainX.astype(float)
trainX /= 255.0
trainY... | Digit Recognizer |
1,195,173 | 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 = {
'device':'gpu',
'metric': 'rmse',
'random_state': 42,
'reg_lambda': trial.suggest_loguniform(
'reg_lambda', 1e-3, 10.0
),
'reg_alpha': trial.suggest_loguniform(
'reg_alph... | def createModel(inp_shape,nClasses):
model = models.Sequential()
model.add(Conv2D(32,(3, 3), padding='same', activation='relu', input_shape=inp_shape))
model.add(Conv2D(32,(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64,(3, 3), padding='same', activati... | Digit Recognizer |
1,195,173 | study = optuna.create_study(direction='minimize')
study.optimize(objective, n_trials=5)
print('Number of finished trials:', len(study.trials))
print('Best trial:', study.best_trial.params )<find_best_params> | def submission(prediction):
np.savetxt('mnist-submission.csv', np.c_[range(1,len(prediction)+1),prediction], delimiter=',', header = 'ImageId,Label', comments = '', fmt='%d' ) | Digit Recognizer |
1,195,173 | study.best_params<compute_train_metric> | def classification_report(X_test,test):
predicted_classes = model.predict_classes(X_test)
y_true = test.iloc[:, 0]
correct = np.nonzero(predicted_classes==y_true)[0]
incorrect = np.nonzero(predicted_classes!=y_true)[0]
target_names = ["Class {}".format(i)for i in range(num_classes)]
print(classification_report(y_true,... | Digit Recognizer |
1,195,173 | best_params = {
'reg_lambda': 0.015979956459638782,
'reg_alpha': 9.103977313355028,
'colsample_bytree': 0.3,
'subsample': 1.0,
'learning_rate': 0.009,
'n_estimators': 3000,
'max_depth': 15,
'min_child_samples': 142,
'num_leaves': 84,
'random_state': 42,
'device': 'gpu',
}
clf = LGBMRegressor(**best_params)
clf.fit(x_t... | train_path=".. /input/train.csv"
test_path=".. /input/test.csv"
train,test,trainX,trainY,testX,nb_classes=load_dataset(train_path,test_path)
X_train, X_test, y_train, y_test = train_test_split(trainX,trainY,test_size=0.1, random_state=21)
inp_shape=(28,28,1)
model=createModel(inp_shape,nb_classes)
imgaug=False
batc... | Digit Recognizer |
1,195,173 | sub_preds = clf.predict(test_df[feature_cols])
sub_df['target'] = sub_preds
sub_df.to_csv('submission_lgbm_optuna.csv', index=False)
sub_df.head()
sub_lgbm_optuna = sub_preds<init_hyperparams> | Digit Recognizer | |
3,148,616 | lgbm_params = {
"random_state": 2021,
"metric": "rmse",
"n_jobs": -1,
"cat_feature": [x for x in range(len(categorical_columns)) ],
"early_stopping_round": 150,
"reg_alpha": 6.147694913504962,
"reg_lambda": 0.002457826062076097,
"colsample_bytree": 0.3,
"learning_rate": 0.01,
"max_depth": 30,
"num_leaves": 100,
"min_ch... | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
3,148,616 | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape
NUM_FOLDS = 5
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=42)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(x, y))):
tmp_train_df, tmp_val_df = x.iloc[train_ind][feature_cols], x.iloc[val_ind][feature_cols]
train_target, val_target = ... | train = pd.read_csv('.. /input/train.csv')
test = pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
3,148,616 | sub_df['target'] = test_preds
sub_df.to_csv('submission_lgbm_cv_optimized.csv', index=False)
sub_df.head()
sub_lgbm_cv_optimized = test_preds<train_model> | Y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1 ) | Digit Recognizer |
3,148,616 | train_oof = np.zeros(( 300000,))
test_preds = 0
train_oof.shape
NUM_FOLDS = 5
kf = KFold(n_splits=NUM_FOLDS, shuffle=True, random_state=42)
for f,(train_ind, val_ind)in tqdm(enumerate(kf.split(xmod, ymod))):
tmp_train_df, tmp_val_df = xmod.iloc[train_ind][feature_cols_mod], xmod.iloc[val_ind][feature_cols_mod]
train_t... | X_train = X_train / 255.0
test = test / 255 | Digit Recognizer |
3,148,616 | sub_df['target'] = test_preds
sub_df.to_csv('submission_lgbm_mod_cv_optimized.csv', index=False)
sub_df.head()
sub_lgbm_mod_cv_optimized = test_preds<set_options> | X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.1, random_state=2 ) | Digit Recognizer |
3,148,616 | h2o.init()<split> | model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28, 1)) ,
keras.layers.Dense(128, activation=tf.nn.relu),
keras.layers.Dense(10, activation=tf.nn.softmax)
] ) | Digit Recognizer |
3,148,616 | train_hf = h2o.H2OFrame(train_df)
test_hf = h2o.H2OFrame(test_df)
predictors = list(feature_cols)
response = 'target'
train, valid = train_hf.split_frame(ratios=[.8], seed=1234 )<choose_model_class> | model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
3,148,616 | aml = H2OAutoML(
max_models=20,
max_runtime_secs=200,
exclude_algos = ["DeepLearning", "DRF"],
seed=42,
)<train_model> | history = model.fit(X_train, Y_train, epochs=5 ) | Digit Recognizer |
3,148,616 | aml.train(x=predictors,
y=response,
training_frame=train,
validation_frame=valid
)<compute_test_metric> | hist = pd.DataFrame(history.history)
hist['epoch'] = history.epoch
hist.tail() | Digit Recognizer |
3,148,616 | print('The model performance in RMSE: {}'.format(aml.leader.rmse(valid=True)))
print('The model performance in MAE: {}'.format(aml.leader.mae(valid=True)) )<predict_on_test> | test_loss, test_acc = model.evaluate(X_val, Y_val)
print('Test accuracy:', test_acc ) | Digit Recognizer |
3,148,616 | preds = aml.predict(test_hf ).as_data_frame()
preds.head()<save_to_csv> | model = keras.Sequential([
tf.keras.layers.Conv2D(32,(3,3), padding='same', activation=tf.nn.relu,
input_shape=(28, 28, 1)) ,
tf.keras.layers.Conv2D(32,(3,3), padding='same', activation=tf.nn.relu),
tf.keras.layers.MaxPooling2D(( 2, 2), strides=2),
tf.keras.layers.Dropout(0.25),
tf.keras.layers.Conv2D(64,(3,3), padding... | Digit Recognizer |
3,148,616 | sub_df['target'] = preds['predict']
sub_df.to_csv('submission_h2o.csv', index=False)
sub_df.head()
sub_automl = preds['predict']<define_variables> | model.compile(optimizer = 'adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'] ) | Digit Recognizer |
3,148,616 | sub1 = 0.3*sub_xgb_cv_optimized + 0.3*sub_lgbm_cv_optimized + 0.4*sub_lgbm_optuna
sub2 = 0.4*sub_xgb_cv_optimized + 0.4*sub_lgbm_cv_optimized + 0.2*sub_lgbm_optuna
sub3 = 0.3*sub_xgb_cv_optimized + 0.4*sub_lgbm_cv_optimized + 0.3*sub_lgbm_optuna
sub4 = 0.3*sub_xgb_cv_optimized + 0.3*sub_lgbm_cv_optimized + 0.3*sub_lgbm... | history = model.fit(X_train, Y_train, epochs=30 ) | Digit Recognizer |
3,148,616 | sub_df['target'] = sub1
sub_df.to_csv('submission_01.csv', index=False)
sub_df['target'] = sub2
sub_df.to_csv('submission_02.csv', index=False)
sub_df['target'] = sub3
sub_df.to_csv('submission_03.csv', index=False)
sub_df['target'] = sub4
sub_df.to_csv('submission_04.csv', index=False)
sub_df['target'] = sub5
sub_... | test_loss, test_acc = model.evaluate(X_val, Y_val)
print('Test accuracy:', test_acc ) | Digit Recognizer |
3,148,616 | PATH = '.. /input/tabular-playground-series-feb-2021/'
train = pd.read_csv(PATH + 'train.csv')
test = pd.read_csv(PATH + 'test.csv')
sample = pd.read_csv(PATH + 'sample_submission.csv')
print(train.shape, test.shape )<drop_column> | predictions = model.predict(test ) | Digit Recognizer |
3,148,616 | FEATURES = train.drop(['id', 'target'], 1 ).columns
FEATURES<categorify> | np.argmax(predictions[0] ) | Digit Recognizer |
3,148,616 | for i in cat_features:
le = LabelEncoder()
le.fit(train[i])
train[i] = le.transform(train[i])
test[i] = le.transform(test[i])
train.head()<choose_model_class> | predictions = np.argmax(predictions,axis = 1)
predictions = pd.Series(predictions,name="Label" ) | Digit Recognizer |
3,148,616 | <split><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),predictions],axis = 1)
submission.to_csv("mnist_submission_v6.csv",index=False ) | Digit Recognizer |
3,885,820 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<train_model> | import tensorflow as tf
import numpy as np
import pandas as pd
import random
from sklearn.model_selection import train_test_split
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Model, Sequential
from tensorflow.keras.layers import Dense,Conv2D,Flatten,Dropout,Max... | Digit Recognizer |
3,885,820 | def objective(trial):
train_set = lgb.Dataset(X_train, y_train)
val_set = lgb.Dataset(X_val, y_val)
param = {
"objective": "regression",
"metric": "rmse",
"verbosity": 1,
"boosting_type": "gbdt",
"num_leaves": trial.suggest_int("num_leaves", 0, 256),
"max_depth": trial.suggest_int("max_depth", 3, 31),
"lambda_l1": tr... | train_df = pd.read_csv('.. /input/train.csv' ) | Digit Recognizer |
3,885,820 | study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=100)
trial = study.best_trial
trial.params['metric'] = 'rmse'<find_best_params> | label_df = train_df.label
train_df = train_df.drop('label', axis=1 ) | Digit Recognizer |
3,885,820 | print(trial.params )<train_model> | DS_SIZE = len(train_df)
BATCH_SIZE = 64
x_train, x_val, y_train, y_val = train_test_split(
np.reshape(train_df.values,(DS_SIZE, 28, 28, 1)) ,
label_df.values,
test_size=0.01,
random_state=11)
train_gen = ImageDataGenerator(
rescale=1./255,
shear_range=10,
zoom_range=0.1,
width_shift_range=0.05,
height_shift_range=0... | Digit Recognizer |
3,885,820 | for train_idx, val_idx in cv.split(X, y):
X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]
y_train, y_val = y[train_idx], y[val_idx]
train_set = lgb.Dataset(X_train, y_train)
val_set = lgb.Dataset(X_val, y_val)
model = lgb.train(trial.params,
train_set,
num_boost_round=NUM_BOOST_ROUNDS,
early_stopping_rounds=EARLY... | val_gen = ImageDataGenerator(rescale=1./255)
val_gen_flow = val_gen.flow(
x_val,
y_val,
batch_size=BATCH_SIZE
) | Digit Recognizer |
3,885,820 | print(math.sqrt(mean_squared_error(oof_df.target, oof_df.oof)))
sample['target'] = sample.drop(['id', 'target'], 1 ).mean(axis=1)
sample[['id', 'target']].to_csv('submission.csv', index=False )<import_modules> | def get_model() :
model = Sequential()
model.add(Conv2D(64,(3, 3), input_shape=(28,28,1), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(rate=0.4))
model.add(Conv2D(96,(4, 4), activation='relu'))
model.add(Conv2D(128,(6, 6), activation='relu'))
model.add(MaxPooling2D(po... | Digit Recognizer |
3,885,820 | import pandas as pd
import numpy as np
import datatable as dt
import datetime
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import KFold
from lightgbm import LGBMRegressor<load_from_csv> | history = model.fit_generator(
train_gen_flow,
steps_per_epoch=len(x_train)/BATCH_SIZE,
epochs=50,
validation_data = val_gen_flow,
validation_steps = len(x_val)/BATCH_SIZE
)
| Digit Recognizer |
3,885,820 | train = dt.fread('.. /input/tabular-playground-series-feb-2021/train.csv' ).to_pandas()
test = dt.fread('.. /input/tabular-playground-series-feb-2021/test.csv' ).to_pandas()<define_variables> | train_df = pd.read_csv('.. /input/train.csv')
raw_train_image_ds = np.reshape(
train_df.drop('label', axis=1 ).values/255.0,
(len(train_df), 28, 28, 1)
)
model.evaluate(raw_train_image_ds,train_df.label.values ) | Digit Recognizer |
3,885,820 | cat_col = [c for c in train.columns if 'cat' in c]
cont_col = [c for c in train.columns if 'cont' in c]<categorify> | test_df = pd.read_csv('.. /input/test.csv')
test_image_ds = np.reshape(
test_df.values/255.0,
(len(test_df), 28, 28, 1)
)
preds = np.round(model.predict(test_image_ds)) | Digit Recognizer |
3,885,820 | for c in cat_col:
le = LabelEncoder()
train[c] = le.fit_transform(train[c])
test[c] = le.transform(test[c] )<choose_model_class> | sample_submission_df = pd.read_csv('.. /input/sample_submission.csv')
sample_submission_df.Label = np.argmax(preds, axis=1)
sample_submission_df.head() | Digit Recognizer |
3,885,820 | kfold = KFold(5, True, random_state = 87 )<prepare_x_and_y> | sample_submission_df.to_csv('submission.csv', index=False ) | Digit Recognizer |
4,165,577 | X = train[cat_col + cont_col]
y = train['target']
X_test = test[cat_col + cont_col]<init_hyperparams> | import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, BatchNormalization
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
from keras.callbacks import ModelCheckpoint, EarlyStopping
from keras.optimizers import Adam
from keras.utils import np_utils... | Digit Recognizer |
4,165,577 | lgbm_params = {
'bagging_freq': 1,
'reg_alpha': 2.4766410381355457,
'reg_lambda': 2.644144282261626,
'colsample_bytree': 0.3,
'subsample': 0.6,
'learning_rate': 0.008,
'max_depth': 20,
'num_leaves': 139,
'min_child_samples': 176,
'random_state': 48,
'n_estimators': 20000,
'metric': 'rmse',
'cat_smooth': 9}<train_model> | from sklearn.model_selection import train_test_split | Digit Recognizer |
4,165,577 | results = np.zeros(X_test.shape[0])
models = []
loss = []
num = 1
for tr, te in kfold.split(X, y):
print(f'{num} Fold Start')
X_train, X_val = X.iloc[tr], X.iloc[te]
y_train, y_val = y.iloc[tr], y.iloc[te]
model = LGBMRegressor(**lgbm_params)
model.fit(X_train, y_train, eval_set=(X_val, y_val), eval_metric = 'rmse',... | from sklearn.model_selection import train_test_split | Digit Recognizer |
4,165,577 | print(loss )<load_from_csv> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
y_train = train["label"]
x_train = train.drop(labels = ["label"],axis = 1)
y_train.value_counts() | Digit Recognizer |
4,165,577 | submission = pd.read_csv('.. /input/tabular-playground-series-feb-2021/sample_submission.csv')
submission['target'] = results
submission<save_to_csv> | x_train = x_train / 255.0
test = test / 255.0 | Digit Recognizer |
4,165,577 | now = datetime.datetime.now().strftime('%Y-%m-%d:%H:%M')
submission.to_csv(f'./{now}_submission.csv', index= False )<load_from_csv> | random_seed = 2 | Digit Recognizer |
4,165,577 | train = pd.read_csv(input_path / 'train.csv', index_col='id')
display(train.head() )<load_from_csv> | x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size = 0.1, random_state=random_seed ) | Digit Recognizer |
4,165,577 | test = pd.read_csv(input_path / 'test.csv', index_col='id')
display(test.head() )<load_from_csv> | print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_val.shape[0], 'test samples')
y_train = np_utils.to_categorical(y_train)
y_val = np_utils.to_categorical(y_val)
print("Number of Classes: " + str(y_val.shape[1]))
num_classes = y_val.shape[1]
num_pixels = x_train.shape[1] * x_t... | Digit Recognizer |
4,165,577 | submission = pd.read_csv(input_path / 'sample_submission.csv', index_col='id')
display(submission.head() )<categorify> | 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 |
4,165,577 | for c in train.columns:
if train[c].dtype=='object':
lbl = LabelEncoder()
lbl.fit(list(train[c].values)+ list(test[c].values))
train[c] = lbl.transform(train[c].values)
test[c] = lbl.transform(test[c].values)
display(train.head() )<drop_column> | batch_size = 128
epochs = 50
learning_rate_reduction = ReduceLROnPlateau(monitor='val_loss',
patience=2,
verbose=1,
factor=0.5,
min_lr=0.00001)
earlystop = EarlyStopping(monitor = 'val_loss',
min_delta = 0,
patience = 5,
verbose = 1,
restore_best_weights = True)
callbacks = [earlystop, learning_rate_reduction]
histor... | Digit Recognizer |
4,165,577 | target = train.pop('target' )<normalization> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
4,165,577 | scaler = StandardScaler()
train = scaler.fit_transform(train)
test = scaler.transform(test )<create_dataframe> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("2.csv",index=False ) | Digit Recognizer |
4,187,374 | train = DataFrame(train)
test = DataFrame(test )<split> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
4,187,374 | X_train, X_test, y_train, y_test = train_test_split(train, target, train_size=0.90 )<choose_model_class> | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
4,187,374 | rf = ensemble.RandomForestRegressor()
rf.fit(X_train,y_train)
y_preds = rf.predict(X_test)
print(mean_squared_error(y_test,y_preds))<compute_train_metric> | X_train = train.drop('label',axis = 1)
y_train = train.label | Digit Recognizer |
4,187,374 | lgbm = LGBMRegressor()
lgbm.fit(X_train,y_train)
y_pred = lgbm.predict(X_test)
mse_l = mean_squared_error(y_test,y_pred)
print(mse_l )<compute_train_metric> | y_train.value_counts() | Digit Recognizer |
4,187,374 | xgr = xg.XGBRegressor()
xgr.fit(X_train,y_train)
y_preds = xgr.predict(X_test)
print(mean_squared_error(y_test,y_preds))<choose_model_class> | X_train.isnull().any().sum() | Digit Recognizer |
4,187,374 | estimators=[('RandomForest', rf),('LightGBM',lgbm),('xgboost', xgr)]
ensemble = VotingRegressor(estimators )<predict_on_test> | test.isnull().any().sum() | Digit Recognizer |
4,187,374 | ensemble.fit(X_train,y_train)
y_preds = ensemble.predict(X_test)
print(mean_squared_error(y_test,y_preds))<save_to_csv> | X_train /= 255.
test /= 255 . | Digit Recognizer |
4,187,374 | lgbm.fit(train, target)
submission['target'] = lgbm.predict(test)
submission.to_csv('lgbm.csv')
<load_from_csv> | y_train = to_categorical(y_train, num_classes = 10 ) | Digit Recognizer |
4,187,374 | BASE = ".. /input/tabular-playground-series-feb-2021"
Test = pd.read_csv(BASE + '/test.csv')
train = pd.read_csv(BASE + '/train.csv')
sample_sub = pd.read_csv(BASE + '/sample_submission.csv' )<import_modules> | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size = 0.1, random_state= 3 ) | Digit Recognizer |
4,187,374 | import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
<set_options> | from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D, BatchNormalization | Digit Recognizer |
4,187,374 | sns.set_theme()
<count_missing_values> | model = Sequential()
model.add(Conv2D(filters = 16, kernel_size =(3, 3), activation='relu',
input_shape =(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(filters = 16, kernel_size =(3, 3), activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(strides=(2,2)))
model.add(Dropout(0.25))
... | Digit Recognizer |
4,187,374 | print('Rows and Columns in train dataset:', sum(train.isnull().sum()))
print('Rows and Columns in test dataset:', sum(Test.isnull().sum()))<define_variables> | optimizer = Adamax(lr=0.001 ) | Digit Recognizer |
4,187,374 | cat_features = [feature for feature in train.columns if 'cat' in feature]
cont_features = [feature for feature in train.columns if 'cont' in feature]<set_options> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
4,187,374 | warnings.filterwarnings('ignore')
<count_values> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
4,187,374 | Count_diagram(train )<count_values> | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1)
datagen.fit(X_train ) | Digit Recognizer |
4,187,374 | Count_diagram(Test )<import_modules> | %%time
model.fit_generator(datagen.flow(X_train,y_train, batch_size= 86),
epochs = 100, validation_data =(X_val,y_val),
verbose = 2, steps_per_epoch=X_train.shape[0] // 86,
callbacks=[learning_rate_reduction] ) | Digit Recognizer |
4,187,374 | shap.initjs()<prepare_x_and_y> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label" ) | Digit Recognizer |
4,187,374 | <categorify><EOS> | 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,361,589 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<install_modules> | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.