kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
6,789,424 | img_size = 768
def decode_image(filename, label=None, image_size=(img_size, img_size)) :
bits = tf.io.read_file(filename)
image = tf.image.decode_jpeg(bits, channels=3)
image = tf.cast(image, tf.float32)/ 255.0
image = tf.image.resize(image, image_size)
if label is None:
return image
else:
return image, label
def da... | interp = ClassificationInterpretation.from_learner(learn)
losses,idxs = interp.top_losses()
len(data.valid_ds)==len(losses)==len(idxs ) | Digit Recognizer |
6,789,424 | train_dataset =(
tf.data.Dataset
.from_tensor_slices(( train_paths, train_labels))
.map(decode_image, num_parallel_calls=AUTO)
.map(data_augment, num_parallel_calls=AUTO)
.repeat()
.shuffle(512)
.batch(BATCH_SIZE)
.prefetch(AUTO)
)
valid_dataset =(
tf.data.Dataset
.from_tensor_slices(( valid_paths, valid_labels)... | tmp_df = pd.read_csv(path+'sample_submission.csv')
tmp_df.head() | Digit Recognizer |
6,789,424 | LR_START = 0.00001
LR_MAX = 0.0001 * strategy.num_replicas_in_sync
LR_MIN = 0.00001
LR_RAMPUP_EPOCHS = 5
LR_SUSTAIN_EPOCHS = 0
LR_EXP_DECAY =.8
def lrfn(epoch):
if epoch < LR_RAMPUP_EPOCHS:
lr =(LR_MAX - LR_START)/ LR_RAMPUP_EPOCHS * epoch + LR_START
elif epoch < LR_RAMPUP_EPOCHS + LR_SUSTAIN_EPOCHS:
lr = LR_MAX
else:
... | for i in range(28000):
img = learn.data.test_ds[i][0]
tmp_array[i,1] = int(learn.predict(img)[1] ) | Digit Recognizer |
6,789,424 | def get_model(use_model):
base_model = use_model(weights='noisy-student',
include_top=False, pooling='avg',
input_shape=(img_size, img_size, 3))
x = base_model.output
predictions = Dense(train_labels.shape[1], activation="softmax" )(x)
return Model(inputs=base_model.input, outputs=predictions)
with strategy.scope() :... | tmp_df = pd.DataFrame(tmp_array,columns = ['ImageId','Label'])
tmp_df | Digit Recognizer |
6,789,424 | history = model.fit(
train_dataset,
steps_per_epoch=train_labels.shape[0] // BATCH_SIZE,
callbacks=[lr_callback, ModelCheckpoint(filepath='pretrained_EfficientNetB7.h5', monitor='val_loss', save_best_only=True)],
validation_data=valid_dataset, epochs=EPOCHS )<load_pretrained> | tmp_df.to_csv('submission.csv',index=False ) | Digit Recognizer |
6,789,424 | <save_to_csv><EOS> | mnist_test = pd.read_csv(".. /input/mnist-in-csv/mnist_test.csv")
mnist_train = pd.read_csv(".. /input/mnist-in-csv/mnist_train.csv" ) | Digit Recognizer |
10,425,390 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<install_modules> | import numpy as np
import sklearn as sk
import tensorflow as tf
import matplotlib.pyplot as plt
import pandas as pd
import sklearn.model_selection as ms
import sklearn.preprocessing as p
import math | Digit Recognizer |
10,425,390 | !pip install scorecardpy<import_modules> | tf.version.VERSION | Digit Recognizer |
10,425,390 | import numpy as np
import pandas as pd
from scipy.special import logit
import lightgbm as lgb
import scorecardpy as sc<load_from_csv> | mnist = pd.read_csv('.. /input/digit-recognizer/train.csv' ) | Digit Recognizer |
10,425,390 | train = pd.read_csv(".. /input/santander-customer-transaction-prediction/train.csv")
test = pd.read_csv(".. /input/santander-customer-transaction-prediction/test.csv")
train = train.drop('ID_code', axis = 1)
train.head()<drop_column> | height = 28
width = 28
channels = 1 | Digit Recognizer |
10,425,390 | test_id = test.ID_code
test = test.drop('ID_code', axis = 1)
test.head()<count_missing_values> | n_outputs = 10 | Digit Recognizer |
10,425,390 | print(f"The number of missing values in the training set is: {np.sum(np.sum(pd.isnull(train)))}")
print(f"The number of missing values in the test set is: {np.sum(np.sum(pd.isnull(test)))}" )<sort_values> | mnist.loc[:3].apply(show_digit_and_print_label, axis=1)
| Digit Recognizer |
10,425,390 | correlations = train.drop("target", axis = 1 ).corr().abs().unstack().sort_values(kind = "quicksort" ).reset_index()
correlations = correlations[correlations['level_0'] != correlations['level_1']]
correlations.head(10 )<compute_test_metric> | X_data = mnist.drop(columns='label')
y_data = mnist['label'] | Digit Recognizer |
10,425,390 | variables = train.drop("target", axis = 1 ).columns.values.tolist()
corr_pre_res = np.zeros(len(variables))
i = 0
for var in variables:
corr_pre_res[i] = np.corrcoef(train[var], train["target"])[0, 1]
i += 1<create_dataframe> | y_data = tf.keras.utils.to_categorical(y_data, num_classes = n_outputs)
y_data.shape | Digit Recognizer |
10,425,390 | corr_pre_res = abs(pd.DataFrame(corr_pre_res))
corr_pre_res.columns = ['corr_pre_res']
corr_pre_res.sort_values(by = 'corr_pre_res' )<groupby> | X_train, X_val, y_train, y_val = ms.train_test_split(X_data, y_data, test_size=0.15 ) | Digit Recognizer |
10,425,390 | features = [x for x in train.columns if x.startswith("var")]
hist_df = pd.DataFrame()
for var in features:
var_stats = train[var].append(test[var] ).value_counts()
hist_df[var] = pd.Series(test[var] ).map(var_stats)
hist_df[var] = hist_df[var] > 1
ind = hist_df.sum(axis = 1)!= 200
var_stats = {var: train[var].append(t... | scaler = p.StandardScaler()
X_train = scaler.fit_transform(X_train)
X_train = X_train.reshape(-1, height, width, channels)
X_val = scaler.transform(X_val)
X_val = X_val.reshape(-1, height, width, channels ) | Digit Recognizer |
10,425,390 | input_path = '/kaggle/input/severstal-steel-defect-detection/'
base = '/kaggle/input/severstal-inference-base'
requirements_dir = base + '/requirements/'<install_modules> | batch_size = 250 | Digit Recognizer |
10,425,390 | !pip -q config set global.disable-pip-version-check true
!pip -q install {requirements_dir}Keras_Applications-1.0.8-py3-none-any.whl
!pip -q install {requirements_dir}efficientnet-1.1.1-py3-none-any.whl<set_options> | train_data_gen = image_gen.flow(X_train, y=y_train, batch_size=batch_size ) | Digit Recognizer |
10,425,390 | !cp -r {base}/tpu_segmentation./
!cp -r {base}/*.py./
!rm -r tpu_segmentation *.py
AUTO = tf.data.experimental.AUTOTUNE
strategy = tf.distribute.get_strategy()
start_notebook = time()
print('Notebook started at: ', current_time_str())
print('Tensorflow version: ', tf.__version__ )<define_variables> | class CosineAnnealingLearningRateCallback(tf.keras.callbacks.Callback):
def __init__(self, n_epochs, n_cycles, lrate_max, n_epochs_for_saving, verbose=0):
self.epochs = n_epochs
self.cycles = n_cycles
self.lr_max = lrate_max
self.n_epochs_for_saving = n_epochs_for_saving
self.best_val_acc_per_cycle = float('-inf')
def... | Digit Recognizer |
10,425,390 | IMAGE_SIZE =(256, 1600)
target_size =(128, 800)
input_shape =(*target_size, 3)
N_CLASSES = 4<define_variables> | model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Conv2D(32, 3, 1, padding='same', activation='relu', input_shape=(height, width, channels)))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Conv2D(32, 3, 1, padding='same', activation='relu', input_shape=(height, width, channels)... | Digit Recognizer |
10,425,390 | test_fnames = tf.io.gfile.glob(input_path + 'test_images/*')
test_ids = [x.split('/')[-1].split('.')[0] for x in test_fnames]
get_test_path = lambda x: input_path + 'test_images/' + x + '.jpg'<categorify> | model.fit(train_data_gen, batch_size=batch_size, epochs = n_epochs, validation_data =(X_val, y_val), callbacks=[calrc], verbose=2 ) | Digit Recognizer |
10,425,390 | def normalize_and_reshape(img, target_size):
img = tf.image.resize(img, target_size)
img = tf.cast(img, tf.float32)/ 255.0
img = tf.reshape(img, [*target_size, 3])
return img
def get_image_and_id(file_name, target_size):
img = tf.io.read_file(file_name)
img = tf.image.decode_jpeg(img, channels=3)
img = normalize_an... | def load_all_models(n_models):
all_models = list()
for i in range(n_models):
filename = f'snapshot_model_{str(i)}.h5'
model = tf.keras.models.load_model(filename)
all_models.append(model)
return all_models
def ensemble_predictions(models, testX):
yhats = [model.predict(testX)for model in models]
yhats = np.array(yhat... | Digit Recognizer |
10,425,390 | df = pd.read_csv(base + '/weights_meta.csv')
df1 = df[df.source == 1]
df2 = df[df.source == 2]
bin1 = df1[df1.type == 'bin']
bin1 = get_best_weights(bin1, 1)
seg1 = df1[df1.type != 'bin']
seg1 = get_best_weights(seg1, 1)
bin2 = df2[df2.type == 'bin']
seg2 = df2[df2.type != 'bin']
bin_weights = list(bin2.filename)+ l... | X_pred = pd.read_csv('.. /input/digit-recognizer/test.csv')
X_pred = scaler.transform(X_pred)
X_pred = X_pred.reshape(-1, height, width, channels ) | Digit Recognizer |
10,425,390 | <create_dataframe><EOS> | y_pred = pd.DataFrame()
y_pred['ImageId'] = pd.Series(range(1,X_pred.shape[0] + 1))
y_pred['Label'] = ensemble_predictions(models, X_pred)
y_pred.to_csv("submission.csv", index=False ) | Digit Recognizer |
9,149,413 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | Path.ls = lambda x: list(x.iterdir())
path = Path('/kaggle/input/digit-recognizer/')
def get_data(path,fn='train.csv'):
df = pd.read_csv(path/fn)
if 'label' not in df.columns:
vals = np.ones_like(df.iloc[:,0].values)*-1
df.insert(0,'label',vals)
X = df.iloc[:,1:].values
y = df.iloc[:,0].values
return X,y
class Data... | Digit Recognizer |
9,149,413 | ensemble_outputs = []
with strategy.scope() :
X = L.Input(shape=input_shape)
for i, w in enumerate(bin_weights):
base_name = w.split('-bin')[0]
model = build_classifier(base_name, n_classes = 1, input_shape=input_shape, weights = None, name_suffix='-M{}'.format(i+1))
model.load_weights('weights/' + w)
model_output = ... | class GeneralReLU(nn.Module):
def __init__(self, leak=None, sub=None, maxv=None):
super().__init__()
self.leak, self.sub, self.maxv = leak, sub, maxv;
def forward(self, x):
x = F.leaky_relu(x, self.leak)if self.leak is not None else F.relu(x)
if self.sub is not None: x.sub_(self.sub);
if self.maxv is not None: x.cla... | Digit Recognizer |
9,149,413 | start_preds = time()
binary_predictions = binary_ensemble.predict(test_dataset_bin)
del binary_ensemble
K.clear_session()
gc.collect()
print('Elapsed time(binary predictions){}'.format(time_passed(start_preds)) )<choose_model_class> | def conv_layer(f_in, f_out, ks, s, p):
return nn.Sequential(nn.Conv2d(f_in, f_out, kernel_size=ks, stride=s, padding=p,bias=False),
nn.BatchNorm2d(f_out),
GeneralReLU(sub=0.5))
| Digit Recognizer |
9,149,413 | ensemble_outputs = []
with strategy.scope() :
X = L.Input(shape=input_shape)
for i, w in enumerate(seg_weights):
backbone_name = w.split('-unetpp')[0]
model = xnet(backbone_name, num_classes = 4, input_shape=input_shape, weights = None)
model._name = '{}-M{}'.format(model.name, i+1)
model.load_weights('weights/' + w... | class ResBlock(nn.Module):
def __init__(self, nf):
super().__init__()
self.nf = nf
self.conv1 = conv_layer(nf,nf,3,1,1)
self.conv2 = conv_layer(nf,nf,3,1,1)
def forward(self, X):
return X + self.conv2(self.conv1(X)) | Digit Recognizer |
9,149,413 | THRESHOLD = 0.80
masked_indexes = np.where(binary_predictions>=THRESHOLD)[0]
unmasked_indexes = np.where(binary_predictions<THRESHOLD)[0]
seg_ids = list(np.array(test_ids)[masked_indexes])
no_seg_ids = list(np.array(test_ids)[unmasked_indexes])
print(len(seg_ids), len(no_seg_ids), len(seg_ids)+ len(no_seg_ids), len(t... | class DenseBlock(nn.Module):
def __init__(self, ni, nf):
super().__init__()
self.ni, self.nf = ni, nf
self.conv1 = conv_layer(ni, nf,3,1,1)
self.conv2 = conv_layer(nf, nf,3,1,1)
def forward(self, X):
return torch.cat([X,self.conv2(self.conv1(X)) ],dim=1 ) | Digit Recognizer |
9,149,413 | fnames_seg = [get_test_path(i)for i in seg_ids]
batch_size = 8
test_dataset_seg = get_test_dataset(fnames_seg, target_size=target_size, batch_size=batch_size)
num_batches = tf.data.experimental.cardinality(test_dataset_seg);
print('num of batches', num_batches.numpy() )<predict_on_test> | layers = nn.Sequential(Lambda(mnist_resize),
conv_layer(1,8,5,1,2),
nn.Dropout2d(p=0.05),
ResBlock(8),
nn.Dropout2d(p=0.05),
nn.MaxPool2d(3,2,1),
DenseBlock(8,8),
nn.Dropout2d(p=0.05),
nn.MaxPool2d(3,2,1),
DenseBlock(16,16),
nn.Dropout2d(p=0.05),
nn.AdaptiveAvgPool2d(1),
Lambda(flatten),
nn.Linear(32,10),
nn.BatchNorm1... | Digit Recognizer |
9,149,413 | n_batches = 1
sample_preds = seg_ensemble.predict(test_dataset_seg.take(n_batches))
examples = retrieve_examples(test_dataset_seg, batch_size*n_batches)
idx = -1
mask_rgb = [(230, 184, 0),(0, 128, 0),(102, 0, 204),(204, 0, 102)]<predict_on_test> | X_train, y_train, X_test, y_test = get_normalized_data()
train_dl, valid_dl = get_dls(Dataset(X_train,y_train), Dataset(X_test,y_test))
model = get_model(layers=layers)
opt = get_optimizer(model)
loss_func = nn.CrossEntropyLoss()
init_cnn(model ) | Digit Recognizer |
9,149,413 | thresh_upper = [0.7,0.7,0.7,0.7]
thresh_lower = [0.4,0.5,0.4,0.5]
min_area = [180, 260, 200, 500]
empty_mask = np.zeros(target_size, int)
rles_dict = {}
for img_prefix in no_seg_ids:
for c in range(N_CLASSES):
row_name = '{}.jpg_{}'.format(img_prefix, c+1)
rles_dict[row_name] = ''
start_preds = time()
for item in tes... | count_parameters(model ) | Digit Recognizer |
9,149,413 | df = pd.DataFrame.from_dict(rles_dict, orient='index')
df.reset_index(level=0, inplace=True)
df.columns = ['ImageId_ClassId', 'EncodedPixels']
df.to_csv('submission.csv', index=False )<load_from_csv> | one_cycle_sched= combine_scheds([0.3,0.7], [sched_cos(1e-3,1e-1), sched_cos(0.1,1e-6)])
fit_one_cycle(30,one_cycle_sched ) | Digit Recognizer |
9,149,413 | train_data=pd.read_csv('/kaggle/input/forest-cover-type-prediction/train.csv')
train_data.head()<load_from_csv> | preds = get_preds(model,valid_dl)
res = []
for t in preds:
r = t.argmax().item()
res.append(r ) | Digit Recognizer |
9,149,413 | <count_values><EOS> | submission = pd.read_csv(path/'sample_submission.csv')
submission['Label'] = res
submission.to_csv('subs.csv',index=False ) | Digit Recognizer |
8,428,136 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<import_modules> | %matplotlib inline
| Digit Recognizer |
8,428,136 | from sklearn.model_selection import train_test_split<import_modules> | class TrainDataset(Dataset):
def __init__(self, file_path, transform=None):
self.data = pd.read_csv(file_path)
self.transform = transform
def __len__(self):
return len(self.data)
def __getitem__(self, index):
images = self.data.iloc[index, 1:].values.astype(np.uint8 ).reshape(( 28, 28, 1))
labels = self.data.iloc[ind... | Digit Recognizer |
8,428,136 | from sklearn.model_selection import train_test_split<prepare_x_and_y> | class Net(nn.Module):
def __init__(self):
super(Net, self ).__init__()
self.conv1 = nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1)
self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
hidden_1 = 1024
hidden_2 = 512
self.fc1 = nn.Linear(128*7*7, h... | Digit Recognizer |
8,428,136 | X=train_data.drop(labels=['Id','Cover_Type'],axis=1)
y=train_data['Cover_Type']<split> | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Net()
criterion = nn.CrossEntropyLoss()
lr = 0.001
optimizer = optim.Adam(model.parameters() , lr = lr)
model.to(device ) | Digit Recognizer |
8,428,136 | X_train,X_val,y_train,y_val=train_test_split(X,y,random_state=12 )<import_modules> | t0 = time.time()
n_epochs = 50
valid_loss_min = np.Inf
for epoch in range(n_epochs):
train_loss = 0.0
model.train()
for data, target in train_loader:
data, target = data.to(device),target.to(device)
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
optimizer.step()
train_los... | Digit Recognizer |
8,428,136 | from sklearn.ensemble import RandomForestClassifier<train_model> | model.load_state_dict(torch.load('model.pt')) | Digit Recognizer |
8,428,136 | rfc=RandomForestClassifier(n_estimators=70)
rfc.fit(X_train,y_train )<compute_test_metric> | class_correct = list(0.for i in range(10))
class_total = list(0.for i in range(10))
model.eval()
with torch.no_grad() :
for data, target in valid_loader:
data, target = data.to(device),target.to(device)
output = model(data)
_, pred = torch.max(output, dim=1)
correct = pred == target.view_as(pred)
for i in range(len... | Digit Recognizer |
8,428,136 | rfc.score(X_val,y_val )<predict_on_test> | test_preds = torch.LongTensor()
model.eval()
with torch.no_grad() :
for data in test_loader:
data, target = data.to(device),target.to(device)
output = model(data)
_, pred = torch.max(output, dim=1)
test_preds = torch.cat(( test_preds.cpu() , pred.cpu()), dim=0)
submission = pd.DataFrame({"ImageId":list(range(1, len... | Digit Recognizer |
8,428,136 | predict=rfc.predict(test_data.drop(labels=['Id'],axis=1))<prepare_output> | submission.to_csv("my_submission.csv", index=False, header=True ) | Digit Recognizer |
8,428,136 | Submission=pd.DataFrame(data=predict,columns=['Cover_Type'])
Submission.head()<prepare_output> | submission = pd.read_csv("my_submission.csv")
submission | Digit Recognizer |
8,134,868 | Submission['Id']=test_data['Id']
Submission.set_index('Id',inplace=True )<save_to_csv> | root = Path('.. /input')
train_path = Path('train')
rseed = 7
val_size = 0.05 | Digit Recognizer |
8,134,868 | Submission.to_csv('Submission.csv' )<load_from_csv> | def save_imgs(path:Path, data, labels):
path.mkdir(parents=True,exist_ok=True)
for label in np.unique(labels):
(path/str(label)).mkdir(parents=True,exist_ok=True)
for i in range(len(data)) :
if(len(labels)!=0):
imageio.imsave(str(path/str(labels[i])/(str(i)+'.jpg')) , data[i])
else:
imageio.imsave(str(path/(str(i)+... | Digit Recognizer |
8,134,868 | SEED = 1111
tf.random.set_seed(SEED)
np.random.seed(SEED)
train = pd.read_csv('.. /input/jane-street-market-prediction/train.csv')
train = train.query('date > 85' ).reset_index(drop = True)
train = train[train['weight'] != 0]
train.fillna(train.mean() ,inplace=True)
train['action'] =(( train['resp'].values)> 0 ).a... | train_csv = pd.read_csv(root/'train.csv' ) | Digit Recognizer |
8,134,868 | pca_components = 60<choose_model_class> | test_csv = pd.read_csv(root/'test.csv' ) | Digit Recognizer |
8,134,868 | e_size = 64
fc_input = pca_components
h_dims = [512,512,256,128]
dropout_rate = 0.5
epochs = 200
minibatch_size = 100000
class MarketPredictor(nn.Module):
def __init__(self):
super(MarketPredictor, self ).__init__()
self.e = nn.Embedding(2,e_size)
self.deep = nn.Sequential(
nn.Linear(fc_input,h_dims[0]),
nn.BatchNorm... | data_X, data_y = train_csv.loc[:,'pixel0':'pixel783'], train_csv['label'] | Digit Recognizer |
8,134,868 | epochs = 200
path = '/kaggle/input/pytorch-nn-model/marketpredictor_state_dict_'+str(epochs)+'epochs.pt'
model = MarketPredictor()
model.load_state_dict(torch.load(path,map_location=dev))
model.to(dev)
model.eval()<load_pretrained> | train_X, val_X, train_y, val_y = train_test_split(data_X, data_y, test_size=val_size,random_state=rseed,stratify=data_y ) | Digit Recognizer |
8,134,868 | with open('/kaggle/input/pytorch-nn-model/feature_processing.pkl', 'rb')as f:
sc, pca, maxindex, fill_val = pickle.load(f )<define_variables> | def to_img_shape(data_X, data_y=[]):
data_X = np.array(data_X ).reshape(-1,28,28)
data_X = np.stack(( data_X,)*3, axis=-1)
data_y = np.array(data_y)
return data_X,data_y | Digit Recognizer |
8,134,868 | feature_names = ['feature_'+str(i)for i in range(1,130)]
exclude = np.where([maxindex[i,1] > 100 and maxindex [i,2] > 1 for i in range(129)])[0]<split> | train_X,train_y = to_img_shape(data_X, data_y ) | Digit Recognizer |
8,134,868 | env = janestreet.make_env()
iter_test = env.iter_test()<data_type_conversions> | val_X,val_y = to_img_shape(val_X,val_y ) | Digit Recognizer |
8,134,868 | for(test_df, sample_prediction_df)in iter_test:
if test_df['weight'].item() == 0:
sample_prediction_df.action = 0
else:
test_df_features = test_df[feature_names].to_numpy()
for i in exclude:
if test_df_features[0,i] == maxindex[i,0]:
test_df_features[0,i] = fill_val[i]
test_df_int_features = test_df['feature_0'].to_num... | save_imgs(Path('/data/train'),train_X,train_y ) | Digit Recognizer |
8,134,868 | import numpy as np
import pandas as pd
from tensorflow.keras.callbacks import TensorBoard
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder<import_modules> | save_imgs(Path('/data/valid'),val_X,val_y ) | Digit Recognizer |
8,134,868 | from tensorflow import keras
from tensorflow.keras.layers import MaxPooling1D, Dense, LeakyReLU, Conv1D
from tensorflow.keras.layers import Flatten, Activation, BatchNormalization, Dropout
from tensorflow.keras.losses import BinaryCrossentropy
from tensorflow.keras import layers
from kerastuner.tuners import RandomSear... | data = ImageDataBunch.from_folder('/data/',bs=256,size=28,ds_tfms=get_transforms(do_flip=False),num_workers=0 ).normalize(imagenet_stats ) | Digit Recognizer |
8,134,868 | import tensorflow as tf<load_from_csv> | data.show_batch(3,figsize=(6,6)) | Digit Recognizer |
8,134,868 | %%time
train = pd.read_csv('.. /input/jane-street-market-prediction/train.csv')
train = train.query('date > 85' ).reset_index(drop = True)
train = train[train['weight'] != 0]
train.fillna(train.mean() ,inplace=True )<prepare_x_and_y> | learn = cnn_learner(data,models.resnet18,metrics=accuracy,path='.')
learn.lr_find()
learn.recorder.plot() | Digit Recognizer |
8,134,868 | SEED = 1111
tf.random.set_seed(SEED)
np.random.seed(SEED)
train['action'] =(( train['resp'].values)> 0 ).astype(int)
features = [c for c in train.columns if "feature" in c]
f_mean = np.mean(train[features[1:]].values,axis=0)
resp_cols = ['resp_1', 'resp_2', 'resp_3', 'resp', 'resp_4']
X = train.loc[:, train.columns... | learn.fit_one_cycle(1,1e-02 ) | Digit Recognizer |
8,134,868 | def build_model() :
model = keras.models.Sequential()
model.add(Conv1D(180, 2, input_shape=x_train.shape[1:]))
model.add(BatchNormalization())
model.add(LeakyReLU(alpha=leaky_relu_alpha))
model.add(MaxPooling1D(pool_size=2))
model.add(Dropout(0.15))
model.add(Flatten())
model.add(Dense(180))
model.add(LeakyReLU(alpha... | learn.save('s1' ) | Digit Recognizer |
8,134,868 | model = build_model()<train_model> | learn.load('s1'); | Digit Recognizer |
8,134,868 | model.fit(x=x_train,
y=Y,
epochs=10,
batch_size=1024 )<import_modules> | learn.lr_find() | Digit Recognizer |
8,134,868 | from tqdm import tqdm<feature_engineering> | learn.fit_one_cycle(10,max_lr=slice(1e-6,1e-5)) | Digit Recognizer |
8,134,868 | f = np.median
th = 0.5000
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_tt[:, 1:])+ np.isnan(x_tt[:, 1:])* f_mean
pred = np.mean([model(x_tt.reshape(-1, x_tt... | interp = ClassificationInterpretation.from_learner(learn ) | Digit Recognizer |
8,134,868 | START_TIME = time.time()
<data_type_conversions> | learn1 = learn.load('s1')
sub_df = pd.DataFrame(columns=['ImageId','Label'] ) | Digit Recognizer |
8,134,868 | train = pd.read_csv('.. /input/jane-street-market-prediction/train.csv')
train = train.astype({c: np.float32 for c in train.select_dtypes(include='float64' ).columns})
train.fillna(train.median() , inplace=True)
train = train.query('weight > 0' ).reset_index(drop = True)
train['action'] =(train['resp'] > 0 ).astype... | def get_img(data):
t1 = data.reshape(28,28)/255
t1 = np.stack([t1]*3,axis=0)
img = Image(FloatTensor(t1))
return img | Digit Recognizer |
8,134,868 | y_resps = train[resp_cols].values
y_actions = np.stack([(train[c] > 0 ).astype('int')for c in resp_cols] ).T<choose_model_class> | from fastprogress import progress_bar | Digit Recognizer |
8,134,868 | def create_model(input_dim, output_dims, add_models=0):
input_layer_0 = Input(input_dim)
bn_0 = BatchNormalization()(input_layer_0)
outputs_layer_0 = []
for m in range(2+add_models):
x = Dropout(0.2 )(bn_0)
for i in range(m+1):
x = Dense(64 )(x)
x = BatchNormalization()(x)
x = Lambda(tf.keras.activations.swish )(x... | sub_df.to_csv('submission.csv',index=False ) | Digit Recognizer |
4,408,047 | epochs = 50
batch_size = 1024 * 4
verbose = True
objective = 'val_output_layer_3_average_auc'
objective = 'output_layer_3_average_auc'
direction = 'max'
tr =(0, 400)
te =(420, 500)
train_indices = train[(train.date >= tr[0])&(train.date < tr[1])].index
test_indices = train[(train.date >= te[0])&(train.date < te[1])].... | import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from keras.utils import to_categorical
import os
import time
from keras.models import Sequential
from keras.layers import Dense,Conv2D,Flatten,Dropout,MaxPooling2D,BatchNormalization
from keras.callbacks import EarlyStopping
from sklearn.metrics imp... | Digit Recognizer |
4,408,047 | tf.keras.utils.plot_model(model, to_file=f'model.png', show_shapes=True )<predict_on_test> | path_train='.. /input/train.csv'
path_test=".. /input/test.csv"
train=pd.read_csv(path_train)
test=pd.read_csv(path_test)
X_train=train.drop("label",axis=1 ).values
Y_train=train["label"].values
X_test=test.values
X_train=X_train/X_train.max()
X_test=X_test/X_test.max() | Digit Recognizer |
4,408,047 | pred = model.predict(X_test, batch_size=batch_size, verbose=True )<split> | label=[0,1,2,3,4,5,6,7,8,9]
nc=10
Y_train_d=to_categorical(Y_train,10)
X_train_c=X_train.reshape(-1,28,28,1)
X_test_c=X_test.reshape(-1,28,28,1 ) | Digit Recognizer |
4,408,047 | env = janestreet.make_env()
iter_test = env.iter_test()<define_variables> | np.random.seed(2)
m=Sequential()
m.add(Conv2D(filters=128,kernel_size=4,padding="same",activation="relu",input_shape=(28,28,1)))
m.add(Conv2D(filters=128,kernel_size=4,padding="same",activation="relu"))
m.add(MaxPooling2D(pool_size=2,strides=2))
m.add(Dropout(0.2))
m.add(Conv2D(filters=64,kernel_size=4,padding="same"... | Digit Recognizer |
4,408,047 | selected_models = [model]<feature_engineering> | el=EarlyStopping(monitor='val_loss',min_delta=0.001,patience=5,restore_best_weights=True)
ad=optimizers.Adam(lr=0.002,beta_1=0.9,beta_2=0.999,decay=0.004)
m.compile(loss="categorical_crossentropy",optimizer=ad,metrics=["accuracy"])
s=time.time()
h=m.fit(X_train_c,Y_train_d,batch_size=32,validation_split=0.4,epochs=5... | Digit Recognizer |
4,408,047 | start = time.time()
th = 0.5
j = 0
for(test_df, pred_df)in tqdm(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_tt[:, 1:])+ np.isnan(x_tt[:, 1:])* f_median
try:
pred = model(x_tt, training=False)[2].numpy().flatten()
pred ... | acc=h.history['acc']
val_acc=h.history['val_acc']
loss=h.history['loss']
val_loss=h.history['val_loss'] | Digit Recognizer |
4,408,047 | <import_modules><EOS> | y_test=m.predict(X_test_c)
y_test = np.argmax(y_test,axis = 1)
out=pd.DataFrame({"ImageId": list(range(1,len(y_test)+1)) ,"Label": y_test})
out.to_csv("Submission_cnn.csv", index=False, header=True ) | Digit Recognizer |
5,380,372 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<load_from_csv> | os.listdir('.. /input/digit-recognizer')
| Digit Recognizer |
5,380,372 | train = pd.read_csv('.. /input/tabular-playground-series-feb-2021/train.csv')
test = pd.read_csv('.. /input/tabular-playground-series-feb-2021/test.csv')
sample_sub = pd.read_csv('.. /input/tabular-playground-series-feb-2021/sample_submission.csv' )<drop_column> | PATH = '.. /input/digit-recognizer'
df_train = pd.read_csv(os.path.join(PATH, 'train.csv'))
train_y = df_train['label'].values
train_x = df_train.drop(['label'], axis=1 ).values
df_test = pd.read_csv(os.path.join(PATH, 'test.csv'))
test_x = df_test.values
print(train_x.shape)
print(train_y.shape)
print(test_x.shape ) | Digit Recognizer |
5,380,372 | delete_columns = ['id']
train.drop(delete_columns, axis=1, inplace=True)
test.drop(delete_columns, axis=1, inplace=True )<define_variables> | IMG_SIZE = 32 | Digit Recognizer |
5,380,372 | categorical_features = ['cat0', 'cat1', 'cat2', 'cat3', 'cat4', 'cat5', 'cat6','cat7', 'cat8', 'cat9']<categorify> | def resize(img_array):
tmp = np.empty(( img_array.shape[0], IMG_SIZE, IMG_SIZE))
for i in range(len(img_array)) :
img = img_array[i].reshape(28, 28 ).astype('uint8')
img = cv2.resize(img,(IMG_SIZE, IMG_SIZE))
img = img.astype('float32')/255
tmp[i] = img
return tmp
train_x_resize = resize(train_x)
test_x_resize = resi... | Digit Recognizer |
5,380,372 | 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())
<prepare_x_and_y> | train_y_final = to_categorical(train_y, num_classes=10)
print(train_y_final.shape ) | Digit Recognizer |
5,380,372 | y_train = train['target']
X_train = train.drop('target', axis = 1)
X_test = test<init_hyperparams> | vgg16 = VGG16(weights = 'imagenet',
include_top = False,
input_shape=(IMG_SIZE, IMG_SIZE, 3)
)
model = Sequential()
model.add(vgg16)
model.add(Flatten())
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
model.summary() | Digit Recognizer |
5,380,372 | y_preds = []
models = []
oof_train = np.zeros(len(X_train))
cv = KFold(n_splits=5, shuffle=True, random_state=0)
params = {
'random_state':42,
'metric': 'rmse',
'n_jobs': -1,
'cat_feature': [x for x in range(len(categorical_features)) ],
'bagging_seed':42,
'feature_fraction_seed':42,
'learning_rate': 0.001199271513808... | x_train, x_test, y_train, y_test = train_test_split(train_x_final, train_y_final, test_size=0.2, random_state=2019)
print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)
| Digit Recognizer |
5,380,372 | pd.DataFrame(oof_train ).to_csv('oof_train_kfold.csv', index=False )<create_dataframe> | es = EarlyStopping(monitor='val_acc', verbose=1, patience=5)
mc = ModelCheckpoint(filepath='mnist-vgg13.h5', verbose=1, monitor='val_acc')
cb = [es, mc] | Digit Recognizer |
5,380,372 | y_preds = pd.DataFrame(y_preds )<prepare_output> | history = model.fit(x_train, y_train,
epochs=100,
batch_size=128,
validation_data=(x_test, y_test),
callbacks=cb ) | Digit Recognizer |
5,380,372 | y_subs = y_preds<save_to_csv> | preds = model.predict(test_x_final, batch_size=128 ) | Digit Recognizer |
5,380,372 | sample_sub['target'] = y_subs
sample_sub.to_csv('submission_CV.csv', index=False )<import_modules> | results = np.argmax(preds, axis=-1)
results.shape | Digit Recognizer |
5,380,372 | <load_from_csv><EOS> | sub = pd.read_csv(os.path.join(PATH, 'sample_submission.csv'))
sub.head()
df = pd.DataFrame({'ImageId': sub['ImageId'], 'Label': results})
df.to_csv('submission.csv', index=False)
os.listdir('./' ) | Digit Recognizer |
4,143,339 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<drop_column> | %matplotlib inline
| Digit Recognizer |
4,143,339 | train_id = df_train["id"]
test_id = df_test["id"]
df_train.drop("id", axis=1, inplace=True)
df_test.drop("id", axis=1, inplace=True )<define_variables> | train_data=pd.read_csv(".. /input/train.csv")
test_data=pd.read_csv('.. /input/test.csv' ) | Digit Recognizer |
4,143,339 | cat_features = [f"cat{i}" for i in range(9 + 1)]<categorify> | y_label=train_data['label'] | Digit Recognizer |
4,143,339 | onehot_encoder = ce.one_hot.OneHotEncoder()
onehot_encoder.fit(pd.concat([df_train[cat_features], df_test[cat_features]], axis=0))
train_ohe = onehot_encoder.transform(df_train[cat_features])
test_ohe = onehot_encoder.transform(df_test[cat_features])
train_ohe.columns = [f"OHE_{col}" for col in train_ohe]
test_ohe.co... | img_rows, img_cols = 28, 28
num_classes = 10 | Digit Recognizer |
4,143,339 | numerical_features = [f"cont{i}" for i in range(13 + 1)]<concatenate> | def data_prep(raw):
out_y = keras.utils.to_categorical(raw.label, num_classes)
num_images = raw.shape[0]
x_as_array = raw.values[:,1:]
x_shaped_array = x_as_array.reshape(num_images, img_rows, img_cols, 1)
out_x = x_shaped_array / 255
return out_x, out_y | Digit Recognizer |
4,143,339 | train_x = pd.concat([
df_train[numerical_features],
train_ohe
], axis=1 )<concatenate> | train_size =len(train_data ) | Digit Recognizer |
4,143,339 | test_x = pd.concat([
df_test[numerical_features],
test_ohe
], axis=1 )<prepare_x_and_y> | x,y = data_prep(train_data ) | Digit Recognizer |
4,143,339 | train_y = df_train["target"]<choose_model_class> | 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.18,
width_shift_range=0.15,
height_shift_range=0.15,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(... | Digit Recognizer |
4,143,339 | folds = KFold(n_splits=5, shuffle=True, random_state=2021 )<train_model> | X_train, X_val, Y_train, Y_val = train_test_split(x, y, test_size = 0.1, random_state=2 ) | Digit Recognizer |
4,143,339 | class FoldsAverageLGBM:
def __init__(self, folds):
self.folds = folds
self.models = []
def fit(self, lgb_params, train_x, train_y):
oof_preds = np.zeros_like(train_y)
self.train_x = train_x
self.train_y = train_y.values
for tr_idx, va_idx in tqdm(folds.split(train_x)) :
tr_x, va_x = self.train_x.iloc[tr_idx], self.tra... | class myCallback(keras.callbacks.Callback):
def on_epoch_end(self,epoch,logs={}):
if(logs.get('acc')>0.997):
print("
Reached 99.7% accuracy so cancelling training")
self.model.stop_training=True | Digit Recognizer |
4,143,339 | lgb_params = {
'objective': 'regression',
'metric': 'rmse',
'verbosity': -1,
'learning_rate': 0.01,
'feature_pre_filter': False,
'lambda_l1': 6.271548464074981,
'lambda_l2': 6.442666191955093e-05,
'num_leaves': 244,
'feature_fraction': 0.4,
'bagging_fraction': 0.6165715549446614,
'bagging_freq': 6,
'min_child_samples':... | model = Sequential() | Digit Recognizer |
4,143,339 | folds_average_lgbm = FoldsAverageLGBM(folds )<train_model> | model.add(Conv2D(filters = 16, kernel_size =(3,3),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(filters = 32, kernel_size =(3,3),padding = 'Same',
activation ='relu'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(filters = 64, ke... | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.