kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
7,429,783 | pd.set_option('display.max_columns', 100)
pd.set_option('display.max_rows', 100)
seed = 42
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
if not os.path.exists("results"):
os.mkdir("results")
TRAINING = True
read_path = '/kagg... | results=classifier.predict_classes(df_test)
print(results)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission.csv",index=False,header=True ) | Digit Recognizer |
7,429,783 | TRAINING = True<data_type_conversions> | ( X_train,y_train),(X_test,y_test)=mnist.load_data()
print(X_train.shape)
print(X_test.shape)
print(type(X_train))
img=X_train[0]
plt.imshow(img,cmap='gray')
print(type(img)) | Digit Recognizer |
7,429,783 | train = pd.read_csv(read_path)
features = [c for c in train.columns if 'feature' in c]
f_mean = train[features].mean()
train = train.loc[train.weight > 0].reset_index(drop = True)
train[features] = train[features].fillna(f_mean)
train = train.astype("float32")
train['action'] =(train['resp'] > 0 ).astype('int')
tr... | X_train=X_train.reshape(60000,28,28,1)
X_test=X_test.reshape(10000,28,28,1)
y_cat_train=to_categorical(y_train,10)
y_cat_test=to_categorical(y_test,10 ) | Digit Recognizer |
7,429,783 | test = train.loc[(train.date >= 450)&(train.date < 500)].reset_index(drop=True)
<data_type_conversions> | classifier.fit(X_train,y_cat_train,epochs=25 ) | Digit Recognizer |
7,429,783 | class MyDataset:
def __init__(self, df, features, targets):
self.features = df[features].values
self.labels = df[targets].values
self.weights = df['weight'].values
def __len__(self):
return len(self.labels)
def __getitem__(self, idx):
feat_ = torch.tensor(self.features[idx], dtype=torch.float)
label_ = torch.tensor(s... | results=classifier.predict_classes(df_test)
print(results)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission1.csv",index=False,header=True ) | Digit Recognizer |
7,429,783 | class Model(nn.Module):
def __init__(self, all_feat_cols, target_cols):
super(Model, self ).__init__()
self.batch_norm0 = nn.BatchNorm1d(len(all_feat_cols))
self.dropout0 = nn.Dropout(0.1)
dropout_rate = 0.1
hidden_size = 256
self.dense1 = nn.Linear(len(all_feat_cols), hidden_size)
self.batch_norm1 = nn.BatchNorm1d(h... | classifier.fit(X_test,y_cat_test,epochs=25 ) | Digit Recognizer |
7,429,783 | <split><EOS> | results=classifier.predict_classes(df_test)
print(results)
results = pd.Series(results,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),results],axis = 1)
submission.to_csv("submission2.csv",index=False,header=True ) | Digit Recognizer |
4,208,051 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<find_best_params> | print('Working on "%s"' % Path('.' ).absolute() ) | Digit Recognizer |
4,208,051 | if not TRAINING:
models = []
for i in [0, 1, 2, 3, 4]:
torch.cuda.empty_cache()
device = torch.device("cuda:0")
model = Model(train_features, targets)
model.to(device)
model.eval()
ckp_path = f'/kaggle/input/skeleton-with-pytorch/JSModel_{i}.pth'
model.load_state_dict(torch.load(ckp_path))
models.append(model )<find... | class NumpyImageList(ImageList):
def open(self, fn):
img = fn.reshape(28,28,1)
return Image(pil2tensor(img, dtype=np.float32))
@classmethod
def from_csv(cls, path:PathOrStr, csv:str, **kwargs)->'ItemList':
df = pd.read_csv(Path(path)/csv, header='infer')
res = super().from_df(df, path=path, cols=0, **kwargs)
if 'lab... | Digit Recognizer |
4,208,051 | if TRAINING:
models = []
for i in [1, 3]:
torch.cuda.empty_cache()
device = torch.device("cuda:0")
model = Model(train_features, targets)
model.to(device)
model.eval()
ckp_path = f'./JSModel_{i}.pth'
model.load_state_dict(torch.load(ckp_path))
models.append(model )<categorify> | test = NumpyImageList.from_csv('.. /input/', 'test.csv')
test | Digit Recognizer |
4,208,051 | models = [models[1], models[3], models[2]]
batch_size = 4096
label_smoothing = 1e-2
loss_fn = SmoothBCEwLogits(smoothing=label_smoothing)
test_pred = np.zeros(( len(test), len(targets)))
test_set = MyDataset(test, train_features, targets)
test_loader = DataLoader(test_set, batch_size=4096, shuffle=False, num_workers... | tfms = get_transforms(do_flip=False)
data =(NumpyImageList.from_csv('.. /input/', 'train.csv')
.split_by_rand_pct (.1)
.label_from_df(cols='label')
.add_test(test, label=0)
.transform(tfms)
.databunch(bs=128, num_workers=0)
.normalize(imagenet_stats))
data | Digit Recognizer |
4,208,051 | env = janestreet.make_env()
env_iter = env.iter_test()
th = 0.5
for(test_df, pred_df)in tqdm(env_iter):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, features].values
if np.isnan(x_tt.sum()):
x_tt = np.nan_to_num(x_tt)+ np.isnan(x_tt)* f_mean.values.reshape(1, -1)
feature_inp = pd.DataFrame(x_tt)
feature_inp... | data.show_batch(rows=5, figsize=(10,10)) | Digit Recognizer |
4,208,051 | import os
import time
import pickle
import random
import numpy as np
import pandas as pd
from tqdm import tqdm
from sklearn.metrics import log_loss, roc_auc_score
import torch
import torch.nn as nn
from torch.autograd import Variable
from torch.utils.data import DataLoader
from torch.nn import CrossEntropyLoss, MSELoss... | dropout = 0.25
model = nn.Sequential(
nn.Conv2d(in_channels=3,
out_channels=32,
kernel_size=5),
nn.ReLU() ,
nn.BatchNorm2d(32),
nn.MaxPool2d(kernel_size=2,
stride=2),
nn.Dropout(dropout),
nn.Conv2d(in_channels=32,
out_channels=64,
kernel_size=3),
nn.ReLU() ,
nn.BatchNorm2d(64),
nn.MaxPool2d(kernel_size=2,
stride=2),
n... | Digit Recognizer |
4,208,051 | from tensorflow.keras.layers import Input, Dense, BatchNormalization, Dropout, Concatenate, Lambda, GaussianNoise, Activation
from tensorflow.keras.models import Model, Sequential
from tensorflow.keras.losses import BinaryCrossentropy
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import E... | learn.fit_one_cycle(20, max_lr=slice(1e-1)) | Digit Recognizer |
4,208,051 | SEED = 1111
tf.random.set_seed(SEED)
np.random.seed(SEED)
train = pd.read_csv('/kaggle/input/jane-street-market-prediction/train.csv')
train = train.query('date > 85' ).reset_index(drop = True)
train = train[train['weight'] != 0]
features_mean = []
features = [c for c in train.columns if 'feature' in c]
for i in fe... | learn.save('stage1' ) | Digit Recognizer |
4,208,051 | epochs = 200
batch_size = 4096
hidden_units = [160, 160, 160]
dropout_rates = [0.20, 0.20, 0.20, 0.20]
label_smoothing = 1e-2
learning_rate = 1e-3<choose_model_class> | learn.fit_one_cycle(5, max_lr=slice(1e-2)) | Digit Recognizer |
4,208,051 | def create_mlp(
num_columns, num_labels, hidden_units, dropout_rates, label_smoothing, learning_rate
):
inp = tf.keras.layers.Input(shape=(num_columns,))
x = tf.keras.layers.BatchNormalization()(inp)
x = tf.keras.layers.Dropout(dropout_rates[0] )(x)
for i in range(len(hidden_units)) :
x = tf.keras.layers.Dense(hidd... | learn.save('stage2' ) | Digit Recognizer |
4,208,051 | tf.keras.backend.clear_session()
tf.random.set_seed(SEED)
clf = create_mlp(
len(features), 5, hidden_units, dropout_rates, label_smoothing, learning_rate
)
clf.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, verbose=2 )<feature_engineering> | predictions, *_ = learn.get_preds(DatasetType.Test)
labels = np.argmax(predictions, 1)
submission_df = pd.DataFrame({'ImageId': list(range(1,len(labels)+1)) , 'Label': labels})
submission_df.to_csv(f'submission.csv', index=False ) | Digit Recognizer |
5,844,541 | models = []
models.append(clf)
th = 0.503
f = np.median
f_mean = np.mean(train[features[1:]].values,axis=0)
env = janestreet.make_env()
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, features].values
if np.isnan(x_tt[:, 1:].sum()):
x_tt[:, 1:] = np.nan_to_num(x_t... | %matplotlib inline
np.random.seed(2)
sns.set(style='white', context='notebook', palette='deep' ) | Digit Recognizer |
5,844,541 | df = dtable.fread('/kaggle/input/jane-street-market-prediction/train.csv' ).to_pandas()
df = df.query('date > 85' ).reset_index(drop = True)
df = df[df.weight > 0]
df.reset_index(inplace=True, drop=True)
df = df.astype({c: np.float32 for c in df.select_dtypes(include='float64' ).columns})
df_labels = df[['date', 'we... | train=pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test=pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
5,844,541 | class Model(nn.Module):
def __init__(self, input_size):
super(Model, self ).__init__()
hs = 256
self.batch_norm0 = nn.BatchNorm1d(input_size)
self.layer1 = LinBnDrop(input_size, hs, bn=True, p=0, act=Mish() , lin_first=False)
self.layer2 = LinBnDrop(hs + input_size, hs, bn=True, p=0.2289, act=Mish() , lin_first=False... | def load_data() :
path='/kaggle/input/mnist-numpy/mnist.npz'
f = np.load(path)
x_train, y_train = f['x_train'], f['y_train']
x_test, y_test = f['x_test'], f['y_test']
f.close()
return(x_train, y_train),(x_test, y_test ) | Digit Recognizer |
5,844,541 | model_nn = Model(len(features))
model_nn = model_nn.to(device)
learn = Learner(None, model_nn, loss_func=1)
learn.load('/kaggle/input/roclossjs3/dense_model')
<categorify> | Y_train=train["label"]
X_train=train.drop("label",axis=1)
(x_train1,y_train1),(x_test1,y_test1)=load_data()
train1=np.concatenate([x_train1,x_test1],axis=0)
y_train1=np.concatenate([y_train1,y_test1],axis=0)
Y_train1=y_train1
X_train1=train1.reshape(-1,28*28 ) | Digit Recognizer |
5,844,541 | @njit
def fillna_npwhere_njit(array, values):
if np.isnan(array.sum()):
array = np.where(np.isnan(array), values, array)
return array
def for_loop(method, matrix, values):
for i in range(matrix.shape[0]):
matrix[i] = method(matrix[i], values)
return matrix<find_best_params> | X_train=X_train/255.0
test=test/255.0
X_train1=X_train1/255.0 | Digit Recognizer |
5,844,541 | %%time
%%capture
env = janestreet.make_env()
learn.model.eval()
preds = []
for(test_df, pred_df)in tqdm(env.iter_test()):
if test_df['weight'].item() > 0:
x_tt = test_df.loc[:, features].values
x_tt[:, 1:] = for_loop(fillna_npwhere_njit, x_tt[:, 1:], f_mean)
pred = 0.
pred = learn.model(t.from_numpy(x_tt ).to(device,... | X_train = np.concatenate(( X_train.values, X_train1))
Y_train = np.concatenate(( Y_train, Y_train1))
X_train=X_train.reshape(-1,28,28,1)
test=test.values.reshape(-1,28,28,1)
| Digit Recognizer |
5,844,541 | preds = np.array(preds)
preds.mean() , preds.std() , sum(preds >=.5), sum(preds < 5 )<import_modules> | Y_train = to_categorical(Y_train,num_classes=10)
| Digit Recognizer |
5,844,541 | tf.__version__<define_variables> | random_seed=2 | Digit Recognizer |
5,844,541 | SEED = 1111
tf.random.set_seed(SEED)
np.random.seed(SEED)
<load_from_csv> | X_train,X_val,Y_train,Y_val=train_test_split(X_train,Y_train,test_size=0.25,random_state=random_seed)
| Digit Recognizer |
5,844,541 | %%time
train=pd.read_parquet('.. /input/step01-csv-parquet/dtrain.parquet')
train = train.query('date > 85' ).reset_index(drop = True)
train = train[train['weight'] != 0]
train['action'] =(( train['resp'].values)> 0 ).astype(int)
train.fillna(train.mean() ,inplace=True)
raw_features = [c for c in train.columns if "... | model=Sequential()
model.add(Conv2D(filters=64,kernel_size=(5,5),padding='Same',activation='relu',input_shape=(28,28,1)))
model.add(BatchNormalization())
model.add(Conv2D(filters=64,kernel_size=(5,5),padding='Same',activation='relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=(2,2)))
model.add(D... | Digit Recognizer |
5,844,541 | def stats_features(tmp_df):
tmp_df['feature_cross_41_42_43']=tmp_df['feature_41']+tmp_df['feature_42']+tmp_df['feature_43']
tmp_df['feature_cross_1_2']=tmp_df['feature_1']/(tmp_df['feature_2']+1e-5)
tmp_df.head()
return tmp_df
<feature_engineering> | plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)
Image("model.png" ) | Digit Recognizer |
5,844,541 | train=stats_features(train)
train.head()<define_variables> | optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0 ) | Digit Recognizer |
5,844,541 | features = [c for c in train.columns if "feature" in c]<prepare_x_and_y> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"] ) | Digit Recognizer |
5,844,541 | valid = train.loc[(train.date >= 450)&(train.date < 500)].reset_index(drop=True)
resp_cols = ['resp_1', 'resp_2', 'resp_3', 'resp', 'resp_4']
X_train = train.loc[:, train.columns.str.contains('feature')]
y_train = np.stack([(train[c] > 0 ).astype('int')for c in resp_cols] ).T
X_valid = valid.loc[:, valid.columns.str.c... | learning_rate_reduction=ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
5,844,541 | def create_resnet(
num_columns, num_labels, hidden_size, dropout_rate, label_smoothing, learning_rate
):
inp = tf.keras.layers.Input(shape=(num_columns,))
x=tf.keras.layers.BatchNormalization()(inp)
x=tf.keras.layers.Dropout(dropout_rate )(x)
x1=tf.keras.layers.Dense(hidden_size )(x)
x1=tf.keras.layers.BatchNormal... | epochs = 50
batch_size = 128 | Digit Recognizer |
5,844,541 |
<import_modules> | 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 |
5,844,541 | <load_from_csv><EOS> | results = model.predict(test)
results = np.argmax(results,axis = 1)
results = pd.Series(results,name="Label")
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,864,231 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_from_csv> | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from keras.utils.np_utils import to_categorical
from keras.preprocessing.image import ImageDataGenerator
from sklearn.model_selection import train_test_split
| Digit Recognizer |
4,864,231 | df3 = pd.read_csv('.. /input/0-286-private-norm/df_rcnn286.csv' )<merge> | train = pd.read_csv(".. /input/train.csv" ) | Digit Recognizer |
4,864,231 | df4 = pd.merge(df, df3, on = 'image_id', how = 'left' )<feature_engineering> | test = pd.read_csv(".. /input/test.csv")
print(test.info())
test.head() | Digit Recognizer |
4,864,231 | list1 = [0,1,2,3,4,5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
for i in range(df4.shape[0]):
if df4.loc[i,'PredictionString'] == '14 1 0 0 1 1':
continue
a = df4.loc[i,'PredictionString']
b = a.split()
for j in range(int(len(a.split())/6)) :
for k in list1:
if int(b[0 + 6 * j])== k:
c = b[0 + 6 * j + 1]
b[0 + 6 * j + 1] = str(d... | X_train = train.drop(['label'],axis=1 ).astype('float32')
y_train = train['label'].astype('float32')
X_test = test.values.astype('float32' ) | Digit Recognizer |
4,864,231 | df_final = df4[['image_id', 'PredictionString']]
df_final.to_csv('submission.csv',index = False)
<import_modules> | def normalize(m):
return m / 255
X_train = normalize(X_train)
X_test = normalize(X_test ) | Digit Recognizer |
4,864,231 | import numpy as np
import pandas as pd
<load_from_csv> | print('Labels')
print(y_train[:5])
y_train = to_categorical(y_train, 10)
print('Encoded labels')
print(y_train[:5] ) | Digit Recognizer |
4,864,231 | pred_2class = pd.read_csv(".. /input/vinbigdata-2class-prediction/2-cls test pred.csv")
low_threshold = 0.0
high_threshold = 0.874
pred_2class<load_from_csv> | checkpoint = ModelCheckpoint(filepath='mnist.model.best.hdf5',
verbose=1,
save_best_only=True,
monitor='val_acc')
def build_model() :
model = Sequential([
Convolution2D(16,(3,3), activation='relu', input_shape=(28, 28, 1)) ,
BatchNormalization() ,
Convolution2D(16,(3,3), activation='relu'),
BatchNormalization() ,
MaxP... | Digit Recognizer |
4,864,231 | NORMAL = "14 1 0 0 1 1"
pred_det_df = pd.read_csv(".. /input/pp-old/submission_postprocessed(4 ).csv")
n_normal_before = len(pred_det_df.query("PredictionString == @NORMAL"))
merged_df = pd.merge(pred_det_df, pred_2class, on="image_id", how="left")
if "target" in merged_df.columns:
merged_df["class0"] = 1 - merged_df... | X_train, X_val, y_train, y_val = train_test_split(X_train,
y_train,
test_size=0.1,
random_state=42 ) | Digit Recognizer |
4,864,231 | !pip install -U ensemble-boxes<import_modules> | learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
4,864,231 | import pandas as pd
import numpy as np
from ensemble_boxes import *
from glob import glob
import copy
from tqdm import tqdm
import shutil<load_from_csv> | image_generator = 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)
| Digit Recognizer |
4,864,231 | height_dict = pd.read_csv('.. /input/vinbigdata-original-image-dataset/vinbigdata/test.csv' ).to_dict('records')
fnl_dict ={}
for ix,i in enumerate(height_dict):
fnl_dict[i['image_id']] = [i['width'],i['height'],i['width'],i['height']]<load_from_csv> | batch_size = 96
epochs = 60
steps_per_epoch = X_train.shape[0] / batch_size
batches = image_generator.flow(X_train, y_train, batch_size=batch_size ) | Digit Recognizer |
4,864,231 | subs = [
pd.read_csv('.. /input/yolo-vbd-lots-of-decimals/Fold_1.csv'),
pd.read_csv('.. /input/yolo-vbd-lots-of-decimals/Fold_2.csv'),
pd.read_csv('.. /input/yolo-vbd-lots-of-decimals/Fold_3.csv'),
pd.read_csv('.. /input/yolo-vbd-lots-of-decimals/Fold_4.csv'),
pd.read_csv('.. /input/yolo-vbd-lots-of-decimals/Fold_5.csv... | history = model.fit_generator(generator=batches,
steps_per_epoch=steps_per_epoch,
epochs=epochs,
validation_data=(X_val, y_val),
callbacks=[checkpoint, learning_rate_reduction] ) | Digit Recognizer |
4,864,231 | def submission_decoder(df:pd.DataFrame)-> np.ndarray:
info = df.values
df_lst = []
for i in info:
pre_lst = i[1].split(' ')
for j in range(0,len(pre_lst),6):
df_lst.append([i[0],int(pre_lst[j]),float(pre_lst[j+1]),int(pre_lst[j+2]),int(pre_lst[j+3]),\
int(pre_lst[j+4]),int(pre_lst[j+5]),fnl_dict.get(i[0])[0],fnl_dict.... | model.load_weights('mnist.model.best.hdf5' ) | Digit Recognizer |
4,864,231 | subs = [submission_decoder(subs[i])for i in range(len(subs)) ]<count_unique_values> | _, train_acc = model.evaluate(X_train, y_train, verbose=0)
_, test_acc = model.evaluate(X_val, y_val, verbose=0)
print('Train accuracy: %.3f, Test accuracy: %.3f' %(train_acc, test_acc)) | Digit Recognizer |
4,864,231 | boxes_dict = {}
scores_dict = {}
labels_dict = {}
whwh_dict = {}
for i in tqdm(subs[0].image_id.unique()):
if not i in boxes_dict.keys() :
boxes_dict[i] = []
scores_dict[i] = []
labels_dict[i] = []
whwh_dict[i] = []
size_ratio = fnl_dict.get(i)
whwh_dict[i].append(size_ratio)
tmp_df = [subs[x][subs[x]['image_id']==i]... | errors =(Y_pred_classes - y_true != 0)
Y_pred_classes_errors = Y_pred_classes[errors]
Y_pred_errors = Y_pred[errors]
Y_true_errors = y_true[errors]
| Digit Recognizer |
4,864,231 | weights = [1]*5
weights += [3]
weights1 = [3,2,4,5]
iou_thr = 0.25
skip_box_thr = 0.0
sigma = 0.1
fnl = {}
for i in tqdm(boxes_dict.keys()):
boxes, scores, labels = weighted_boxes_fusion(boxes_dict[i], scores_dict[i], labels_dict[i],\
weights=weights, iou_thr=iou_thr, skip_box_thr=skip_box_thr)
if not i in fnl.keys() ... | predictions = model.predict_classes(X_test, verbose=2 ) | Digit Recognizer |
4,864,231 | pd_form = []
for i in fnl.keys() :
b = fnl[i]
for j in range(len(b['boxes'])) :
pd_form.append([i,int(b['labels'][j]),round(b['scores'][j],2),\
int(b['boxes'][j][0]),int(b['boxes'][j][1]),\
int(b['boxes'][j][2]),int(b['boxes'][j][3])])
final_df = pd.DataFrame(pd_form,columns = ['image_id','class_id','score','x_min','y... | sub = pd.read_csv('.. /input/sample_submission.csv')
sub['Label'] = predictions
sub.to_csv('submission.csv',index=False ) | Digit Recognizer |
7,500,544 | def submission_encoder(df:pd.DataFrame)-> np.ndarray:
dct = {}
for i in tqdm(df['image_id'].unique()):
if not i in dct.keys() :
dct[i] = []
tmp = df[df['image_id'] == i].values
for j in tmp:
dct[i].append(int(j[1]))
dct[i].append(float(j[2]))
dct[i].append(int(j[3]))
dct[i].append(int(j[4]))
dct[i].append(int(j[5]))
dc... | %matplotlib inline
| Digit Recognizer |
7,500,544 | NORMAL = "14 1 0 0 1 1"
low_threshold = 0.00
high_threshold = 0.99
pred_det_df = df
n_normal_before = len(pred_det_df.query("PredictionString == @NORMAL"))
merged_df = pd.merge(pred_det_df, pred_2cls, on="image_id", how="left")
if "target" in merged_df.columns:
merged_df["class0"] = 1 - merged_df["target"]
c0, c1, c2 ... | train_df = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test_df = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
submit_df = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv' ) | Digit Recognizer |
7,500,544 | import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import RidgeCV<load_from_csv> | num_pixel = len(train_df.columns)- 1
num_pixel | Digit Recognizer |
7,500,544 | train = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
test = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv' )<count_missing_values> | transform_0 = transforms.Compose([
transforms.ToPILImage() ,
transforms.ToTensor() ,
transforms.Normalize([0.5], [0.5])
])
transform_1 = transforms.Compose([
transforms.ToPILImage() ,
transforms.RandomRotation(30),
transforms.ToTensor() ,
transforms.Normalize([0.5], [0.5])
])
transform_2 = transforms.Compose([
tran... | Digit Recognizer |
7,500,544 | sum(train.isnull().sum() )<count_missing_values> | class DataFrame_to_Dataset(Dataset):
def __init__(self, df, transform=transform_0):
if len(df.columns)== num_pixel:
self.features = df.values.reshape(( -1,28,28)).astype(np.uint8)
self.labels = None
else:
self.features = df.iloc[:,1:].values.reshape(( -1,28,28)).astype(np.uint8)
self.labels = torch.from_numpy(df.labe... | Digit Recognizer |
7,500,544 | sum(test.isnull().sum() )<concatenate> | def create_dataloaders(seed, test_size=0.1, df=train_df, batch_size=32):
train_data, valid_data = train_test_split(df,
test_size=test_size,
random_state=seed)
train_dataset_0 = DataFrame_to_Dataset(train_data)
train_dataset_1 = DataFrame_to_Dataset(train_data, transform_1)
train_dataset_2 = DataFrame_to_Dataset(trai... | Digit Recognizer |
7,500,544 | house_data = pd.concat([train.iloc[:,:-1], test],axis=0)
house_data = house_data.drop(columns=['Id'], axis=1)
sep = len(train )<data_type_conversions> | class Net(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=3),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.Conv2d(32, 32, kernel_size=3),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.Conv2d(32, 32, kernel_size=5, stride=2, padding=14),
nn.BatchNorm2d(32),
n... | Digit Recognizer |
7,500,544 | n_columns = [name for name in house_data.columns if house_data[name].dtype in ['int64', 'float64']]
w_columns = [name for name in house_data.columns if house_data[name].dtype == "object"]
values = {}
for a in w_columns:
values[a] = 'UNKNOWN'
for a in n_columns:
values[a] = house_data[a].median()
house_data.fillna(value... | use_cuda = torch.cuda.is_available()
print(use_cuda ) | Digit Recognizer |
7,500,544 | house_data = house_data.drop(['PoolQC'], axis=1 )<categorify> | def train(seed, num_epochs):
print('Creating new dataloaders...')
train_loader, valid_loader = create_dataloaders(seed=seed)
print('Creating a new model...')
net = Net()
criterion = nn.CrossEntropyLoss()
if use_cuda:
net.cuda()
criterion.cuda()
optimizer = optim.Adam(net.parameters() ,
lr=0.003, betas=(0.9, 0.999),
... | Digit Recognizer |
7,500,544 | house_data = pd.get_dummies(house_data )<prepare_x_and_y> | test_dataset = DataFrame_to_Dataset(test_df)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=32, shuffle=False)
ensemble_df = submit_df.copy()
num_models = 23
num_epochs = 6
for seed in range(num_models):
train(seed, num_epochs ) | Digit Recognizer |
7,500,544 | y_train = train.iloc[:,-1]
X_train = house_data.iloc[:sep, :]
X_test = house_data.iloc[sep:, :]<train_model> | final_pred = ensemble_df.iloc[:,2:].mode(axis=1 ).iloc[:,0]
submit_df.Label = final_pred.astype(int)
submit_df.head() | Digit Recognizer |
7,500,544 | search_rf = RandomForestRegressor(n_estimators = 100, random_state=0)
search_rf.fit(X_train, y_train)
y_test_rf = search_rf.predict(X_test)
print('Random forest accuracy:', search_rf.score(X_train, y_train))<save_to_csv> | submit_df.to_csv('submission.csv', index=False ) | Digit Recognizer |
5,742,147 | output1 = pd.DataFrame({'Id': test.Id.values, 'SalePrice': y_test_rf})
output1.to_csv('output1.csv', index=False )<find_best_params> | train_data = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test_data = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
submission = pd.read_csv('/kaggle/input/digit-recognizer/sample_submission.csv')
train_labels = train_data["label"]
train_data = train_data.drop(['label'], axis = 1)
train_data = t... | Digit Recognizer |
5,742,147 | search_cv = RidgeCV(alphas =(0.001, 0.01, 0.05, 0.1, 0.3, 0.5, 1, 3, 5, 10))
search_cv.fit(X_train, y_train)
y_test_cv = search_cv.predict(X_test)
print('RidgeCV accuracy:', search_cv.score(X_train, y_train))<save_to_csv> | learning_rate_cb = ReduceLROnPlateau(monitor = 'val_acc',
patience = 2,
verbose = 1,
factor = 0.5,
min_lr = 1e-5 ) | Digit Recognizer |
5,742,147 | output2 = pd.DataFrame({'Id': test.Id.values, 'SalePrice': y_test_cv})
output2.to_csv('output2.csv', index=False )<save_to_csv> | datagen = ImageDataGenerator(
zoom_range = 0.1,
width_shift_range = 0.1,
height_shift_range = 0.1,
rotation_range = 10
)
datagen.fit(X_train ) | Digit Recognizer |
5,742,147 | prediction =(y_test_rf + y_test_cv)/2
output = pd.DataFrame({'Id': test.Id.values, 'SalePrice': prediction})
output.to_csv('submission.csv', index=False )<import_modules> | batchsize = 512
num_epochs = 30
n_model_runs = 10
modellist = list()
for i in range(n_model_runs):
print("+++++++++ running model number", i+1)
model = models.Sequential([
Conv2D(16, [5,5], activation = 'relu', padding = 'same', input_shape = [28,28,1]),
MaxPooling2D([2,2]),
Conv2D(32, [5,5], activation = 'relu', padd... | Digit Recognizer |
5,742,147 | import os
import warnings
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.feature_selection import mutual_info_regression
from sklearn.decomposition import PCA
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, OrdinalEncoder... | prediction = [model.predict(test_data)for model in modellist]
prediction = np.sum(prediction, axis=0)
prediction = np.argmax(prediction,axis=1 ) | Digit Recognizer |
5,742,147 | <drop_column><EOS> | submission = pd.DataFrame({"ImageId": list(range(1, len(prediction)+1)) , "Label": prediction})
submission.to_csv('submission.csv', index = False, header = True ) | Digit Recognizer |
1,186,370 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_from_csv> | config = tf.ConfigProto(device_count = {'GPU': 1 , 'CPU': 4})
sess = tf.Session(config=config)
keras.backend.set_session(sess)
K.set_image_dim_ordering('tf' ) | Digit Recognizer |
1,186,370 | def load_data() :
train = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
X_train = train.copy()
y_train = X_train['SalePrice']
test = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv')
X_test = test.copy()
X_train = clean(X_train)
X_test = clean(X_test)
all... | train_data = np.genfromtxt('.. /input/train.csv', delimiter=',')[1:]
train_X = train_data[:, 1:]
train_y_orig = train_data[:, :1]
train_y = np.zeros([train_y_orig.shape[0], 10])
for ind in range(train_y_orig.shape[0]):
train_y[ind][int(train_y_orig[ind][0])] = 1 | Digit Recognizer |
1,186,370 | def cv_loop(
X_train,
y_train,
X_test,
model,
useful_features,
num_features,
cat_features,
cat_features_to_encode,
encoding = 'ohe',
new_features=[],
scaling=False,
clip=False, clipmin=np.log(34900), clipmax=np.log(755000),
tuning=True,
early_stopping=True
):
y_train = np.log(y_train)
num_features = np.intersect1d(n... | model = Sequential()
input_shape =(28, 28, 1)
model.add(Conv2D(32, kernel_size=(7, 7), padding='same', activation='relu', input_shape=input_shape))
model.add(Conv2D(32, kernel_size=(7, 7), padding='same', activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.4))
model.add(Conv2D(64, kernel_size=(5, ... | Digit Recognizer |
1,186,370 | _, _, X_train, y_train, X_test, all_features, num_features, num_continuous_features, num_discrete_features, cat_features, cat_features_to_encode = load_data()
X_train.head(2 )<create_dataframe> | batch_size=2**8
epochs = 100
n = train_X.shape[0]
train_X = train_X.reshape(( n, 28, 28, 1)).astype('float32')/ 255
history = model.fit(train_X, train_y,
epochs=epochs,
batch_size=batch_size ) | Digit Recognizer |
1,186,370 | feature_types = pd.DataFrame(data=[num_features, cat_features])
feature_types.index=['Numerical','Categorical']
feature_types.style.set_table_styles([
{'selector': 'thead', 'props': [('display', 'none')]}
] )<concatenate> | print(model.evaluate(train_X, train_y)) | Digit Recognizer |
1,186,370 | f_with_na_train = X_train.isna().sum(axis=0)
f_with_na_train = f_with_na_train[f_with_na_train>0]
f_with_na_train.name='Nb of NaNs in train'
f_with_na_test = X_test.isna().sum(axis=0)
f_with_na_test = f_with_na_test[f_with_na_test>0]
f_with_na_test.name='Nb of NaNs in test'
f_with_na = pd.concat([f_with_na_train, f_w... | test_data = np.genfromtxt('.. /input/test.csv', delimiter=',')[1:] | Digit Recognizer |
1,186,370 | _, _, X_train, y_train, X_test, all_features, num_features, _, _, cat_features, cat_features_to_encode = load_data()
useful_features = [e for e in all_features if e not in('PoolArea','3SsnPorch','MoSold','YrSold','RoofMatl','Utilities','MiscFeatureGar2','PoolQC')]
new_features = ['NbNAs','LivLotRatio','Spaciousness','M... | predictions = model.predict(test_data.reshape(( test_data.shape[0], 28, 28, 1)).astype('float32')/ 255)
predictions = predictions.argmax(1 ) | Digit Recognizer |
1,186,370 | <find_best_params><EOS> | sub_data = np.zeros([predictions.shape[0], 2])
count = 0
for val in predictions:
sub_data[count] = [count + 1, val]
count += 1
sub_data = sub_data.astype(int)
np.savetxt(fname="submission.csv",
X=sub_data,
fmt='%i',
delimiter=',',
comments='',
header='ImageId,Label' ) | Digit Recognizer |
4,566,279 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix
from keras.datasets import mnist
from keras.models import Model, Sequential
from keras.models import load_model
from keras.layers... | Digit Recognizer |
4,566,279 | if TUNING_XGB:
model = XGBRegressor(
tree_method='gpu_hist',
predictor='gpu_predictor',
n_jobs=4,
**trial.params)
else:
params = {
'max_depth': 5,
'n_estimators': 7779,
'eta': 0.0044144556312306175,
'subsample': 0.30000000000000004,
'colsample_bytree': 0.2,
'colsample_bylevel': 0.4,
'min_child_weight': 0.217928410146... | train_dir = ".. /input/train.csv"
test_dir = ".. /input/test.csv" | Digit Recognizer |
4,566,279 | submission = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/sample_submission.csv')
submission['SalePrice'] = preds
submission.to_csv('xgb_preds.csv', index = False)
oof_preds.to_csv('xgb_oof_preds.csv', header=False )<categorify> | df_train = pd.read_csv(train_dir)
df_train.info() | Digit Recognizer |
4,566,279 | _, _, X_train, y_train, X_test, all_features, num_features, _, _, cat_features, cat_features_to_encode = load_data()
useful_features = [e for e in all_features if e not in('PoolArea','3SsnPorch','MoSold','YrSold','RoofMatl','Utilities','MiscFeatureGar2','PoolQC')]
new_features = ['NbNAs','LivLotRatio','Spaciousness','M... | y_train = df_train['label']
X_train = df_train.drop(columns=['label'] ) | Digit Recognizer |
4,566,279 | def objective(trial):
param_grid = {
'alpha': trial.suggest_loguniform('alpha', 0.0001, 10000),
'max_iter': trial.suggest_loguniform('max_iter', 1000, 900000),
'random_state' : 42
}
model = Lasso(
**param_grid
)
avg_rmse, _, _ = cv_loop(
X_train = X_train,
y_train = y_train,
X_test = X_test,
model = model,
useful_f... | display_image(X_train, y_train, n=10, label=True ) | Digit Recognizer |
4,566,279 | if TUNING_LASSO:
study = optuna.create_study(direction='minimize', study_name=STUDY_NAME)
study.optimize(objective, n_trials=50)
print('Number of finished trials: ', len(study.trials))
print('Best trial:')
trial = study.best_trial
print('\tValue: {}'.format(trial.value))
print('\tParams: ')
for key, value in trial.... | X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, shuffle=False ) | Digit Recognizer |
4,566,279 | if TUNING_LASSO:
model = Lasso(**trial.params, random_state=42)
else:
params = {
'alpha': 0.0018185000964940012,
'max_iter': 21098,
'random_state' : 42
}
model = Lasso(**params)
avg_rmse, oof_preds, preds = cv_loop(
X_train = X_train,
y_train = y_train,
X_test = X_test,
model = model,
useful_features = useful_featur... | X_train = X_train.values.reshape(-1, 28,28,1)
X_val = X_val.values.reshape(-1, 28,28,1 ) | Digit Recognizer |
4,566,279 | submission = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/sample_submission.csv')
submission['SalePrice'] = preds
submission.to_csv('lasso_preds.csv', index = False)
oof_preds.to_csv('lasso_oof_preds.csv', header=False )<load_from_csv> | X_train = X_train / 255.0
X_val = X_val / 255.0 | Digit Recognizer |
4,566,279 | X_train, y_train = oof_preds[['xgb_oof_preds','lasso_oof_preds']], oof_preds['y_train']
xgb_preds = pd.read_csv('xgb_preds.csv' ).iloc[:,1]
lasso_preds = pd.read_csv('lasso_preds.csv' ).iloc[:,1]
X_test = pd.concat([np.log(xgb_preds), np.log(lasso_preds)], axis=1 )<find_best_model_class> | Y_train = pd.get_dummies(y_train ).values
Y_val = pd.get_dummies(y_val ).values | Digit Recognizer |
4,566,279 | metamodel = LinearRegression()
cum_rmse_val = 0
iteration = 1
kf = KFold(n_splits=5, shuffle=True, random_state=42)
for train_index, val_index in kf.split(X_train, y_train):
X_train_, X_val_ = X_train.iloc[train_index], X_train.iloc[val_index]
y_train_, y_val_ = y_train[train_index], y_train[val_index]
metamodel.fit(X... | print("La valeur {} est encodée vers le vecteur {}".format(y_train[0], Y_train[0]))
print("valeur {} transformée en vecteur: {}".format(y_train[20], Y_train[20])) | Digit Recognizer |
4,566,279 | submission = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/sample_submission.csv')
submission['SalePrice'] = np.exp(preds)
submission.to_csv('stacking_preds.csv', index = False )<import_modules> | datagen = ImageDataGenerator(
featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=20,
zoom_range = 0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False ) | Digit Recognizer |
4,566,279 | for dirname, _, filenames in os.walk('/kaggle/input'):
for filename in filenames:
print(os.path.join(dirname, filename))<load_from_csv> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5, 5), activation='relu', padding='Same', input_shape =(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(filters = 32, kernel_size =(5, 5), activation='relu', padding='Same'))
model.add(BatchNormalization())
model.add(MaxPooling2D(strides... | Digit Recognizer |
4,566,279 | train = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/train.csv')
test = pd.read_csv('.. /input/house-prices-advanced-regression-techniques/test.csv' )<count_missing_values> | model.add(Flatten())
model.add(Dense(units=1024, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(units=1024, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(units=10, activation='softmax')) | Digit Recognizer |
4,566,279 | Null_train = train.isnull().sum()
Null_train[Null_train > 0]<drop_column> | model.compile(loss='categorical_crossentropy', optimizer = Adam(lr=0.0001), metrics=["accuracy"] ) | Digit Recognizer |
4,566,279 | train.drop(['Alley', 'PoolQC', 'Fence', 'MiscFeature', 'Id'], axis = 1, inplace = True )<define_variables> | hist = model.fit_generator(datagen.flow(X_train, Y_train, batch_size=32),
steps_per_epoch=1000,
epochs=25,
verbose=1,
validation_data=(X_val, Y_val)) | Digit Recognizer |
4,566,279 | Null_train_data = train[['LotFrontage','MasVnrType', 'MasVnrArea', 'FireplaceQu',
'BsmtQual', 'BsmtCond', 'BsmtExposure', 'BsmtFinType1',
'BsmtFinType2', 'Electrical', 'GarageType', 'GarageYrBlt',
'GarageFinish', 'GarageQual', 'GarageCond']]<count_unique_values> | final_loss, final_acc = model.evaluate(X_val, Y_val, verbose=0)
print("Final loss: {0:.4f}, final accuracy: {1:.4f}".format(final_loss, final_acc)) | Digit Recognizer |
4,566,279 | def view_null_data(data):
return pd.DataFrame({"Data Type":data.dtypes, "Unique Count":data.apply(lambda x: x.nunique() ,axis=0),
"Null Count": data.isnull().sum() } )<feature_engineering> | Y_hat = model.predict(X_val)
Y_hat[0] | Digit Recognizer |
4,566,279 | train['LotFrontage'] = train['LotFrontage'].fillna(train.LotFrontage.mean())
train['GarageYrBlt'] = train['GarageYrBlt'].fillna(train.GarageYrBlt.mean())
train['MasVnrArea'] = train['MasVnrArea'].fillna(train.MasVnrArea.mode() [0] )<count_missing_values> | Y_pred = np.argmax(Y_hat, axis=1)
Y_true = np.argmax(Y_val, axis=1 ) | Digit Recognizer |
4,566,279 | Null_test = test.isnull().sum()
Null_test[Null_test > 0]<drop_column> | cm = confusion_matrix(Y_true, Y_pred)
print(cm ) | Digit Recognizer |
4,566,279 | Id = test['Id']
test.drop(['Alley', 'PoolQC', 'Fence', 'MiscFeature', 'Id'], axis = 1, inplace = True )<drop_column> | X_test = pd.read_csv(test_dir)
X_test = X_test.values.reshape(-1, 28,28,1)
X_test = X_test / 255.0 | Digit Recognizer |
4,566,279 | Null_test_data = test[['MSZoning', 'LotFrontage', 'Utilities', 'Exterior1st',
'Exterior2nd', 'MasVnrType', 'MasVnrArea', 'BsmtQual','FireplaceQu',
'BsmtCond', 'BsmtExposure', 'BsmtFinType1', 'BsmtFinSF1',
'BsmtFinType2', 'BsmtFinSF2', 'BsmtUnfSF', 'TotalBsmtSF',
'BsmtFullBath', 'BsmtHalfBath', 'KitchenQual', 'Functiona... | Y_hat = model.predict(X_test, verbose=1)
Y_pred = np.argmax(Y_hat, axis=1 ) | Digit Recognizer |
4,566,279 | test['LotFrontage'] = test['LotFrontage'].fillna(test['LotFrontage'].mean())
test['BsmtFinSF1'] = test['BsmtFinSF1'].fillna(test['BsmtFinSF1'].mean())
test['BsmtUnfSF'] = test['BsmtUnfSF'].fillna(test['BsmtUnfSF'].mean())
test['TotalBsmtSF'] = test['TotalBsmtSF'].fillna(test['TotalBsmtSF'].mean())
test['GarageYrBlt... | display_image(pd.DataFrame(X_test.reshape(-1, 784)) , Y_pred, n=10, label=True ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.