kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
9,309,487 | outputs = roberta_seq.predict(test_dataset)
y_pred = outputs[0].argmax(axis=1 )<compute_test_metric> | model.add(Conv2D(64,(3,3),padding='same',activation= 'relu'))
model.add(BatchNormalization())
model.add(Conv2D(64,(3,3),padding='same',activation= 'relu'))
model.add(BatchNormalization())
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.4)) | Digit Recognizer |
9,309,487 | print('Confusion matrix:')
print(confusion_matrix(y_test,y_pred,labels=[0,1]))
print()
print('Classification report:')
print(classification_report(y_test,y_pred,labels=[0,1],target_names=['not a disaster','disaster']))<define_variables> | model.add(Dense(256,activation= 'relu'))
model.add(Dropout(0.25))
model.add(Dense(128,activation= 'relu'))
model.add(Dropout(0.50))
model.add(Dense(10,activation= 'softmax')) | Digit Recognizer |
9,309,487 | tweets_test = list(df_test['text'])
tweets_test = process_tweets(tweets_test)
X_real_test = roberta_tokenizer(tweets_test,padding='max_length',max_length=max_len,return_tensors='tf')
real_test_dataset = tf.data.Dataset.from_tensor_slices(dict(X_real_test))
real_test_dataset = real_test_dataset.batch(batch_size)
rea... | optimizer =Adam(lr=0.004 ) | Digit Recognizer |
9,309,487 | outputs_test = roberta_seq.predict(real_test_dataset)
y_pred_test = outputs_test[0].argmax(axis=1 )<save_to_csv> | model.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])
| Digit Recognizer |
9,309,487 | results = pd.Series(y_pred_test,index=df_test.index,name='target')
results.to_csv('./submission.csv' )<import_modules> | plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)
Image("model.png")
| Digit Recognizer |
9,309,487 | import pandas as pd
import numpy as np
import cv2
from glob import glob
import sklearn
from sklearn.model_selection import GroupKFold, StratifiedKFold
from sklearn.metrics import roc_auc_score, log_loss
from sklearn import metrics
from sklearn.metrics import log_loss
from skimage import io
import os
from datetime impor... | annealer = LearningRateScheduler(lambda x: 1e-3 * 0.9 ** x)
| Digit Recognizer |
9,309,487 | CFG = {
'fold_num': 12,
'seed': 719,
'model_arch': 'tf_efficientnet_b3_ns',
'img_size': 384,
'epochs': 120,
'train_bs': 28,
'valid_bs': 32,
'lr': 1e-2,
'num_workers': 5,
'accum_iter': 1,
'verbose_step': 2,
'device': 'cuda:0',
'tta': 10,
'used_epochs': [6,7,8,9],
'weights': [1,1,1,1]
}<set_options> | datagen = ImageDataGenerator(zoom_range = 0.2,
)
datagen.fit(x_train ) | Digit Recognizer |
9,309,487 | def all_seed(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True<normalization> | hist = model.fit_generator(datagen.flow(x_train, y_train, batch_size=256),
steps_per_epoch=600,
epochs=15,
verbose=1,
validation_data=(x_test, y_test)
) | Digit Recognizer |
9,309,487 | def get_img(path):
im_bgr = cv2.imread(path)
im_rgb = im_bgr[:, :, ::-1]
return im_rgb<load_pretrained> | y_pred = model.predict(test, verbose = 1)
| Digit Recognizer |
9,309,487 | img = get_img('.. /input/cassava-leaf-disease-classification/train_images/1000015157.jpg')
plt.imshow(img)
plt.show()<load_from_csv> | predictions=[]
for i in range(len(test)) :
a=np.where(y_pred[i] == max(y_pred[i]))
predictions.append(a[0][0] ) | Digit Recognizer |
9,309,487 | <count_values><EOS> | counter = range(1, len(predictions)+ 1)
solution = pd.DataFrame({"ImageId": counter, "label": list(predictions)})
solution.to_csv("digit_recognizer8.csv", index = False ) | Digit Recognizer |
9,281,452 | <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.models import Model, load_model
from keras.layers import Conv2D, Input, MaxPooling2D, Dense, Dropout, Flatten
from keras.layers import LeakyReLU
from keras.layers.normalization import BatchNormalization
from keras.preprocessing.image impo... | Digit Recognizer |
9,281,452 | sample_submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
sample_submission.head()<categorify> | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv")
submission = pd.read_csv("/kaggle/input/digit-recognizer/sample_submission.csv")
X = train.drop(['label'],1 ).values
Y = train['label'].values
x_test = test.values
X = X/255.
x_test = x_test... | Digit Recognizer |
9,281,452 | class CassavaDataset(Dataset):
def __init__(self, df, data_root, transforms = None, output_label = True):
super().__init__()
self.df = df.reset_index(drop = True ).copy()
self.transforms = transforms
self.data_root = data_root
self.output_label = output_label
def __len__(self):
return self.df.shape[0]
def __getitem... | x_train, x_valid, y_train, y_valid = train_test_split(X,Y, test_size=0.1 ) | Digit Recognizer |
9,281,452 | HorizontalFlip, VerticalFlip, Transpose, ShiftScaleRotate,
HueSaturationValue,RandomResizedCrop, RandomBrightnessContrast,
Compose, Normalize, Cutout, CoarseDropout, CenterCrop, Resize
)
<categorify> | def get_model() :
In = Input(shape=(28,28,1))
x = Conv2D(32,(3,3), padding="same" )(In)
x = LeakyReLU(alpha=0.01 )(x)
x = Conv2D(32,(3,3), padding="same" )(x)
x = LeakyReLU(alpha=0.01 )(x)
x = BatchNormalization()(x)
x = MaxPooling2D(( 2,2))(x)
x = Conv2D(64,(3,3), padding="same" )(x)
x = LeakyReLU(alpha=0.01 )(... | Digit Recognizer |
9,281,452 | def get_train_transforms() :
return Compose([
RandomResizedCrop(CFG['img_size'], CFG['img_size']),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
ShiftScaleRotate(p=0.5),
HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),
RandomBrightnessContrast(brightness_limit=... | best_checkpoint = ModelCheckpoint('best.hdf5',monitor = 'val_loss', mode = "min", verbose = 1, save_best_only = True)
lr_reduction = ReduceLROnPlateau(monitor = 'val_loss', patience = 3, verbose = 1, factor = 0.5, min_lr = 1e-6 ) | Digit Recognizer |
9,281,452 | def get_inference_transforms() :
return Compose([
RandomResizedCrop(CFG['img_size'], CFG['img_size']),
Transpose(p=0.5),
HorizontalFlip(p=0.5),
VerticalFlip(p=0.5),
HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),
RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_... | data_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)
epochs =... | Digit Recognizer |
9,281,452 | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
sys.path.append(package_path)
<import_modules> | hist = model.fit_generator(train_generator, epochs=epochs, steps_per_epoch = x_train.shape[0]//batch_size,
validation_data = valid_generator, validation_steps = x_valid.shape[0]//batch_size, callbacks=[best_checkpoint, lr_reduction], verbose=1 ) | Digit Recognizer |
9,281,452 | class CassavaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, n_class)
def forward(self, x):
x = self.... | best = load_model("best.hdf5")
preds = best.predict(x_test, verbose=1)
preds = np.array([np.argmax(i)for i in preds])
preds | Digit Recognizer |
9,281,452 | <import_modules><EOS> | submission['Label'] = preds
submission.to_csv("submission.csv", index=False)
submission.head() | Digit Recognizer |
8,147,528 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | train = pd.read_csv(".. /input/digit-recognizer/train.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv" ) | Digit Recognizer |
8,147,528 | if __name__ == '__main__':
all_seed(CFG['seed'])
folds = StratifiedKFold(n_splits=CFG['fold_num'] ).split(np.arange(train.shape[0]), train.label.values)
for fold,(trn_idx, val_idx)in enumerate(folds):
if fold > 0:
break
print('Inference fold {} started'.format(fold))
valid_ = train.loc[val_idx,:].reset_index(drop=Tru... | X_train = train.drop(labels=["label"], axis=1)
Y_train = train['label']
del train
X_train = X_train / 255.
test = test / 255.
X_train = X_train.values.reshape(-1, 28, 28, 1)
test = test.values.reshape(-1, 28, 28, 1)
| Digit Recognizer |
8,147,528 | test['label'] = np.argmax(tst_preds, axis=1)
test.head()<save_to_csv> | X_train, X_val, Y_train, Y_val = train_test_split(
X_train,
Y_train,
test_size=0.1,
random_state=42
) | Digit Recognizer |
8,147,528 | test.to_csv('submission.csv', index = False )<define_variables> | datagen = ImageDataGenerator(
rotation_range=10,
zoom_range=(1.15, 0.95),
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False,
shear_range=5
) | Digit Recognizer |
8,147,528 | package_paths = [
'.. /input/pytorch-image-models/pytorch-image-models-master',
'.. /input/adamp-optimizer/AdamP-master/adamp'
]
for pth in package_paths:
sys.path.append(pth )<import_modules> | init = RandomNormal(stddev=0.02)
model = Sequential([
Conv2D(32, 3, input_shape=(28, 28, 1), activation='relu', kernel_initializer=init),
BatchNormalization() ,
Conv2D(32, 3, activation='relu', kernel_initializer=init),
BatchNormalization() ,
Conv2D(32, 5, strides=2, padding='same', activation='relu', kernel_initializ... | Digit Recognizer |
8,147,528 | from glob import glob
from sklearn.model_selection import GroupKFold, StratifiedKFold
import cv2
from skimage import io
import torch
from torch import nn
import os
from datetime import datetime
import time
import random
import cv2
import torchvision
from torchvision import transforms
import pandas as pd
import numpy as... | model.compile(
optimizer=Adam(lr=1e-3),
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy']
) | Digit Recognizer |
8,147,528 | CFG = {
'valid': False,
'fold_num': 5,
'seed': 719,
'model_arch1': 'tf_efficientnet_b4_ns',
'model_arch2': 'tf_efficientnet_b4_ns',
'model_arch3' : 'regnety_040',
'model_arch4' : 'regnety_040',
'model_arch5': 'tf_efficientnet_b4_ns',
'model_arch6': 'regnety_040',
'ckpt_path2': 'regnety4noresetadamp',
'ckpt_path3': 'reg... | learning_rate_reduction = ReduceLROnPlateau(
monitor='val_sparse_categorical_accuracy',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001
) | Digit Recognizer |
8,147,528 | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head()<load_from_csv> | history = model.fit(
datagen.flow(X_train, Y_train, batch_size=64),
epochs=45,
validation_data=(X_val, Y_val),
callbacks=[learning_rate_reduction],
use_multiprocessing=True
) | Digit Recognizer |
8,147,528 | <set_options><EOS> | results = model.predict(test)
results = np.argmax(results, axis=1)
submission = pd.concat([
pd.Series(range(1,28001), name="ImageId"),
pd.Series(results, name="Label")
], axis=1)
submission.to_csv("submission.csv", index=False ) | Digit Recognizer |
1,021,412 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<prepare_x_and_y> | %matplotlib inline
| Digit Recognizer |
1,021,412 | def rand_bbox(size, lam):
W = size[0]
H = size[1]
cut_rat = np.sqrt(1.- lam)
cut_w = np.int(W * cut_rat)
cut_h = np.int(H * cut_rat)
cx = np.random.randint(W)
cy = np.random.randint(H)
bbx1 = np.clip(cx - cut_w // 2, 0, W)
bby1 = np.clip(cy - cut_h // 2, 0, H)
bbx2 = np.clip(cx + cut_w // 2, 0, W)
bby2 = np.cli... | train_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv")
| Digit Recognizer |
1,021,412 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | train_data = train_df.values
test_data = test_df.values | Digit Recognizer |
1,021,412 | class CassvaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
if model_arch == 'regnety_040':
self.model.head = nn.Sequential(
nn.AdaptiveAvgPool2d(( 1,1)) ,
nn.Flatten() ,
nn.Linear(1088, n_class)
... | labels = train_data[:,0]
train = train_data[:,1:]/255 | Digit Recognizer |
1,021,412 | class CassvaImgClassifier_ViT(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
self.model.head = nn.Linear(self.model.head.in_features, n_class)
for module in self.model.modules() :
if isinstance(module, nn.Batc... | dummy_y = keras.utils.to_categorical(labels)
x_train, x_test, y_train, y_test = train_test_split(train, dummy_y, test_size=0.1, random_state=166,stratify=labels ) | Digit Recognizer |
1,021,412 | def prepare_dataloader(df, trn_idx, val_idx, data_root='.. /input/cassava-leaf-disease-classification/train_images/'):
train_ = df.loc[trn_idx,:].reset_index(drop=True)
valid_ = df.loc[val_idx,:].reset_index(drop=True)
train_ds = CassavaDataset(train_, data_root, transforms=get_train_transforms() , output_label=True)... | model = Sequential()
callbacks = [keras.callbacks.ModelCheckpoint('minist.h5', monitor='val_acc', verbose=1, save_best_only=True,
mode='auto')]
model.add(Conv2D(64, kernel_size=(3, 3),
activation='relu',padding='same',
input_shape=(28,28,1)))
model.add(Conv2D(64,(3, 3),padding='same', activation='relu'))
model.add(Con... | Digit Recognizer |
1,021,412 | def freeze_batchnorm_stats(net):
try:
for m in net.modules() :
if isinstance(m,nn.BatchNorm2d)or isinstance(m,nn.LayerNorm):
m.eval()
except ValuError:
print('error with batchnorm2d or layernorm')
return
def unfreeze_batchnorm_stats(net):
try:
for m in net.modules() :
if isinstance(m,nn.BatchNorm2d)or isinstance(m,nn.... | model.load_weights('minist.h5' ) | Digit Recognizer |
1,021,412 | class LabelSmoothingCrossEntropy(nn.Module):
def __init__(self, smoothing=0.1):
super(LabelSmoothingCrossEntropy, self ).__init__()
assert smoothing < 1.0
self.smoothing = smoothing
self.confidence = 1.- smoothing
def forward(self, x, target):
logprobs = torch.nn.functional.log_softmax(x, dim=-1)
nll_loss = -logpr... | predict = model.predict(test ) | Digit Recognizer |
1,021,412 | if __name__ == '__main__':
seed_everything(CFG['seed'])
oof_preds = np.zeros(len(train))
print('Model 1 Start')
sub1 = []
folds = StratifiedKFold(n_splits=CFG['fold_num'] ).split(np.arange(train.shape[0]), train.label.values)
for fold,(trn_idx, val_idx)in enumerate(folds):
print('Inference fold {} started'.format(fo... | results = np.argmax(predict,axis = 1 ) | Digit Recognizer |
1,021,412 | test['label'] = np.argmax(np.mean(sub, axis=0), axis=1)
test.head()<save_to_csv> | submission = pd.DataFrame({"ImageId":range(1,28001),"Label":results})
submission.to_csv("cnn_mnist.csv",index=False ) | Digit Recognizer |
4,249,570 | test.to_csv('submission.csv', index=False )<define_variables> | input_df = pd.read_csv(".. /input/train.csv")
test_df = pd.read_csv(".. /input/test.csv" ) | Digit Recognizer |
4,249,570 | CONFIG_NAME = 'stacking12.yml'
debug = False
STAGE2_DIR = '.. /input/train-stacking-2dcnn-ver3/output'<define_variables> | input_data = input_df.drop(['label'], axis=1 ).values / 255.0
input_labels = input_df['label']
test_data = test_df.values / 255.0
train_data, valid_data, train_labels, valid_labels = train_test_split(input_data, input_labels, test_size = 0.15, random_state=2)
train_data = train_data.reshape(-1,28,28,1)
valid_data = v... | Digit Recognizer |
4,249,570 | CONFIG_PATH = f'{STAGE2_DIR}/{CONFIG_NAME}'
with open(CONFIG_PATH)as f:
config = yaml.load(f)
INFO = config['info']
TAG = config['tag']
CFG = config['cfg']
OUTPUT_DIR = './'
DATA_PATH = '.. /input/cassava-leaf-disease-classification'<define_variables> | data_augment = ImageDataGenerator(rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1 ) | Digit Recognizer |
4,249,570 |
<import_modules> | model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32,(5,5), padding='same', activation='relu', input_shape=(28,28,1)) ,
tf.keras.layers.Conv2D(32,(5,5), padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Dropout(0.25),
tf.keras.layers.Conv2D(64,(3,3), padding='same', activation='r... | Digit Recognizer |
4,249,570 | sys.path.append('.. /input/pytorch-image-models/pytorch-image-models-master')
Compose, OneOf, Normalize, Resize, RandomResizedCrop, RandomCrop, HorizontalFlip, VerticalFlip,
RandomBrightness, RandomContrast, RandomBrightnessContrast, Rotate, ShiftScaleRotate, Cutout,
IAAAdditiveGaussianNoise, Transpose, CenterCrop
)
... | annealer = ReduceLROnPlateau(
monitor='val_acc',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001 ) | Digit Recognizer |
4,249,570 | train = pd.read_csv(f'{DATA_PATH}/train.csv')
test = pd.read_csv(f'{DATA_PATH}/sample_submission.csv')
label_map = pd.read_json(f'{DATA_PATH}/label_num_to_disease_map.json',
orient='index')
if CFG['debug']:
train = train.sample(n=1000, random_state=CFG['seed'] ).reset_index(drop=True )<define_variables> | optim = tf.keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
model.compile(optimizer=optim, loss="categorical_crossentropy", metrics=['accuracy'])
num_epochs = 30
batch_size = 86
history = model.fit_generator(
data_augment.flow(train_data, train_labels, batch_size=batch_size),
steps_per_epoch=tra... | Digit Recognizer |
4,249,570 | model_dirs = []
for stage1 in CFG['stage1_models']:
num = str(stage1 ).rjust(2, '0')
output_dir_ = glob.glob(f'.. /input/{num}*/')
assert len(output_dir_)== 1, output_dir_
model_dirs.append(output_dir_[0])
model_dirs<load_pretrained> | predictions = model.predict(test_data)
pred_list = []
for index, pred in enumerate(predictions):
pred_list.append({"ImageId": index+1, "Label": np.argmax(pred)})
sub_df = pd.DataFrame(pred_list)
sub_df.to_csv("submission.csv", index=False ) | Digit Recognizer |
3,916,180 | normal_configs = []
tta_configs = []
normal_model_dirs = []
tta_model_dirs = []
for model_dir in model_dirs:
assert len(glob.glob(f'{model_dir}/*.yml')) ==1
config_path = glob.glob(f'{model_dir}/*.yml')[0]
with open(config_path)as f:
config = yaml.load(f)
if 'valid_augmentation' in config['tag'].keys() :
tta_model_dir... | import numpy as np
import pandas as pd
import random
| Digit Recognizer |
3,916,180 | def get_score(y_true, y_pred):
return accuracy_score(y_true, y_pred)
def remove_glob(pathname, recursive=True):
for p in glob.glob(pathname, recursive=recursive):
if os.path.isfile(p):
os.remove(p)
@contextmanager
def timer(name):
t0 = time.time()
LOGGER.info(f'[{name}] start')
yield
LOGGER.info(f'[{name}] done in {... | import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
from keras import backend as K | Digit Recognizer |
3,916,180 | TRAIN_PATH = '.. /input/cassava-leaf-disease-classification/train_images'
TEST_PATH = '.. /input/cassava-leaf-disease-classification/test_images'<normalization> | import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split | Digit Recognizer |
3,916,180 | class TestDataset(Dataset):
def __init__(self, df, transform=None):
self.df = df
self.file_names = df['image_id'].values
self.transform = transform
def __len__(self):
return len(self.df)
def __getitem__(self, idx):
file_name = self.file_names[idx]
file_path = f'{TEST_PATH}/{file_name}'
image = cv2.imread(file_path)
i... | train = pd.read_csv(".. /input/train.csv")
test = pd.read_csv(".. /input/test.csv")
| Digit Recognizer |
3,916,180 | def _get_augmentations(aug_list, cfg):
process = []
for aug in aug_list:
if aug == 'Resize':
process.append(Resize(cfg['size'], cfg['size']))
elif aug == 'RandomResizedCrop':
process.append(RandomResizedCrop(cfg['size'], cfg['size']))
elif aug == 'CenterCrop':
process.append(CenterCrop(CFG['size'], CFG['size']))
elif a... | y_train = train["label"]
X_train = train.drop(labels = ["label"],axis = 1 ) | Digit Recognizer |
3,916,180 | class CustomModel(nn.Module):
def __init__(self, model_name, target_size, pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=pretrained)
if hasattr(self.model, 'classifier'):
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, target_siz... | def prep_data(X_train, y_train, test):
X_train = X_train.astype('float32')/ 255
test = test.astype('float32')/255
X_train = X_train.values.reshape(-1,28,28,1)
test = test.values.reshape(-1,28,28,1)
y_train = keras.utils.np_utils.to_categorical(y_train)
classes = y_train.shape[1]
X_train, X_test, y_train, y_test = tr... | Digit Recognizer |
3,916,180 | def inference_tta(model, states, tta_loader, device):
model.to(device)
tk0 = tqdm(enumerate(tta_loader), total=len(tta_loader))
probs = []
for i,(images, _)in tk0:
images = images.to(device)
batch_size, n_crops, c, h, w = images.size()
images = images.view(-1, c, h, w)
avg_preds = []
for state in states:
model.load_... | X_train, y_train, X_test, y_test, out_neurons, test = prep_data(X_train, y_train, test ) | Digit Recognizer |
3,916,180 | def main_tta(config, model_dir):
INFO = config['info']
TAG = config['tag']
CFG = config['cfg']
CFG['train'] = False
CFG['inference'] = True
inference_batch_size = 8
seed_torch(seed=CFG['seed'])
model = CustomModel(TAG['model_name'], CFG['target_size'], pretrained=False)
states = [torch.load(path)for path in glob.glob... | model = Sequential([
Conv2D(32, kernel_size =(3, 3), padding = 'same', activation = 'relu', input_shape =(28,28,1)) ,
Conv2D(32, kernel_size =(3, 3), activation = 'relu', padding = 'same'),
MaxPool2D(pool_size =(2, 2)) ,
Dropout(0.25),
Conv2D(64, kernel_size =(3, 3), activation = 'relu', padding = 'same'),
Conv2D(64, k... | Digit Recognizer |
3,916,180 | data_num = len(test)
model_num = len(model_dirs)
target_num = CFG['target_size']
channel_num = 4
stage1_predictions = np.zeros(( model_num, data_num, channel_num, target_num), dtype=np.float)
for config, model_dir in zip(tta_configs, tta_model_dirs):
stage1_predictions[model_dirs.index(model_dir)] = main_tta(config,... | model.fit(X_train, y_train,
batch_size = 512,
epochs = 180,
validation_data =(X_test, y_test),
verbose = 0); | Digit Recognizer |
3,916,180 | class StackingDataset(Dataset):
def __init__(self, X: np.ndarray, y: Optional[np.ndarray] = None):
self.X = X
self.y = y
def __len__(self):
return self.X.shape[0]
def __getitem__(self, idx):
if self.y is None:
return torch.tensor(self.X[idx], dtype=torch.float)
else:
return(
torch.tensor(self.X[idx], dtype=torch.floa... | result = model.evaluate(X_test, y_test, verbose = 0)
print('Accuracy: ', result[1])
print('Error: %.2f%%' %(100- result[1]*100))
y_pred = model.predict(test, verbose=0 ) | Digit Recognizer |
3,916,180 | class CNNStacking(nn.Module):
def __init__(self, n_labels):
super(CNNStacking, self ).__init__()
self.sq = nn.Sequential(
nn.Conv2d(in_channels=4, out_channels=8, kernel_size=(3, 1), bias=False),
nn.ReLU() ,
nn.Conv2d(in_channels=8, out_channels=16, kernel_size=(3, 1), bias=False),
nn.ReLU() ,
nn.Flatten() ,
nn.Linear... | solution = np.argmax(y_pred,axis = 1)
solution = pd.Series(solution, name="Label" ).astype(int)
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),solution],axis = 1)
submission.to_csv("mnist_with_cnn.csv",index=False ) | Digit Recognizer |
4,829,753 | def inference(model, states, test_loader, device):
model.to(device)
tk0 = tqdm(enumerate(test_loader), total=len(test_loader))
probs = []
for i,(features)in tk0:
features = features.to(device)
avg_preds = []
for state in states:
model.load_state_dict(state['model'])
model.eval()
with torch.no_grad() :
y_preds = mode... | np.random.seed(7)
%matplotlib inline | Digit Recognizer |
4,829,753 | model = CNNStacking(CFG['target_size'])
states = [torch.load(STAGE2_DIR+f'/fold{fold}_best.pth')for fold in CFG['trn_fold']]
test_dataset = StackingDataset(stage1_predictions)
test_loader = DataLoader(test_dataset, batch_size=CFG['batch_size'], shuffle=False,
num_workers=CFG['num_workers'], pin_memory=True)
pred_sta... | train_path = '.. //input//train.csv'
test_path = '.. //input//test.csv'
train_df = pd.read_csv(train_path)
test_df = pd.read_csv(test_path)
train_df.info()
test_df.info() | Digit Recognizer |
4,829,753 | with open('.. /input/train-weights-optimization/best_weights.json', 'r')as f:
weights_dict = json.load(f)
weights_dict<define_variables> | pd.options.display.max_rows = 1000
print(train_df.isnull().sum() ) | Digit Recognizer |
4,829,753 | pred_weights_opt = np.zeros(weights_opt_feats.shape[1:], dtype=np.float)
for idx, key in enumerate(model_dirs):
pred_weights_opt += weights_opt_feats[idx] * weights_dict[key[:-1]]<define_variables> | print(test_df.isnull().sum() ) | Digit Recognizer |
4,829,753 | BLENDING_WEIGHTS = {
"stacking": 0.5,
"weights_opt": 0.5
}<prepare_output> | X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255 | Digit Recognizer |
4,829,753 | predictions = pred_stacking * BLENDING_WEIGHTS['stacking'] + pred_weights_opt * BLENDING_WEIGHTS['weights_opt']
predictions<save_to_csv> | def inception_block(inputs):
tower_one = MaxPooling2D(( 3,3), strides=(1,1), padding='same' )(inputs)
tower_one = Conv2D(6,(1,1), activation='relu', border_mode='same' )(tower_one)
tower_two = Conv2D(6,(1,1), activation='relu', border_mode='same' )(inputs)
tower_two = Conv2D(6,(3,3), activation='relu', border_mode='... | Digit Recognizer |
4,829,753 | test['label'] = predictions.argmax(1)
test[['image_id', 'label']].to_csv(OUTPUT_DIR+'submission.csv', index=False )<define_variables> | model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'] ) | Digit Recognizer |
4,829,753 | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
sys.path.append(package_path)
DATA_DIR = '.. /input/cassava-leaf-disease-classification'
MODEL_DIR_0 = '.. /input/gpu-vit-noisearch-amp-aug-fold-0'
MODEL_DIR_1 = '.. /input/gpu-vit-noisearch-amp-aug-fold-1'
MODEL_DIR_2 = '.. /input/gpu-vit-noi... | history = model.fit(X_train, Y_train,
batch_size=100,
epochs=100,
validation_split=0.1,
shuffle=True ) | Digit Recognizer |
4,829,753 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | scores_train = model.evaluate(X_train, Y_train)
print("
%s: %.2f%%" %(model.metrics_names[1], scores_train[1]*100)) | Digit Recognizer |
4,829,753 | CFG = {
'fold_num': 5,
'seed': 719,
'model_arch': 'vit_base_patch16_384',
'img_size': 384,
'epochs': 10,
'train_bs': 16,
'valid_bs': 16,
'lr': 1e-4,
'num_workers': 4,
'accum_iter': 1,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 3,
'used_epochs': [7,8,9],
'weights': [1,1,1,1,1,1]
}<define_variables> | predictions = model.predict(X_test)
predictions = np.argmax(predictions, axis = 1)
predictions | Digit Recognizer |
4,829,753 | EPOCHS0 = {
0: [9,8,6,5],
1: [5,6,4,8],
2: [8,9,7,6],
3: [8,7,9,6],
4: [9,8,7,4]
}
EPOCHS1 = {
0: [8,9,7,6],
1: [9,4,8,6],
2: [9,7,8,4],
3: [5,8,9,3],
4: [6,7,8,9]
}
EPOCHS2 = {
0: [8,9,6,7],
1: [9,8,5,6],
2: [9,7,5,4],
3: [5,8,9,4],
4: [5,8,9,7]
}
EPOCHS3 = {
0: [8,9,7,6],
1: [2,7,9,5],
2: [5,6,9,7],
3: [8,9,7,6],
4: ... | result=pd.DataFrame({"ImageId": list(range(1,len(predictions)+1)) ,"Label": predictions})
result.to_csv("mnist_cnn_only_v1.csv", index=False, header=True ) | Digit Recognizer |
1,970,319 | train = pd.read_csv(f'{DATA_DIR}/train.csv' )<set_options> | warnings.filterwarnings('ignore' ) | Digit Recognizer |
1,970,319 | def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
def get_img(path):
im_bgr = cv2.imread(path)
im_rgb = im_bgr[:, :, ::-1]
r... | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
print(train_df.shape)
print(test_df.shape ) | Digit Recognizer |
1,970,319 | class CassavaDataset(Dataset):
def __init__(self, df, data_root, transforms=None, output_label=True):
super().__init__()
self.df = df.reset_index(drop=True ).copy()
self.transforms = transforms
self.data_root = data_root
self.output_label = output_label
def __len__(self):
return self.df.shape[0]
def __getitem__(self, i... | print('Missing values in training dataset : %d' %np.sum(train_df.isnull().sum()))
print('Missing values in testing dataset : %d' %np.sum(test_df.isnull().sum())) | Digit Recognizer |
1,970,319 | class CassvaImgClassifierN(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, n_class)
def forward(self, x):
x = self.mo... | train_df = train_df/255.0
test_df = test_df/255.0
train_df = train_df.values.reshape(-1,28,28,1)
test_df = test_df.values.reshape(-1,28,28,1 ) | Digit Recognizer |
1,970,319 | class CassvaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.n_class = n_class
self.model = timm.create_model(model_arch, pretrained=pretrained)
if 'vit' in model_arch:
n_features = self.model.head.in_features
self.model.head = nn.Identity()
if 'eff' in model... | train_y = to_categorical(train_label, num_classes = 10)
print('one hot encoding vector of %d :' %train_label[3] , train_y[3] ) | Digit Recognizer |
1,970,319 | def inference_one_epoch(model, data_loader, device):
model.eval()
image_preds_all = []
pbar = tqdm(enumerate(data_loader), total=len(data_loader))
for step,(imgs)in pbar:
imgs = imgs.to(device ).float()
_, image_preds = model(imgs)
image_preds_all += [torch.sigmoid(image_preds ).detach().cpu().numpy() ]
image_preds_al... | x_train,x_val,y_train,y_val = train_test_split(train_df,train_y,test_size = 0.2, random_state = 2)
| Digit Recognizer |
1,970,319 | def run_inference(fold, MODEL_DIR, model_arch, epoch_list):
print(f'Inference fold {fold} started')
test = pd.DataFrame()
test['image_id'] = list(os.listdir(f'{DATA_DIR}/test_images/'))
if 'vit' in model_arch:
T = get_inference_transforms_384()
else:
T = get_inference_transforms()
test_ds = CassavaDataset(
test, f'{D... | dataGenerator = ImageDataGenerator(rotation_range = 10,
width_shift_range = 0.1,
height_shift_range = 0.1,
zoom_range = 0.1)
dataGenerator.fit(x_train ) | Digit Recognizer |
1,970,319 | def run_inferenceN(fold, MODEL_DIR, model_arch):
print(f'Inference fold {fold} started')
test = pd.DataFrame()
test['image_id'] = list(os.listdir(f'{DATA_DIR}/test_images/'))
test_ds = CassavaDataset(
test, f'{DATA_DIR}/test_images/',
transforms=get_inference_transforms() , output_label=False)
tst_loader = torch.uti... | ExampleImg = train_df[10][:,:,0]
def translate(img,x,y):
transMat = np.float32([[1,0,x],[0,1,y]])
shifted = cv2.warpAffine(img,transMat,(img.shape[1],img.shape[0]))
return shifted
def rotate(img,angle):
(h,w)= img.shape[:2]
center =(w/2,h/2)
rotatMat = cv2.getRotationMatrix2D(center,angle,1)
rotated = cv2.warpAffin... | Digit Recognizer |
1,970,319 | preds0 = run_inference(0, MODEL_DIR_0, 'vit_base_patch16_384', EPOCHS0)
preds1 = run_inference(1, MODEL_DIR_1, 'vit_base_patch16_384', EPOCHS0)
preds2 = run_inference(2, MODEL_DIR_2, 'vit_base_patch16_384', EPOCHS0)
preds3 = run_inference(3, MODEL_DIR_3, 'vit_base_patch16_384', EPOCHS0)
preds4 = run_inference(4, MO... | def build_CNN(input_shape, output_units = 10):
input_layer = keras.layers.Input(input_shape, name = "input_layer")
x = Conv2D(filters = 64, kernel_size =(3,3), padding = 'same' )(input_layer)
x = BatchNormalization()(x)
x = Activation('relu' )(x)
x = Conv2D(filters = 64, kernel_size =(3,3), padding = 'same' )(x)
x... | Digit Recognizer |
1,970,319 | preds0 = run_inference(0, MODEL_DIR_01, 'tf_efficientnet_b4_ns', EPOCHS1)
preds1 = run_inference(1, MODEL_DIR_11, 'tf_efficientnet_b4_ns', EPOCHS1)
preds2 = run_inference(2, MODEL_DIR_21, 'tf_efficientnet_b4_ns', EPOCHS1)
preds3 = run_inference(3, MODEL_DIR_31, 'tf_efficientnet_b4_ns', EPOCHS1)
preds4 = run_inferen... | batch_size = 128
epochs = 300
momentum = 0.95
lr = 5e-4
ES = keras.callbacks.EarlyStopping(monitor = "val_loss",
patience = 10,
verbose = 1)
model = build_CNN(x_train.shape[1:],10)
optimizer = keras.optimizers.SGD(lr = lr, momentum = 0.95)
model.compile(optimizer = optimizer, loss = 'categorical_crossentropy', metri... | Digit Recognizer |
1,970,319 | preds0 = run_inference(0, MODEL_DIR_02, 'seresnext50_32x4d', EPOCHS2)
preds1 = run_inference(1, MODEL_DIR_12, 'seresnext50_32x4d', EPOCHS2)
preds2 = run_inference(2, MODEL_DIR_22, 'seresnext50_32x4d', EPOCHS2)
preds3 = run_inference(3, MODEL_DIR_32, 'seresnext50_32x4d', EPOCHS2)
preds4 = run_inference(4, MODEL_DIR_... | final_prediction = model.predict(test_df)
final_prediction = np.argmax(final_prediction, axis = 1 ) | Digit Recognizer |
1,970,319 | preds0 = run_inferenceN(0, MODEL_DIR_03, 'tf_efficientnet_b4_ns',)
preds1 = run_inferenceN(1, MODEL_DIR_13, 'tf_efficientnet_b4_ns',)
preds2 = run_inferenceN(2, MODEL_DIR_23, 'tf_efficientnet_b4_ns',)
preds3 = run_inferenceN(3, MODEL_DIR_33, 'tf_efficientnet_b4_ns',)
preds4 = run_inferenceN(4, MODEL_DIR_43, 'tf_eff... | submission = pd.DataFrame({'ImageId':np.arange(1,final_prediction.shape[0]+1,1),'Label':final_prediction})
submission.to_csv('submission_v5.csv',index = False ) | Digit Recognizer |
4,442,168 | tst_preds =(PRED0 + 2*PRED1 + PRED2 + PRED3)/5<save_to_csv> | %matplotlib inline
seed = 4098653265
seed_all(seed, det_cudnn=True)
def mnist_learner(data: ImageDataBunch, model_name: Optional[str] = None)-> Learner:
cbs =(( partial(SaveModelCallback, monitor='accuracy', name=model_name),)
if model_name else None)
lrn = cnn_learner(data, models.resnet152, metrics=accuracy,
opt_f... | Digit Recognizer |
4,442,168 | test = pd.DataFrame()
test['image_id'] = list(os.listdir(f'{DATA_DIR}/test_images/'))
test['label'] = np.argmax(tst_preds, axis=1)
test.to_csv('submission.csv', index=False )<define_variables> | data = ImageDataBunch.from_csv('data', test='test', num_workers=0)
data.test_ds.x.items = np.array(sorted(data.test_ds.x.items, key=attrgetter('stem')))
learner = mnist_learner(data, 'best-freezed')
learner.lr_find()
learner.recorder.plot(suggestion=True ) | Digit Recognizer |
4,442,168 | CONFIG_NAME = 'stacking12.yml'
debug = False
STAGE2_DIR = '.. /input/train-stacking-2dcnn-ver3/output'<define_variables> | learner.fit_one_cycle(30, 1.3e-2 ) | Digit Recognizer |
4,442,168 | CONFIG_PATH = f'{STAGE2_DIR}/{CONFIG_NAME}'
with open(CONFIG_PATH)as f:
config = yaml.load(f)
INFO = config['info']
TAG = config['tag']
CFG = config['cfg']
OUTPUT_DIR = './'
DATA_PATH = '.. /input/cassava-leaf-disease-classification'<define_variables> | learner = mnist_learner(data ).load('best-freezed')
corr_args = DatasetFormatter.from_most_unsure(learner, 100)
corr = PredictionsCorrector(*corr_args ) | Digit Recognizer |
4,442,168 |
<import_modules> | corr.corrections = {
275: 5, 927: 6, 3080: 0, 3162: 3, 3485: 8, 3700: 5, 3740: 9,
4680: 1, 5215: 1, 5276: 1, 5928: 5, 6789: 3, 7026: 4, 9040: 2,
9202: 7, 9744: 3, 9814: 4, 9924: 2, 10344: 9, 11370: 8, 11746: 8,
11862: 8, 12620: 8, 12864: 9, 14579: 9, 14742: 0, 16204: 9,
16281: 5, 16452: 4, 17589: 8, 17931: 5, 18166: 1,... | Digit Recognizer |
4,442,168 | sys.path.append('.. /input/pytorch-image-models/pytorch-image-models-master')
Compose, OneOf, Normalize, Resize, RandomResizedCrop, RandomCrop, HorizontalFlip, VerticalFlip,
RandomBrightness, RandomContrast, RandomBrightnessContrast, Rotate, ShiftScaleRotate, Cutout,
IAAAdditiveGaussianNoise, Transpose, CenterCrop
)
... | preds = corr.corrected_labels()
submission = pd.DataFrame(
preds, columns=('Label',),
index=pd.Index(( 1 + int(p.stem)for p in data.test_ds.x.items),
name='ImageId')
).sort_index()
submission.to_csv('submission.csv')
submission.head(10 ) | Digit Recognizer |
4,442,168 | train = pd.read_csv(f'{DATA_PATH}/train.csv')
test = pd.read_csv(f'{DATA_PATH}/sample_submission.csv')
label_map = pd.read_json(f'{DATA_PATH}/label_num_to_disease_map.json',
orient='index')
if CFG['debug']:
train = train.sample(n=1000, random_state=CFG['seed'] ).reset_index(drop=True )<define_variables> | ! echo 64e2b22ef2bf4e7f8b179c497a81aeea11761ce1e242083a44c42a20c8a52c65 \
submission.csv | sha256sum -c | Digit Recognizer |
7,390,641 | model_dirs = []
for stage1 in CFG['stage1_models']:
num = str(stage1 ).rjust(2, '0')
output_dir_ = glob.glob(f'.. /input/{num}*/')
assert len(output_dir_)== 1, output_dir_
model_dirs.append(output_dir_[0])
model_dirs<load_pretrained> | sample_submission = pd.read_csv(".. /input/digit-recognizer/sample_submission.csv")
test = pd.read_csv(".. /input/digit-recognizer/test.csv")
train = pd.read_csv(".. /input/digit-recognizer/train.csv" ) | Digit Recognizer |
7,390,641 | normal_configs = []
tta_configs = []
normal_model_dirs = []
tta_model_dirs = []
for model_dir in model_dirs:
assert len(glob.glob(f'{model_dir}/*.yml')) ==1
config_path = glob.glob(f'{model_dir}/*.yml')[0]
with open(config_path)as f:
config = yaml.load(f)
if 'valid_augmentation' in config['tag'].keys() :
tta_model_dir... | X_train = train / 255.0
X_test = test / 255.0 | Digit Recognizer |
7,390,641 | def get_score(y_true, y_pred):
return accuracy_score(y_true, y_pred)
def remove_glob(pathname, recursive=True):
for p in glob.glob(pathname, recursive=recursive):
if os.path.isfile(p):
os.remove(p)
@contextmanager
def timer(name):
t0 = time.time()
LOGGER.info(f'[{name}] start')
yield
LOGGER.info(f'[{name}] done in {... | X_train =(X_train.iloc[:,1:].values ).astype('float32')
y_train = train['label'].astype('float32')
X_test = X_test.values.astype('float32' ) | Digit Recognizer |
7,390,641 | TRAIN_PATH = '.. /input/cassava-leaf-disease-classification/train_images'
TEST_PATH = '.. /input/cassava-leaf-disease-classification/test_images'<normalization> | mean_px = X_train.mean().astype(np.float32)
std_px = X_train.std().astype(np.float32)
def standardize(x):
return(x - mean_px)/std_px
[mean_px, std_px] | Digit Recognizer |
7,390,641 | class TestDataset(Dataset):
def __init__(self, df, transform=None):
self.df = df
self.file_names = df['image_id'].values
self.transform = transform
def __len__(self):
return len(self.df)
def __getitem__(self, idx):
file_name = self.file_names[idx]
file_path = f'{TEST_PATH}/{file_name}'
image = cv2.imread(file_path)
i... | print(y_train)
y_train= to_categorical(y_train)
num_classes = y_train.shape[1] | Digit Recognizer |
7,390,641 | def _get_augmentations(aug_list, cfg):
process = []
for aug in aug_list:
if aug == 'Resize':
process.append(Resize(cfg['size'], cfg['size']))
elif aug == 'RandomResizedCrop':
process.append(RandomResizedCrop(cfg['size'], cfg['size']))
elif aug == 'CenterCrop':
process.append(CenterCrop(CFG['size'], CFG['size']))
elif a... | seed = 43
np.random.seed(seed)
seed | Digit Recognizer |
7,390,641 | class CustomModel(nn.Module):
def __init__(self, model_name, target_size, pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=pretrained)
if hasattr(self.model, 'classifier'):
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, target_siz... | gen = image.ImageDataGenerator()
X = X_train
y = y_train
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.10, random_state=42)
batches = gen.flow(X_train, y_train, batch_size=64)
val_batches=gen.flow(X_val, y_val, batch_size=64)
| Digit Recognizer |
7,390,641 | def inference_tta(model, states, tta_loader, device):
model.to(device)
tk0 = tqdm(enumerate(tta_loader), total=len(tta_loader))
probs = []
for i,(images, _)in tk0:
images = images.to(device)
batch_size, n_crops, c, h, w = images.size()
images = images.view(-1, c, h, w)
avg_preds = []
for state in states:
model.load_... | gen =ImageDataGenerator(rotation_range=8, width_shift_range=0.08, shear_range=0.3,
height_shift_range=0.08, zoom_range=0.08)
batches = gen.flow(X_train, y_train, batch_size=64)
val_batches = gen.flow(X_val, y_val, batch_size=64)
| Digit Recognizer |
7,390,641 | def main_tta(config, model_dir):
INFO = config['info']
TAG = config['tag']
CFG = config['cfg']
CFG['train'] = False
CFG['inference'] = True
inference_batch_size = 8
seed_torch(seed=CFG['seed'])
model = CustomModel(TAG['model_name'], CFG['target_size'], pretrained=False)
states = [torch.load(path)for path in glob.glob... | def get_bn_model() :
model = Sequential([
Lambda(standardize, input_shape=(28,28,1)) ,
Conv2D(32,(3,3), activation='relu'),
BatchNormalization() ,
Conv2D(32,(3,3), activation='relu'),
MaxPooling2D() ,
BatchNormalization() ,
Conv2D(64,(3,3), activation='relu'),
BatchNormalization() ,
Conv2D(64,(3,3), activation='relu'),... | Digit Recognizer |
7,390,641 | data_num = len(test)
model_num = len(model_dirs)
target_num = CFG['target_size']
channel_num = 4
stage1_predictions = np.zeros(( model_num, data_num, channel_num, target_num), dtype=np.float)
for config, model_dir in zip(tta_configs, tta_model_dirs):
stage1_predictions[model_dirs.index(model_dir)] = main_tta(config,... | model.optimizer.learning_rate=0.01
gen = image.ImageDataGenerator()
batches = gen.flow(X, y, batch_size=64)
history=model.fit_generator(generator=batches, steps_per_epoch=batches.n, epochs=3 ) | Digit Recognizer |
7,390,641 | <choose_model_class><EOS> | predictions = model.predict_classes(X_test, verbose=0)
submissions=pd.DataFrame({"ImageId": list(range(1,len(predictions)+1)) ,
"Label": predictions})
submissions.to_csv("DR.csv", index=False, header=True)
| Digit Recognizer |
3,729,811 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<predict_on_test> | batch_size=128
keras.__version__
| Digit Recognizer |
3,729,811 | def inference(model, states, test_loader, device):
model.to(device)
tk0 = tqdm(enumerate(test_loader), total=len(test_loader))
probs = []
for i,(features)in tk0:
features = features.to(device)
avg_preds = []
for state in states:
model.load_state_dict(state['model'])
model.eval()
with torch.no_grad() :
y_preds = mode... | train_df = pd.read_csv('.. /input/train.csv')
test_df = pd.read_csv('.. /input/test.csv')
pred_df = pd.read_csv('.. /input/sample_submission.csv')
| Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.