kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
10,345,485 | imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
for col in continious_features:
imp_mean.fit(train_set[col].values.reshape(-1,1))
train_set[col] = imp_mean.transform(train_set[col].values.reshape(-1,1))
test_set[col] = imp_mean.transform(test_set[col].values.reshape(-1,1))
train_set[col] = np.log(trai... | pred = model.predict_classes(test_x, verbose=1 ) | Digit Recognizer |
10,345,485 | train_set[norminal_features].isnull().sum()<count_missing_values> | sub['Label'] = pred
sub.to_csv("sub.csv", index=False)
sub.head() | Digit Recognizer |
12,686,477 | test_set[norminal_features].isnull().sum()<data_type_conversions> | import time
import torch
import matplotlib.pyplot as plt
from torch import nn, optim
from torchvision import transforms
from torch.utils.data import TensorDataset, DataLoader | Digit Recognizer |
12,686,477 | for col in norminal_features:
train_set[col] = train_set[col].astype(str)
test_set[col] = test_set[col].astype(str)
train_set[col] = train_set[col].fillna('Unknown')
test_set[col] = test_set[col].fillna('Unknown' )<categorify> | epochs = 50
batch_size = 32
lr = 1e-3
momentum = 0.9
weight_decay = 1e-4
train_ratio = 0.8
device = torch.device("cuda" if torch.cuda.is_available() else "cpu" ) | Digit Recognizer |
12,686,477 | ohe = OneHotEncoder(handle_unknown = "ignore", sparse=False)
ohe_train_set = pd.DataFrame(ohe.fit_transform(train_set[norminal_features]))
ohe_test_set= pd.DataFrame(ohe.transform(test_set[norminal_features]))
ohe_train_set.index = train_set.index
ohe_test_set.index = test_set.index<drop_column> | train_df = np.array(pd.read_csv('/kaggle/input/digit-recognizer/train.csv'))
imgs = train_df[:,1:].reshape(-1, 28, 28)
labels = train_df[:,0]
imgs = np.expand_dims(imgs, axis=1)/ 255.0
num_train = int(imgs.shape[0] * train_ratio)
train_imgs = imgs[:num_train]
train_labels = labels[:num_train]
val_imgs = imgs[num_trai... | Digit Recognizer |
12,686,477 | train_set = train_set.drop(norminal_features, axis = 1)
test_set = test_set.drop(norminal_features, axis = 1 )<concatenate> | def conv_cell(cin, cout, k, s, p=None):
if not p:
p =(k-1)// 2
cell = nn.Sequential()
cell.add_module('conv', nn.Conv2d(in_channels=cin, out_channels=cout, kernel_size=k, stride=s, padding=p, bias=False))
cell.add_module('bn', nn.BatchNorm2d(cout))
cell.add_module('act', nn.ReLU())
return cell
net = nn.Sequential(
co... | Digit Recognizer |
12,686,477 | train_base = train_set.copy()
test_base = test_set.copy()
train_set = pd.concat([train_set, ohe_train_set], axis=1)
test_set = pd.concat([test_set, ohe_test_set], axis =1 )<count_missing_values> | loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters() , lr=lr, momentum=momentum, weight_decay=weight_decay ) | Digit Recognizer |
12,686,477 | test_set[discrete_features].isnull().sum()<count_missing_values> | def accuracy(dataloader, net):
total = 0
correct = 0
with torch.no_grad() :
for data in dataloader:
inputs, labels = data[0].to(device), data[1].to(device)
outputs = net(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct +=(predicted == labels ).sum().item()
return correct/total | Digit Recognizer |
12,686,477 | train_set[discrete_features].isnull().sum()
test_set[discrete_features].isnull().sum()
for col in discrete_features:
test_set[col] = test_set[col].fillna(0 )<drop_column> | best = 0
train_losses = []
train_accuracies = []
val_accuracies = []
for epoch in range(epochs):
tic = time.time()
epoch_loss = 0
for i, data in enumerate(train_loader):
inputs, labels = data[0].to(device), data[1].to(device)
optimizer.zero_grad()
outputs = net(inputs)
loss = loss_fn(outputs, labels)
loss.backward()... | Digit Recognizer |
12,686,477 | correlation_features = corr_cols.append(corr_cols_small ).drop('SalePrice' )<drop_column> | test_df = np.array(pd.read_csv('/kaggle/input/digit-recognizer/test.csv'))
test_imgs = test_df.reshape(-1, 28, 28)
test_imgs = np.expand_dims(test_imgs, axis=1)/ 255.0
test_dataset = TensorDataset(torch.tensor(test_imgs, dtype=torch.float))
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
... | Digit Recognizer |
12,686,477 | <define_variables><EOS> | num_test = len(test_results)
test_df = pd.DataFrame(np.vstack(( np.arange(1, num_test+1), np.array(test_results)) ).T, columns=['ImageId', 'Label'])
test_df.to_csv('submission.csv', index=False ) | Digit Recognizer |
12,354,348 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<split> | def load_train_data(split=.0):
with open('.. /input/digit-recognizer/train.csv')as file:
data = np.asarray([x.replace('
', '' ).split(',')for x in file.readlines() [1:]])
train_data = data.astype('float32')[:, 1:].reshape(( len(data), 28, 28, 1))
train_labels = to_categorical(data[:, 0])
indices = np.arange(l... | Digit Recognizer |
12,354,348 | train_x, val_x, train_y, val_y = train_test_split(train, target, train_size = 0.8, random_state = RANDOM_STATE )<normalization> | ( train_data, train_labels),(val_data, val_labels)= load_train_data(split=.2)
batch_size = 64
train_gen = ImageDataGenerator(
rescale=1./255,
rotation_range=10,
zoom_range=.1,
width_shift_range=.1,
height_shift_range=.1,
fill_mode='nearest' ).flow(
train_data, train_labels,
batch_size=batch_size)
val_gen ... | Digit Recognizer |
12,354,348 | std_scaler = StandardScaler()
std_scaler.fit(train_x)
train_x = std_scaler.transform(train_x)
val_x = std_scaler.transform(val_x)
test_set = std_scaler.transform(test_set)
<define_variables> | train_data, train_labels = load_train_data()
batch_size = 64
train_gen = ImageDataGenerator(
rescale=1./255,
rotation_range=10,
zoom_range=.1,
width_shift_range=.1,
height_shift_range=.1,
fill_mode='nearest' ).flow(
train_data, train_labels,
batch_size=batch_size)
model = get_model()
history = model.fit(tr... | Digit Recognizer |
12,354,348 | <split><EOS> | test_data = load_test_data()
model = models.load_model('mnist.h5')
predict = np.argmax(model.predict(test_data), axis=1)
confirm_submission(predict ) | Digit Recognizer |
13,111,649 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<normalization> | import tensorflow as tf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import os | Digit Recognizer |
13,111,649 | std_scaler_base = StandardScaler()
std_scaler_base.fit(train_x_base)
train_x_base = std_scaler_base.transform(train_x_base)
val_x_base = std_scaler_base.transform(val_x_base )<train_model> | train_input = ".. /input/digit-recognizer/train.csv"
test_input = ".. /input/digit-recognizer/test.csv"
train_dataset = pd.read_csv(train_input)
test_dataset = pd.read_csv(test_input ) | Digit Recognizer |
13,111,649 | logreg = LinearRegression()
start_time = time.time()
logreg.fit(train_x_base, train_y_base)
time_lapse = time.time() - start_time
model_type.append('LogReg Baseline')
model_train_time.append(time_lapse)
time_lapse
<predict_on_test> | train_labels = tf.keras.utils.to_categorical(train_dataset.pop("label")) | Digit Recognizer |
13,111,649 | logreg_pred_train = logreg.predict(train_x_base)
logreg_train_rmse = evaluation_metric(logreg_pred_train, train_y_base)
model_rmse_train.append(logreg_train_rmse)
logreg_train_rmse<predict_on_test> | train_dataset = np.array(train_dataset.values.reshape(-1, 28, 28, 1))
test_dataset = np.array(test_dataset.values.reshape(-1, 28, 28, 1)) | Digit Recognizer |
13,111,649 | start_time = time.time()
logreg_pred_val = logreg.predict(val_x_base)
time_lapse = time.time() - start_time
model_pred_time.append(time_lapse )<compute_test_metric> | train_dataset = train_dataset / 255.0
test_dataset = test_dataset / 255.0 | Digit Recognizer |
13,111,649 | %time logreg_val_rmse = evaluation_metric(logreg_pred_val, val_y_base )<concatenate> | checkpoint_path = "logs/checkpoints/" | Digit Recognizer |
13,111,649 | model_rmse_val.append(logreg_val_rmse)
logreg_val_rmse<create_dataframe> | model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(64,(3, 3), input_shape=(28, 28, 1), activation=tf.nn.relu, padding="SAME"),
tf.keras.layers.MaxPooling2D() ,
tf.keras.layers.Conv2D(64,(3, 3), activation=tf.nn.relu, padding="SAME"),
tf.keras.layers.MaxPooling2D() ,
tf.keras.layers.Dropout(0.5),
tf.keras.layer... | Digit Recognizer |
13,111,649 | result = pd.DataFrame(
{
'feature': model_type,
'train time': model_train_time,
'validation prediction time':model_pred_time,
'rmse train':model_rmse_train,
'rmse validation':model_rmse_val
}
)
result.sort_values(by='rmse validation' )<split> | model.load_weights(checkpoint_path ) | Digit Recognizer |
13,111,649 | train_x_corr, val_x_corr, train_y_corr, val_y_corr = train_test_split(train[correlation_features], target, train_size = 0.8, random_state = RANDOM_STATE)
logreg_corr = LinearRegression()
start_time = time.time()
logreg_corr.fit(train_x_corr, train_y_corr)
time_lapse = time.time() - start_time
model_type.append('LogRe... | labels = [np.argmax(predict)for predict in model.predict(test_dataset)]
df = pd.DataFrame({
"ImageId": list(range(1, len(test_dataset)+1)) ,
"Label": labels,
} ) | Digit Recognizer |
13,111,649 | logreg_corr_pred_train = logreg_corr.predict(train_x_corr)
logreg_corr_train_rmse = evaluation_metric(logreg_corr_pred_train, train_y_corr)
model_rmse_train.append(logreg_corr_train_rmse)
logreg_corr_train_rmse<predict_on_test> | df.to_csv("submission.csv", index=False ) | Digit Recognizer |
13,111,649 | <compute_train_metric><EOS> | model.save("model.h5" ) | Digit Recognizer |
14,439,479 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<create_dataframe> | %matplotlib inline
| Digit Recognizer |
14,439,479 | result = pd.DataFrame(
{
'feature': model_type,
'train time': model_train_time,
'validation prediction time':model_pred_time,
'rmse train':model_rmse_train,
'rmse validation':model_rmse_val
}
)
result.sort_values(by='rmse validation' )<compute_train_metric> | tf.__version__ | Digit Recognizer |
14,439,479 | def make_mi_scores(train_data, target_data):
mi_scores = mutual_info_regression(train_data, target_data)
mi_scores = pd.Series(mi_scores, name="MI Scores", index=train.columns)
mi_scores = mi_scores.sort_values(ascending=False)
return mi_scores
mi_scores = make_mi_scores(train_x, train_y)
mi_scores<filter> | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
sub = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
14,439,479 | mi_features = mi_scores[mi_scores > 0.1].index.values<split> | X = train.drop(['label'], axis=1 ).values
y = train['label'].values | Digit Recognizer |
14,439,479 | train_x_mi, val_x_mi, train_y_mi, val_y_mi = train_test_split(train[mi_features], target, train_size = 0.8, random_state = RANDOM_STATE)
logreg_mi = LinearRegression()
start_time = time.time()
logreg_mi.fit(train_x_mi, train_y_mi)
time_lapse = time.time() - start_time
model_type.append('LogReg - Mutual Information Fe... | train_X, val_X, train_y, val_y = train_test_split(X, y, test_size = 0.2 ) | Digit Recognizer |
14,439,479 | logreg_mi_pred_train = logreg_mi.predict(train_x_mi)
logreg_mi_train_rmse = evaluation_metric(logreg_mi_pred_train, train_y_mi)
model_rmse_train.append(logreg_mi_train_rmse)
logreg_mi_train_rmse<predict_on_test> | train_X = train_X.reshape(-1, 28, 28, 1 ).astype("float32")/255.0
val_X = val_X.reshape(-1, 28, 28, 1 ).astype("float32")/255.0
test = test.values.reshape(-1, 28, 28, 1 ).astype("float32")/255.0
train_y = tf.keras.utils.to_categorical(train_y)
val_y = tf.keras.utils.to_categorical(val_y ) | Digit Recognizer |
14,439,479 | start_time = time.time()
logreg_mi_pred_val = logreg_mi.predict(val_x_mi)
time_lapse = time.time() - start_time
model_pred_time.append(time_lapse )<compute_train_metric> | ! git clone https://github.com/bckenstler/CLR.git | Digit Recognizer |
14,439,479 | logreg_mi_val_rmse = evaluation_metric(logreg_mi_pred_val, val_y_mi)
model_rmse_val.append(logreg_mi_val_rmse)
logreg_mi_val_rmse<create_dataframe> | clr_triangular = CyclicLR(mode='triangular' ) | Digit Recognizer |
14,439,479 | result = pd.DataFrame(
{
'feature': model_type,
'train time': model_train_time,
'validation prediction time':model_pred_time,
'rmse train':model_rmse_train,
'rmse validation':model_rmse_val
}
)
result.sort_values(by='rmse validation' )<train_model> | class myCallback(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if(logs.get('accuracy')>0.9999):
print("
Reached 99.99% accuracy so cancelling training!")
self.model.stop_training = True
callbacks = myCallback()
learning_rate_reduction = tf.keras.callbacks.ReduceLROnPlateau(monitor = 'val_loss',... | Digit Recognizer |
14,439,479 | lreg = Lasso(random_state = RANDOM_STATE)
start_time = time.time()
lreg.fit(train_x, train_y)
time_lapse = time.time() - start_time
model_type.append('Lasso')
model_train_time.append(time_lapse)
time_lapse<predict_on_test> | IMG_SIZE = 28
BATCH_SIZE = 64
AUTOTUNE = tf.data.experimental.AUTOTUNE
num_classes = 10
def augment(image_label, seed):
image, label = image_label
image = tf.image.resize_with_crop_or_pad(
image,
IMG_SIZE + 6,
IMG_SIZE + 6
)
new_seed = tf.random.experimental.stateless_split(seed, num=1)[0,:]
image = tf.image.statele... | Digit Recognizer |
14,439,479 | lreg_pred_train = lreg.predict(train_x)
lreg_pred_train_rmse = evaluation_metric(lreg_pred_train, train_y)
model_rmse_train.append(lreg_pred_train_rmse)
lreg_pred_train_rmse<predict_on_test> | startTime = timeit.default_timer()
history = cnn_model.fit(
train_ds,
steps_per_epoch = train_X.shape[0] // BATCH_SIZE,
epochs = 50,
validation_data = val_ds,
validation_steps = val_X.shape[0] // BATCH_SIZE,
callbacks = [callbacks, learning_rate_reduction]
)
elapsedTime = timeit.default_timer() - startTime
print("Ti... | Digit Recognizer |
14,439,479 | start_time = time.time()
lreg_pred = lreg.predict(val_x)
time_lapse = time.time() - start_time
model_pred_time.append(time_lapse )<compute_test_metric> | startTime = timeit.default_timer()
history = cnn_model.fit(
train_ds,
steps_per_epoch = train_X.shape[0] // BATCH_SIZE,
epochs = 50,
validation_data = val_ds,
validation_steps = val_X.shape[0] // BATCH_SIZE,
callbacks = [clr_triangular]
)
elapsedTime = timeit.default_timer() - startTime
print("Time taken for the Net... | Digit Recognizer |
14,439,479 | lreg_rmse = evaluation_metric(lreg_pred, val_y)
model_rmse_val.append(lreg_rmse)
lreg_rmse<create_dataframe> | prediction = cnn_model.predict(test ).argmax(axis=1)
sub['Label'] = prediction
sub.to_csv("MNIST_sub_cnn1.csv", index=False)
sub.head() | Digit Recognizer |
14,184,820 | result = pd.DataFrame(
{
'feature': model_type,
'train time': model_train_time,
'validation prediction time':model_pred_time,
'rmse train':model_rmse_train,
'rmse validation':model_rmse_val
}
)
result.sort_values(by='rmse validation' )<train_model> | np.random.seed(42)
torch.random.seed = 42 | Digit Recognizer |
14,184,820 | rfr=RandomForestRegressor(max_features=0.4, n_estimators=1000, random_state=RANDOM_STATE)
start_time = time.time()
rfr.fit(train_x, train_y)
time_lapse = time.time() - start_time
model_type.append('Random Forest')
model_train_time.append(time_lapse)
time_lapse<predict_on_test> | train_df = pd.read_csv(dirname+'/train.csv')
test_df = pd.read_csv(dirname + '/test.csv')
train_df.head() | Digit Recognizer |
14,184,820 | rfr_pred_train = rfr.predict(train_x)
rfr_pred_train_rmse = evaluation_metric(rfr_pred_train, train_y)
model_rmse_train.append(rfr_pred_train_rmse)
rfr_pred_train_rmse<predict_on_test> | train = train_df.to_numpy()
test = test_df.to_numpy() | Digit Recognizer |
14,184,820 | start_time = time.time()
rfr_pred_val = rfr.predict(val_x)
time_lapse = time.time() - start_time
model_pred_time.append(time_lapse)
<compute_test_metric> | @Transform
def get_label(a):
return a[0]
@Transform
def get_x(a):
return a[-28*28:]
@Transform
def nums_to_tensor(a):
return TensorImageBW(torch.from_numpy(a ).view(1,28,28))
| Digit Recognizer |
14,184,820 | rfr_rmse = evaluation_metric(rfr_pred_val, val_y)
model_rmse_val.append(rfr_rmse)
rfr_rmse<create_dataframe> | x_tfms = [get_x,nums_to_tensor, ]
y_tfms = [get_label, Categorize]
cut = int(len(train)*0.8)
splits = [list(range(cut)) , list(range(cut,len(train)-1)) ]
bs = 128 | Digit Recognizer |
14,184,820 | result = pd.DataFrame(
{
'feature': model_type,
'train time': model_train_time,
'validation prediction time':model_pred_time,
'rmse train':model_rmse_train,
'rmse validation':model_rmse_val
}
)
result.sort_values(by='rmse validation' )<train_model> | dsets = Datasets(train,[x_tfms, y_tfms], splits = splits)
dls = dsets.dataloaders(bs=bs, after_batch=[IntToFloatTensor() ,*aug_transforms(do_flip=False,batch=True,), Normalize.from_stats(*mnist_stats)] ) | Digit Recognizer |
14,184,820 | mnet = MLPRegressor(hidden_layer_sizes=(200,200,100, 100, 50, 25), activation = 'logistic', alpha = 0.001, max_iter = 1000, early_stopping = True, random_state = RANDOM_STATE)
start_time = time.time()
mnet.fit(train_x, train_y)
time_lapse = time.time() - start_time
model_type.append('Neural Net')
model_train_time.ap... | test_dl =dls.test_dl(test ) | Digit Recognizer |
14,184,820 | mnet_pred_train = mnet.predict(train_x)
mnet_pred_train_rmse = evaluation_metric(mnet_pred_train, train_y)
model_rmse_train.append(mnet_pred_train_rmse)
mnet_pred_train_rmse<predict_on_test> | model = xresnet18(c_in=1,n_out=10, sa=True, act_cls=Mish ) | Digit Recognizer |
14,184,820 | start_time = time.time()
mnet_pred_val = mnet.predict(val_x)
time_lapse = time.time() - start_time
model_pred_time.append(time_lapse )<compute_test_metric> | learn = Learner(dls,model, loss_func=CrossEntropyLossFlat() , metrics=accuracy, ) | Digit Recognizer |
14,184,820 | mnet_rmse = evaluation_metric(mnet_pred_val, val_y)
model_rmse_val.append(mnet_rmse)
mnet_rmse<create_dataframe> | lr_min, lr_steep = learn.lr_find() ;lr_min, lr_steep | Digit Recognizer |
14,184,820 | result = pd.DataFrame(
{
'feature': model_type,
'train time': model_train_time,
'validation prediction time':model_pred_time,
'rmse train':model_rmse_train,
'rmse validation':model_rmse_val
}
)
result.sort_values(by='rmse validation' )<train_model> | learn.fit_one_cycle(20,lr_min ) | Digit Recognizer |
14,184,820 | params = {'n_estimators': 1000,
'max_depth': 5,
'min_samples_split': 6,
'learning_rate': 0.01,
'loss': 'ls',
'max_features':0.25,
'random_state':RANDOM_STATE}
gbm = GradientBoostingRegressor(**params)
start_time = time.time()
gbm.fit(train_x, train_y)
time_lapse = time.time() - start_time
model_type.append('Gradient ... | learn.save('20epoch_Xresnet18-sa' ) | Digit Recognizer |
14,184,820 | gbm_pred_train = gbm.predict(train_x)
gbm_pred_train_rmse = evaluation_metric(gbm_pred_train, train_y)
model_rmse_train.append(gbm_pred_train_rmse)
gbm_pred_train_rmse<predict_on_test> | learn = learn.load('20epoch_Xresnet18-sa' ) | Digit Recognizer |
14,184,820 | start_time = time.time()
gbm_pred_val = gbm.predict(val_x)
time_lapse = time.time() - start_time
model_pred_time.append(time_lapse )<compute_test_metric> | learn.fit_one_cycle(2,lr_min/50 ) | Digit Recognizer |
14,184,820 | gbm_rmse = evaluation_metric(gbm_pred_val, val_y)
model_rmse_val.append(gbm_rmse)
gbm_rmse<create_dataframe> | learn.save('20+2epoch_Xresnet18-sa' ) | Digit Recognizer |
14,184,820 | result = pd.DataFrame(
{
'feature': model_type,
'train time': model_train_time,
'validation prediction time':model_pred_time,
'rmse train':model_rmse_train,
'rmse validation':model_rmse_val
}
)
result.sort_values(by='rmse validation' )<train_model> | preds,targets = learn.tta()
accuracy(preds,targets ) | Digit Recognizer |
14,184,820 | param = {'n_estimators': 1000,
'max_depth': 5,
'learning_rate': 0.01,
'random_state':RANDOM_STATE}
xgb = XGBRegressor(**param)
start_time = time.time()
xgb.fit(train_x, train_y, eval_set=[(train_x, train_y),(val_x, val_y)], early_stopping_rounds = 5, eval_metric = 'rmse')
time_lapse = time.time() - start_time
model_t... | preds,_ = learn.tta(dl=test_dl ) | Digit Recognizer |
14,184,820 | xgb_pred_train = xgb.predict(train_x)
xgb_pred_train_rmse = evaluation_metric(xgb_pred_train, train_y)
model_rmse_train.append(xgb_pred_train_rmse)
xgb_pred_train_rmse<predict_on_test> | class_preds =np.argmax(preds,axis=1)
pred_submission = [dls.vocab[i] for i in class_preds] | Digit Recognizer |
14,184,820 | <compute_test_metric><EOS> | submission = pd.read_csv(dirname+'/sample_submission.csv')
submission['Label']=pred_submission
submission.to_csv('submission.csv',index=False ) | Digit Recognizer |
13,630,920 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<create_dataframe> | %matplotlib inline
| Digit Recognizer |
13,630,920 | result = pd.DataFrame(
{
'feature': model_type,
'train time': model_train_time,
'validation prediction time':model_pred_time,
'rmse train':model_rmse_train,
'rmse validation':model_rmse_val
}
)
result.sort_values(by='rmse validation' )<predict_on_test> | train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('Training on CPU...')
else:
print('Training on GPU...')
| Digit Recognizer |
13,630,920 | test_pred = gbm.predict(test_set)
test_result = pd.DataFrame(
{
'Id': test_set_Id,
'SalePrice': np.exp(test_pred),
} )<save_to_csv> | device = torch.device('cuda:0' ) | Digit Recognizer |
13,630,920 | test_result.to_csv('submission_gbm.csv', index=False )<load_from_csv> | df_train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
df_test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
13,630,920 | p_train = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/train.csv')
p_test = pd.read_csv('/kaggle/input/house-prices-advanced-regression-techniques/test.csv' )<feature_engineering> | df_train.isna().any().any() | Digit Recognizer |
13,630,920 | def create_new_columns(dataset):
dataset['total_square_footage'] = dataset['TotalBsmtSF'] + dataset['GrLivArea']
dataset['remodelling_done'] = dataset.apply(lambda x: verify_remodelling(x['YearRemodAdd'], x['YearBuilt']), axis=1)
dataset['selling_season'] = dataset.apply(lambda x: selling_period(x['MoSold']), axis=1)
... | train_data = df_train.drop('label',axis=1 ).values | Digit Recognizer |
13,630,920 | target = target_feature(p_train )<categorify> | train_data = train_data/255.0
df_test = df_test/255.0 | Digit Recognizer |
13,630,920 | pipes = Pipeline(steps = [('new_columns', FunctionTransformer(create_new_columns)) ,
('continious_cleanup', FunctionTransformer(log_continious)) ,
('nominal_filling', FunctionTransformer(nominal_one_hot)) ,
('discrete_filling',FunctionTransformer(discrete_fill)) ,
('ordinal_cleanup', FunctionTransformer(map_ordinal... | mask = np.random.rand(len(df_train)) < 0.8
df_val = df_train[~mask]
df_train = df_train[mask]
print('Train size: ', df_train.shape)
print('Val size: ', df_val.shape)
print('Test size: ', df_test.shape)
df_train.head() | Digit Recognizer |
13,630,920 | p_train = pipes.transform(p_train )<categorify> | class DatasetMNIST(torch.utils.data.Dataset):
def __init__(self, data, transform=None):
self.data = data
self.transform = transform
def __len__(self):
return len(self.data)
def __getitem__(self, index):
item = self.data.iloc[index]
image = item[1:].values.astype(np.uint8 ).reshape(( 28, 28))
label = item[0]
if self.tr... | Digit Recognizer |
13,630,920 | p_test = pipes.transform(p_test )<split> | train_transform = transforms.Compose(
[
transforms.ToPILImage() ,
transforms.ToTensor() ,
transforms.Normalize(mean=train_data.mean() , std=train_data.std()),
])
val_transform = transforms.Compose(
[
transforms.ToPILImage() ,
transforms.ToTensor() ,
transforms.Normalize(mean=train_data.mean() , std=train_data.std())... | Digit Recognizer |
13,630,920 | p_test_Id = p_test['Id']
p_train = p_train.drop(columns=['SalePrice', 'Id'])
p_test = p_test.drop(columns = 'Id')
p_train_x, p_val_x, p_train_y, p_val_y = train_test_split(p_train, target, train_size=0.8, test_size=0.2, random_state = RANDOM_STATE )<categorify> | train_dataset = DatasetMNIST(df_train, transform = train_transform)
validation_dataset = DatasetMNIST(df_val, transform = val_transform)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=16)
validation_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=16)
| Digit Recognizer |
13,630,920 | categorical_transformer = OneHotEncoder(handle_unknown = "ignore", sparse=False)
numeric_transformer = Pipeline(steps=[
('scaler', StandardScaler())])
preprocessor = ColumnTransformer(remainder='passthrough',
transformers=[
('num', numeric_transformer, selector(dtype_exclude="object")) ,
('cat', categorical_transf... | class CNN(nn.Module):
def __init__(self):
super(CNN,self ).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(1, 32, 3, padding=1),
nn.ReLU() ,
nn.BatchNorm2d(32),
nn.Conv2d(32, 32, 3, stride=2, padding=1),
nn.ReLU() ,
nn.BatchNorm2d(32),
nn.MaxPool2d(2, 2),
nn.Dropout(0.25)
)
self.conv2 = nn.Sequential(
nn.Conv2d(32,... | Digit Recognizer |
13,630,920 | params = {'n_estimators': 1000,
'max_depth': 5,
'min_samples_split': 6,
'learning_rate': 0.01,
'loss': 'ls',
'max_features':0.25,
'random_state':RANDOM_STATE}
model_gbm = GradientBoostingRegressor(**params)
gbm_pipeline = Pipeline(steps=[
('preprocess', preprocessor),
('model', model_gbm)
])
gbm_pipeline.fit(p_tra... | LEARNING_RATE = 0.001680
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters() , lr=LEARNING_RATE ) | Digit Recognizer |
13,630,920 | p_test_gbm = gbm_pipeline.predict(p_test)
test_result = pd.DataFrame(
{
'Id': p_test_Id,
'SalePrice': np.exp(p_test_gbm),
})
test_result.to_csv('pipeline_gbm.csv', index=False)
<install_modules> | def train_model(model,train_loader, validation_loader, optimizer, n_epochs=100):
N_test=len(validation_dataset)
accuracy_list=[]
loss_list=[]
for epoch in range(n_epochs):
for x, y in train_loader:
x, y = x.to(device), y.to(device)
model.train()
optimizer.zero_grad()
z = model(x)
loss = criterion(z, y)
loss.backwar... | Digit Recognizer |
13,630,920 | !pip install.. /input/python-datatable/datatable-0.11.0-cp37-cp37m-manylinux2010_x86_64.whl > /dev/null 2>&1<set_options> | accuracy_list, loss_list=train_model(model=model,n_epochs=100,train_loader=train_loader,validation_loader=validation_loader,optimizer=optimizer ) | Digit Recognizer |
13,630,920 | _ = np.seterr(divide='ignore', invalid='ignore')
<define_variables> | print(accuracy_list, loss_list ) | Digit Recognizer |
13,630,920 | data_types_dict = {
'timestamp': 'int64',
'user_id': 'int32',
'content_id': 'int16',
'content_type_id':'int8',
'task_container_id': 'int16',
'answered_correctly': 'int8',
'prior_question_elapsed_time': 'float32',
'prior_question_had_explanation': 'bool'
}
target = 'answered_correctly'
<load_from_csv> | test_dataset = DatasetMNIST(df_test, transform = val_transform)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=16 ) | Digit Recognizer |
13,630,920 | print('start read train data...')
train_df = dt.fread('.. /input/riiid-test-answer-prediction/train.csv', columns=set(data_types_dict.keys())).to_pandas()
<load_from_csv> | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x_test = np.expand_dims(x_test, axis=1)
x_test = torch.from_numpy(x_test ).float().to(device)
x_test.type() | Digit Recognizer |
13,630,920 | lectures_df = pd.read_csv('/kaggle/input/riiid-test-answer-prediction/lectures.csv')
<categorify> | model.eval()
with torch.no_grad() :
ps = model(x_test)
prediction = torch.argmax(ps, 1)
print('Prediction',prediction ) | Digit Recognizer |
13,630,920 | lectures_df['type_of'] = lectures_df['type_of'].replace('solving question', 'solving_question')
lectures_df = pd.get_dummies(lectures_df, columns=['part', 'type_of'])
part_lectures_columns = [column for column in lectures_df.columns if column.startswith('part')]
types_of_lectures_columns = [column for column in lectu... | df_export = pd.DataFrame(prediction.cpu().tolist() , columns = ['Label'])
df_export['ImageId'] = df_export.index +1
df_export = df_export[['ImageId', 'Label']]
df_export.head() | Digit Recognizer |
13,630,920 | train_lectures = train_df[train_df.content_type_id == True].merge(lectures_df, left_on='content_id', right_on='lecture_id', how='left')
user_lecture_stats_part = train_lectures.groupby('user_id',as_index = False)[part_lectures_columns + types_of_lectures_columns].sum()
<data_type_conversions> | df_export.to_csv('output.csv', index=False ) | Digit Recognizer |
14,296,580 | lecturedata_types_dict = {
'user_id': 'int32',
'part_1': 'int8',
'part_2': 'int8',
'part_3': 'int8',
'part_4': 'int8',
'part_5': 'int8',
'part_6': 'int8',
'part_7': 'int8',
'type_of_concept': 'int8',
'type_of_intention': 'int8',
'type_of_solving_question': 'int8',
'type_of_starter': 'int8'
}
user_lecture_stats_part = u... | %matplotlib inline | Digit Recognizer |
14,296,580 | for column in user_lecture_stats_part.columns:
if(column !='user_id'):
user_lecture_stats_part[column] =(user_lecture_stats_part[column] > 0 ).astype('int8')
user_lecture_stats_part.dtypes
<drop_column> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' ) | Digit Recognizer |
14,296,580 | del(train_lectures)
gc.collect()
<data_type_conversions> | train_set = train.iloc[:,1:]
label = train["label"] | Digit Recognizer |
14,296,580 | user_lecture_agg = train_df.groupby('user_id')['content_type_id'].agg(['sum', 'count'])
user_lecture_agg=user_lecture_agg.astype('int16')
<data_type_conversions> | norm_train_set = train_set / 255
norm_test_set = test / 255 | Digit Recognizer |
14,296,580 | cum = train_df.groupby('user_id')['content_type_id'].agg(['cumsum', 'cumcount'])
cum['cumcount']=cum['cumcount']+1
train_df['user_interaction_count'] = cum['cumcount']
train_df['user_interaction_timestamp_mean'] = train_df['timestamp']/cum['cumcount']
train_df['user_lecture_sum'] = cum['cumsum']
train_df['user_lecture... | X_train, X_validate, y_train, y_validate = train_test_split(norm_train_set, label, test_size = 0.1 ) | Digit Recognizer |
14,296,580 | del cum
gc.collect()<data_type_conversions> | X_train = torch.from_numpy(X_train.values.reshape(-1,1,28,28))
X_validate = torch.from_numpy(X_validate.values.reshape(-1,1,28,28))
testing_set = torch.from_numpy(norm_test_set.values.reshape(-1,1,28,28))
y_train = torch.from_numpy(y_train.values)
y_validate = torch.from_numpy(y_validate.values ) | Digit Recognizer |
14,296,580 | train_df['prior_question_had_explanation'].fillna(False, inplace=True)
train_df = train_df.astype(data_types_dict)
train_df = train_df[train_df[target] != -1].reset_index(drop=True)
<groupby> | training_set = torch.utils.data.TensorDataset(X_train.float() , y_train)
validating_set = torch.utils.data.TensorDataset(X_validate.float() , y_validate)
testing_set = torch.utils.data.TensorDataset(testing_set.float() ) | Digit Recognizer |
14,296,580 | content_explation_agg=train_df[["content_id","prior_question_had_explanation",target]].groupby(["content_id","prior_question_had_explanation"])[target].agg(['mean'])
<data_type_conversions> | train_loader = DataLoader(training_set, shuffle=True, batch_size = 88)
validate_loader = DataLoader(validating_set, shuffle=False, batch_size = 88)
test_set = DataLoader(testing_set, shuffle=False, batch_size = 88 ) | Digit Recognizer |
14,296,580 | content_explation_agg=content_explation_agg.unstack()
content_explation_agg=content_explation_agg.reset_index()
content_explation_agg.columns = ['content_id', 'content_explation_false_mean','content_explation_true_mean']
content_explation_agg.content_id=content_explation_agg.content_id.astype('int16')
content_explatio... | class CNN_DigitClassifier(nn.Module):
def __init__(self):
super(CNN_DigitClassifier, self ).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 32, 5),
nn.ReLU(inplace=True),
nn.Conv2d(32, 32, 5),
nn.ReLU(inplace=True),
nn.MaxPool2d(2,2),
nn.Dropout(0.25),
nn.Conv2d(32, 64, 3),
nn.ReLU(inplace=True),
nn.Conv2d(64, ... | Digit Recognizer |
14,296,580 | train_df["attempt_no"] = 1
train_df.attempt_no=train_df.attempt_no.astype('int8')
attempt_no_agg=train_df.groupby(["user_id","content_id"])["attempt_no"].agg(['sum'] ).astype('int8')
train_df["attempt_no"] = train_df[["user_id","content_id",'attempt_no']].groupby(["user_id","content_id"])["attempt_no"].cumsum()
attem... | model = CNN_DigitClassifier()
optimizer = optim.RMSprop(model.parameters() , lr=0.001, alpha=0.9)
criterion = nn.CrossEntropyLoss()
lr_reduction = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=3, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0.00001)
if torch.cuda.is_av... | Digit Recognizer |
14,296,580 | print('start handle timestamp...')
prior_question_elapsed_time_mean=train_df['prior_question_elapsed_time'].mean()
train_df['prior_question_elapsed_time'].fillna(prior_question_elapsed_time_mean, inplace=True)
<data_type_conversions> | count = 0
losses = []
iteration_list = []
training_accuracy = []
validation_accuracy = []
training_loss = []
validation_loss = [] | Digit Recognizer |
14,296,580 | max_timestamp_u = train_df[['user_id','timestamp']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u.columns = ['user_id', 'max_time_stamp']
max_timestamp_u.user_id=max_timestamp_u.user_id.astype('int32')
train_df['lagtime'] = train_df.groupby('user_id')['timestamp'].shift()
max_timestamp_u2 = train_d... | def train(epoch):
global count
model.train()
for batch_idx,(data, target)in enumerate(train_loader):
data, target = Variable(data), Variable(target)
if torch.cuda.is_available() :
data = data.cuda()
target = target.cuda()
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
opt... | Digit Recognizer |
14,296,580 | train_df['lagtime2'] = train_df.groupby('user_id')['timestamp'].shift(2)
max_timestamp_u3 = train_df[['user_id','lagtime2']].groupby(['user_id'] ).agg(['max'] ).reset_index()
max_timestamp_u3.columns = ['user_id', 'max_time_stamp3']
max_timestamp_u3.user_id=max_timestamp_u3.user_id.astype('int32')
train_df['lagtime2'... | def evaluate(data_loader, validate=False):
model.eval()
loss = 0
correct = 0
for data, target in data_loader:
data, target = Variable(data), Variable(target)
if torch.cuda.is_available() :
data = data.cuda()
target = target.cuda()
output = model(data)
loss += F.cross_entropy(output, target, size_average=False ).item(... | Digit Recognizer |
14,296,580 | train_df['timestamp']=train_df['timestamp']/(1000*3600)
train_df.timestamp=train_df.timestamp.astype('float16')
user_prior_question_elapsed_time = train_df[['user_id','prior_question_elapsed_time']].groupby(['user_id'] ).tail(1)
user_prior_question_elapsed_time.columns = ['user_id', 'prior_question_elapsed_time']
tr... | def prediction(data_loader):
model.eval()
test_pred = torch.LongTensor()
for batch_idx, data in enumerate(data_loader):
data = Variable(data[0])
if torch.cuda.is_available() :
data = data.cuda()
output = model(data)
pred = output.cpu().data.max(1, keepdim=True)[1]
test_pred = torch.cat(( test_pred, pred), dim=0)
ret... | Digit Recognizer |
14,296,580 | train_df.prior_question_had_explanation=train_df.prior_question_had_explanation.astype('int8')
explanation_agg = train_df.groupby('user_id')['prior_question_had_explanation'].agg(['sum', 'count'])
explanation_agg=explanation_agg.astype('int16' )<data_type_conversions> | test_prediction = prediction(test_set ) | Digit Recognizer |
14,296,580 | cum = train_df.groupby('user_id')['prior_question_had_explanation'].agg(['cumsum', 'cumcount'])
cum['cumcount']=cum['cumcount']+1
train_df['explanation_mean'] = cum['cumsum'] / cum['cumcount']
train_df['explanation_true_count'] = cum['cumsum']
train_df['explanation_false_count'] = cum['cumcount']-cum['cumsum']
train_d... | submission.to_csv("CNN_model_TPU_submission.csv", index = False ) | Digit Recognizer |
14,584,011 | del cum
gc.collect()<categorify> | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
train.head() | Digit Recognizer |
14,584,011 | content_agg = train_df.groupby('content_id')[target].agg(['sum', 'count','var'])
task_container_agg = train_df.groupby('task_container_id')[target].agg(['sum', 'count','var'])
content_agg=content_agg.astype('float32')
task_container_agg=task_container_agg.astype('float32' )<data_type_conversions> | Y_train = to_categorical(train['label'].values, 10)
X_train =(train.loc[:, 'pixel0':] / 255 ).values
X_train.shape, Y_train.shape | Digit Recognizer |
14,584,011 | train_df['task_container_uncor_count'] = train_df['task_container_id'].map(task_container_agg['count']-task_container_agg['sum'] ).astype('int32')
train_df['task_container_cor_count'] = train_df['task_container_id'].map(task_container_agg['sum'] ).astype('int32')
train_df['task_container_std'] = train_df['task_contai... | X_test =(test / 255 ).values | Digit Recognizer |
14,584,011 | questions_df = pd.read_csv(
'.. /input/riiid-test-answer-prediction/questions.csv',
usecols=[0, 1,3,4],
dtype={'question_id': 'int16','bundle_id': 'int16', 'part': 'int8','tags': 'str'}
)
bundle_agg = questions_df.groupby('bundle_id')['question_id'].agg(['count'])
questions_df['content_sub_bundle'] = questions_df['... | datagener = ImageDataGenerator(
rotation_range=15,
zoom_range=0.1,
width_shift_range=0.1,
height_shift_range=0.1,
) | Digit Recognizer |
14,584,011 | def gettags(tags,num):
tags_splits=tags.split(" ")
result=''
for t in tags_splits:
x=int(t)
if(x<32*(num+1)and x>=32*num):
result=result+' '+t
return result
<categorify> | example = X_train[6].reshape(( 1, 28, 28, 1))
label = Y_train[6] | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.