kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
11,978,455 | x1=0
x2=0
print("Classifying Kaggle's 'test.csv' using KNN where K=1 and MNIST 70k images.. ")
for i in range(0,28000):
for j in range(0,70000):
if np.absolute(X_test[i,:]-mnist_image[j,:] ).sum() ==0:
predictions[i]=mnist_label[j]
if i%1000==0:
print(" %d images classified perfectly"%(i),end="")
if j<60000:
x1+=1
el... | class MNISTDataset(Dataset):
def __init__(self, feature, target=None, transform=None):
self.X = feature
self.y = target
self.transform = transform
def __len__(self):
return len(self.X)
def __getitem__(self, idx):
if self.transform is not None:
return self.transform(self.X[idx]), self.y[idx]
elif self.y is None:
retu... | Digit Recognizer |
11,978,455 | final_pred = predictions[0:28000]<prepare_output> | data_transform = transforms.Compose([
transforms.ToPILImage() ,
transforms.RandomAffine(degrees=45, translate=(0.1, 0.1), scale=(0.8, 1.2)) ,
transforms.ToTensor() ])
train_set = MNISTDataset(featuresTrain.float() , targetsTrain, transform=data_transform)
validate_set = MNISTDataset(featuresValidation.float() , targe... | Digit Recognizer |
11,978,455 | my_submission = pd.DataFrame({'ImageId':np.arange(28000),'Label':final_pred.squeeze().astype(np.int)})
my_submission.head()<feature_engineering> | train_set = torch.utils.data.TensorDataset(featuresTrain.float() , targetsTrain)
validate_set = torch.utils.data.TensorDataset(featuresValidation.float() , targetsValidation)
test_set = torch.utils.data.TensorDataset(Test.float() ) | Digit Recognizer |
11,978,455 | my_submission["ImageId"]=my_submission["ImageId"]+1<save_to_csv> | train_loader = torch.utils.data.DataLoader(train_set, batch_size = batch_size, shuffle = True)
validate_loader = torch.utils.data.DataLoader(validate_set, batch_size = batch_size, shuffle = False)
test_loader = torch.utils.data.DataLoader(test_set, batch_size = batch_size, shuffle = False ) | Digit Recognizer |
11,978,455 | my_submission.to_csv('best_submission.csv', index=False )<install_modules> | class CNNModel(nn.Module):
def __init__(self):
super(CNNModel, self ).__init__()
self.cnn = nn.Sequential(nn.Conv2d(in_channels=1, out_channels=32, kernel_size=5),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2),
nn.Dropout(0.25),
nn.C... | Digit Recognizer |
11,978,455 | ! pip install.. /input/mlcollection/ml_collections-0.1.0-py3-none-any.whl<import_modules> | model = CNNModel()
optimizer = optim.RMSprop(model.parameters() , lr=0.001, alpha=0.9)
criterion = nn.CrossEntropyLoss()
lr_reduction = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=3, threshold=0.0001, threshold_mode='rel', cooldown=0, min_lr=0.00001)
if torch.cuda.is_available() :... | Digit Recognizer |
11,978,455 | 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... | count = 0
loss_list = []
iteration_list = []
average_training_accuracy = []
average_validation_accuracy = []
average_training_loss = []
average_validation_loss = [] | Digit Recognizer |
11,978,455 | CFG = {
'fold_num': 5,
'seed': 719,
'model_arch': 'resnext101_ibn_a',
'model_arch_eff':'tf_efficientnet_b4_ns',
'img_size': 512,
'epochs': 10,
'train_bs': 32,
'valid_bs': 32,
'lr': 1e-4,
'num_workers': 4,
'accum_iter': 1,
'verbose_step': 1,
'device': 'cuda' if torch.cuda.is_available() else 'cpu',
'tta': 4,
}
ckpt_path... | def train(epoch):
global count
model.train()
for batch_idx,(data, target)in enumerate(train_loader):
data, target = Variable(data), Variable(target)
if torch.cuda.is_available() :
data = data.cuda()
target = target.cuda()
optimizer.zero_grad()
output = model(data)
loss = criterion(output, target)
loss.backward()
opt... | Digit Recognizer |
11,978,455 | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head()<count_values> | def evaluate(data_loader, validate=False):
model.eval()
loss = 0
correct = 0
for data, target in data_loader:
data, target = Variable(data), Variable(target)
if torch.cuda.is_available() :
data = data.cuda()
target = target.cuda()
output = model(data)
loss += F.cross_entropy(output, target, size_average=False ).item(... | Digit Recognizer |
11,978,455 | train.label.value_counts()<load_from_csv> | def prediciton(data_loader):
model.eval()
test_pred = torch.LongTensor()
for i, data in enumerate(data_loader):
data = Variable(data[0])
if torch.cuda.is_available() :
data = data.cuda()
output = model(data)
pred = output.cpu().data.max(1, keepdim=True)[1]
test_pred = torch.cat(( test_pred, pred), dim=0)
return test... | Digit Recognizer |
11,978,455 | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head()<categorify> | out_df = pd.DataFrame(np.c_[np.arange(1, len(test_set)+1)[:,None], test_pred.numpy() ],
columns=['ImageId', 'Label'])
out_df.head() | Digit Recognizer |
11,978,455 | <import_modules><EOS> | out_df.to_csv('submission.csv', index=False ) | Digit Recognizer |
13,819,614 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<choose_model_class> | import torch
import torchvision
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
import copy
import time | Digit Recognizer |
13,819,614 | class CassvaImgClassifier(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.mod... | torch.backends.cudnn.enabled | Digit Recognizer |
13,819,614 | class IBNResnextCassava(nn.Module):
def __init__(self, arch='resnext101_ibn_a', n_class=5, pre=False):
super().__init__()
m = resnext101_ibn_a()
self.enc = nn.Sequential(*list(m.children())[:-2])
nc = list(m.children())[-1].in_features
self.head = nn.Sequential(
nn.AdaptiveAvgPool2d(1),
nn.Flatten() ,
nn.Linear(2048,... | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device ) | Digit Recognizer |
13,819,614 | class MishFunction(torch.autograd.Function):
@staticmethod
def forward(ctx, x):
ctx.save_for_backward(x)
return x * torch.tanh(F.softplus(x))
@staticmethod
def backward(ctx, grad_output):
x = ctx.saved_variables[0]
sigmoid = torch.sigmoid(x)
tanh_sp = torch.tanh(F.softplus(x))
return grad_output *(tanh_sp + x * sigmo... | Num_CNN = 12
n_epochs = 25
batch_size_train = 64
batch_size_test = 1000
learning_rate = 0.01
momentum = 0.5
log_interval = 100
random_seed = 121
torch.manual_seed(random_seed)
kaggle_input_data = "/kaggle/input/digit-recognizer/train.csv"
kaggle_input_validation = "/kaggle/input/digit-recognizer/test.csv"
kaggle_model... | Digit Recognizer |
13,819,614 | semi_weakly_supervised_model_urls = {
'resnet18': 'https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnet18-118f1556.pth',
'resnet50': 'https://dl.fbaipublicfiles.com/semiweaksupervision/model_files/semi_weakly_supervised_resnet50-16a12f1b.pth',
'resnext50_32x4d': 'https://dl.fbaip... | class Dataset(torch.utils.data.Dataset):
def __init__(self, dataframe):
self.labels = dataframe["label"].to_numpy()
self.dataframe = dataframe.loc[:,dataframe.columns != "label"]
def __len__(self):
return self.dataframe.shape[0]
def __getitem__(self, index):
X = torch.from_numpy(self.dataframe.iloc[index].values.reshap... | Digit Recognizer |
13,819,614 | class CassvaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = 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.model(x)... | df_input = pd.read_csv(kaggle_input_data)
df_validation = pd.read_csv(kaggle_input_validation)
df_train, df_test = train_test_split(df_input, test_size = 0.01)
training_set = Dataset(df_train)
training_generator = torch.utils.data.DataLoader(training_set, batch_size = batch_size_train,
shuffle = True)
test_set = D... | Digit Recognizer |
13,819,614 | ! pip install.. /input/mlcollection/ml_collections-0.1.0-py3-none-any.whl<feature_engineering> | import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim import lr_scheduler | Digit Recognizer |
13,819,614 | class AdaptiveConcatPool2d(nn.Module):
"Layer that concats `AdaptiveAvgPool2d` and `AdaptiveMaxPool2d`"
def __init__(self, size=None):
super().__init__()
self.size = size or 1
self.ap = nn.AdaptiveAvgPool2d(self.size)
self.mp = nn.AdaptiveMaxPool2d(self.size)
def forward(self, x): return torch.cat([self.mp(x), self.a... | class Net(nn.Module):
def __init__(self):
super(Net, self ).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=3)
self.batchnorm1 = nn.BatchNorm2d(32)
self.conv2 = nn.Conv2d(32, 32, kernel_size=3)
self.batchnorm2 = nn.BatchNorm2d(32)
self.conv3 = nn.Conv2d(32, 32, kernel_size=2, stride = 2)
self.batchnorm3 = nn.... | Digit Recognizer |
13,819,614 | if __name__ == '__main__':
VALID = False
test_num = len(os.listdir('.. /input/cassava-leaf-disease-classification/test_images'))
print('test_num:', test_num)
seed_everything(CFG['seed'])
folds = StratifiedKFold(n_splits=CFG['fold_num'], shuffle=True, random_state=CFG['seed'] ).split(np.arange(train.shape[0]), train.l... | train_losses = []
train_counter = []
test_losses = []
test_counter = [i*len(training_generator.dataset)for i in range(n_epochs + 1)]
log_interval = len(training_generator)
network_list = []
prediction_tensor = torch.zeros(kaggle_validation_set.shape[0],10 ) | Digit Recognizer |
13,819,614 | test['label'] = np.argmax(tst_preds, axis=1)
test.head()<save_to_csv> | def train(epoch, network, scheduler, network_id, device):
start_time = time.time()
network.train()
for batch_idx,(data, target)in enumerate(training_generator):
data = data.to(device)
target = target.to(device)
optimizer.zero_grad()
output = network(data)
loss = F.nll_loss(output, target)
loss.backward()
optimizer.... | Digit Recognizer |
13,819,614 | test.to_csv('submission.csv', index=False )<install_modules> | validation_tensor = kaggle_validation_set.to(device)
prediction_tensor = prediction_tensor.to(device)
for id_net in range(1, Num_CNN+1):
network, optimizer, scheduler = initialise_network(device)
for epoch in range(1, n_epochs+1):
train(epoch, network, scheduler, id_net, device)
test(network)
prediction_tensor = v... | Digit Recognizer |
13,819,614 | !pip install -q '/kaggle/input/birdcall-identification-submission-custom/Keras_Applications-1.0.8-py3-none-any.whl'
!pip install -q '/kaggle/input/birdcall-identification-submission-custom/efficientnet-1.1.0-py3-none-any.whl'<import_modules> | output_df = prediction_tensor.max(1)[1].to("cpu")
output_df = pd.DataFrame(output_df.numpy() , columns = ["Label"])
output_df.index.name = "ImageId"
output_df.index = output_df.index + 1 | Digit Recognizer |
13,819,614 | import numpy as np
import pandas as pd
import tensorflow as tf
import efficientnet.tfkeras as efn
import matplotlib.pyplot as plt
from tqdm.notebook import tqdm<define_search_space> | output_df.to_csv(prediction_path ) | Digit Recognizer |
11,437,677 | IMG_HEIGHT = 600
IMG_WIDTH = 800
IMG_SIZE = 600
IMG_TARGET_SIZE = 512
N_CHANNELS = 3
N_LABELS = 5
N_FOLDS = 5
BATCH_SIZE = 16
AUTO = tf.data.experimental.AUTOTUNE
IMAGENET_MEAN = tf.constant([0.485, 0.456, 0.406], dtype=tf.float32)
IMAGENET_STD = tf.constant([0.229, 0.224, 0.225], dtype=tf.float32 )<choose_model_class... | df = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
df2 = pd.read_csv('/kaggle/input/digit-recognizer/test.csv')
print(df.shape)
print(df2.shape ) | Digit Recognizer |
11,437,677 | def get_model(fold):
tf.keras.backend.clear_session()
net = efn.EfficientNetB4(
include_top=False,
weights=None,
input_shape=(IMG_TARGET_SIZE, IMG_TARGET_SIZE, N_CHANNELS),
)
for layer in reversed(net.layers):
if isinstance(layer, tf.keras.layers.BatchNormalization):
layer.trainable = False
else:
layer.trainable = T... | scaler = MinMaxScaler()
x = scaler.fit_transform(x)
x | Digit Recognizer |
11,437,677 | @tf.function
def decode_tfrecord_test(file_path):
image = tf.io.read_file(file_path)
image = tf.io.decode_jpeg(image)
image = tf.reshape(image, [IMG_HEIGHT, IMG_WIDTH, N_CHANNELS])
image = tf.cast(image, tf.float32)
image_id = tf.strings.split(file_path, '/')[-1]
return image, image_id<define_variables> | x1 = np.array(df2)
x1 = scaler.fit_transform(x1)
x1 = x1.reshape(( 28000,28,28,1))
x1.shape
| Digit Recognizer |
11,437,677 | def get_test_dataset() :
ignore_order = tf.data.Options()
ignore_order.experimental_deterministic = False
test_dataset = tf.data.Dataset.list_files('/kaggle/input/cassava-leaf-disease-classification/test_images/*.jpg')
test_dataset = test_dataset.with_options(ignore_order)
test_dataset = test_dataset.map(decode_tfrec... | y = np.array(y)
enc = OneHotEncoder(sparse=False)
y= y.reshape(( -1,1))
y = enc.fit_transform(y)
y.shape | Digit Recognizer |
11,437,677 | def show_first_test_batch() :
imgs, imgs_ids = next(iter(get_test_dataset()))
img = imgs[0].numpy().astype(np.float32)
print(f'imgs.shape: {imgs.shape}, imgs.dtype: {imgs.dtype}, imgs_ids.shape: {imgs_ids.shape}, imgs_ids.dtype: {imgs_ids.dtype}')
print('img mean: {:.3f}, img std {:.3f}, img min: {:.3f}, img max: {:.... | x_train,x_test,y_train,y_test = tts(x,y,test_size = 0.2, random_state=42)
print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape ) | Digit Recognizer |
11,437,677 | submission = pd.DataFrame(columns=['image_id', 'label'])
preds_dict = dict()
for fold in range(N_FOLDS):
model = get_model(fold)
for idx,(imgs, image_ids)in tqdm(enumerate(get_test_dataset())) :
for img, image_id in zip(imgs, image_ids.numpy().astype(str)) :
pred = predict_tta(model, img)
if image_id in preds_dict:
... | import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
from keras.optimizers import RMSprop
from keras.preprocessing.image import ImageDataGenerator
f... | Digit Recognizer |
11,437,677 | import numpy as np
import pandas as pd
import os
<install_modules> | model = keras.Sequential()
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu', input_shape =(28,28,1)))
model.add(Conv2D(filters = 32, kernel_size =(5,5),padding = 'Same',
activation ='relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))
model.add(Conv2D(filters =... | Digit Recognizer |
11,437,677 | !pip install timm --no-index --find-links=file:///kaggle/input/timm-package/<install_modules> | callbacks = [
keras.callbacks.EarlyStopping(
monitor='val_loss',
min_delta=1e-5,
patience=25,
verbose=1)
] | Digit Recognizer |
11,437,677 | !pip install albumentations --no-index --find-links=file:///kaggle/input/albumentationspackage/<import_modules> | predictions=model.predict(x1)
pre=predictions.argmax(axis=-1 ) | Digit Recognizer |
11,437,677 | import sys
import torch
import torch.nn.functional as F
import torch.nn as nn
from torch.nn import Parameter
import os
import cv2
import timm<import_modules> | submission = pd.Series(pre,name="Label")
submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),submission],axis = 1)
submission.to_csv("final_submission_v1.csv",index=False)
submission.head() | Digit Recognizer |
11,232,489 | import albumentations as A<normalization> | from sklearn.model_selection import train_test_split
import tensorflow as tf
from tensorflow.keras import layers, Sequential, optimizers
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt | Digit Recognizer |
11,232,489 | def gem(x, p=3, eps=1e-5):
return F.avg_pool2d(x.clamp(min=eps ).pow(p),(x.size(-2), x.size(-1)) ).pow(1./p)
class GeM(nn.Module):
def __init__(self, p=3, eps=1e-5):
super(GeM, self ).__init__()
self.p = Parameter(torch.ones(1)* p)
self.eps = eps
def forward(self, x):
return gem(x, p=self.p, eps=self.eps)
def __repr... | print("GPUs Available: ", tf.config.experimental.list_physical_devices('GPU')) | Digit Recognizer |
11,232,489 | class Net(nn.Module):
def __init__(self, num_classes=5):
super().__init__()
self.model = timm.create_model('seresnext50_32x4d', pretrained=False)
self._avg_pooling = nn.AdaptiveAvgPool2d(1)
self.dropout=nn.Dropout(0.5)
self._fc = nn.Linear(2048 , num_classes, bias=True)
def forward(self, inputs):
input_iid = inputs... | raw_csv = "/kaggle/input/digit-recognizer/train.csv"
test_csv = "/kaggle/input/digit-recognizer/test.csv" | Digit Recognizer |
11,232,489 | class DatasetTest() :
def __init__(self, test_data_dir):
self.ds = self.get_list(test_data_dir)
self.root_dir = test_data_dir
self.val_trans=A.Compose([A.HorizontalFlip(p=0.5),
A.VerticalFlip(p=0.5),
A.ColorJitter(brightness=0.1, contrast=0.2, saturation=0.2, hue=0.00, always_apply=False, p=1.0),
A.RandomCrop(height= ... | raw_df = pd.read_csv(raw_csv)
test_df = pd.read_csv(test_csv ) | Digit Recognizer |
11,232,489 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
kaggle_root = '/kaggle/input'
model_dir = os.path.join(kaggle_root, 'cassva-models-se50-640')
weights = [os.path.join(model_dir, f)for f in os.listdir(model_dir)]
test_datadir= os.path.join(kaggle_root, 'cassava-leaf-disease-classification/test_ima... | def get_image_and_label(data_frame):
IMGs = data_frame.drop(["label"], axis=1 ).values if 'label' in data_frame.columns else data_frame.values
IMGs = np.array([image.reshape(( 28, 28)) for image in IMGs])
IMGs = np.expand_dims(IMGs, axis=3)
labels = data_frame['label'].values if 'label' in data_frame.columns else Non... | Digit Recognizer |
11,232,489 | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
sys.path.append(package_path )<set_options> | raw_IMGs, raw_labels = get_image_and_label(raw_df)
test_IMGs, _ = get_image_and_label(test_df ) | Digit Recognizer |
11,232,489 | warnings.filterwarnings("ignore")
<init_hyperparams> | classes = len(set(raw_labels))
classes | Digit Recognizer |
11,232,489 | CFG = {
'fold_num': 5,
'seed': 719,
'model_arch': 'tf_efficientnet_b4_ns',
'img_size': 512,
'epochs': 10,
'train_bs': 32,
'valid_bs': 32,
'lr': 1e-4,
'num_workers': 4,
'accum_iter': 1,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 3,
'used_epochs': [6,7,8,9],
'weights': [1,1,1,1]
}<load_from_csv> | raw_labels = to_categorical(raw_labels, num_classes=classes)
raw_labels | Digit Recognizer |
11,232,489 | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head(10 )<count_values> | train_IMGs, validation_IMGs, trian_labels, validation_labels = train_test_split(raw_IMGs, raw_labels, test_size=0.1, random_state=42 ) | Digit Recognizer |
11,232,489 | train.label.value_counts()<load_from_csv> | model = Sequential([
layers.Conv2D(32,(3,3), activation="relu", input_shape=(28,28,1)) ,
layers.BatchNormalization() ,
layers.MaxPooling2D(( 2,2)) ,
layers.Conv2D(64,(3,3), activation="relu"),
layers.BatchNormalization() ,
layers.MaxPooling2D(( 2,2)) ,
layers.Conv2D(128,(3,3), activation="relu"),
layers.BatchNormalizat... | Digit Recognizer |
11,232,489 | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head()<set_options> | model.compile(loss="categorical_crossentropy",
optimizer=optimizers.Adam(learning_rate=1e-4),
metrics=['accuracy'] ) | Digit Recognizer |
11,232,489 | def seeder(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]
return im_... | train_datagen = ImageDataGenerator(
rescale=1/255,
rotation_range=20,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1,
shear_range=0.1
)
validation_datagen = ImageDataGenerator(rescale=1/255)
test_datagen = ImageDataGenerator(rescale=1/255 ) | Digit Recognizer |
11,232,489 | img = get_img('.. /input/cassava-leaf-disease-classification/train_images/1000015157.jpg')
plt.figure(figsize=(15,15))
plt.imshow(img)
plt.show()<categorify> | train_generator = train_datagen.flow(train_IMGs, trian_labels, batch_size=32)
validation_generator = train_datagen.flow(validation_IMGs, validation_labels, batch_size=32)
test_generator = test_datagen.flow(test_IMGs, batch_size=32, shuffle=False ) | Digit Recognizer |
11,232,489 | class CassavaDataset(Dataset):
def __init__(self,df,data_root,transforms=None,output_label=True):
super(CassavaDataset ).__init__()
self.df=df.reset_index().copy()
self.data_root=data_root
self.transforms=transforms
self.output_label=output_label
def __len__(self):
return self.df.shape[0]
def __getitem__(self,index:int... | history = model.fit_generator(train_generator, epochs=100, validation_data=validation_generator, verbose=1 ) | Digit Recognizer |
11,232,489 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | model.evaluate(validation_IMGs, validation_labels ) | Digit Recognizer |
11,232,489 | class CassvaImgClassifier(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.mod... | accuracy = history.history["accuracy"]
val_accuracy = history.history["val_accuracy"]
loss = history.history["loss"]
val_loss = history.history["val_loss"]
epochs = range(len(accuracy)) | Digit Recognizer |
11,232,489 | if __name__ == "__main__":
seeder(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))
test = pd.DataFrame()
test['image_id'] = list(os.lis... | pred_labels = model.predict_generator(test_generator ) | Digit Recognizer |
11,232,489 | test['label'] = np.argmax(tst_preds, axis=1)
test.head()<save_to_csv> | pred_labels = np.argmax(pred_labels, axis=-1)
pred_labels | Digit Recognizer |
11,232,489 | test.to_csv('submission.csv', index=False )<import_modules> | my_submission = pd.DataFrame({'ImageId': test_df.index + 1, 'Label': pred_labels})
my_submission.head() | Digit Recognizer |
11,232,489 | <install_modules><EOS> | my_submission.to_csv('submission.csv', index=False ) | Digit Recognizer |
11,265,589 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<import_modules> | %matplotlib inline
| Digit Recognizer |
11,265,589 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv' ) | Digit Recognizer |
11,265,589 | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv' )<init_hyperparams> | Y_train=train['label']
X_train = train.drop(labels = ["label"],axis = 1)
Y_train.value_counts() | Digit Recognizer |
11,265,589 | CFG = {
'normalize_mean':[0.42984136, 0.49624753, 0.3129598],
'normalize_std':[0.21417203, 0.21910103, 0.19542212],
'device': 'cuda:0',
'fold_num': 5,
'seed': 42,
'valid_bs': 32,
'num_workers': 4,
'model_arch': ['tf_efficientnet_b4_ns',
'tf_efficientnet_b4_ns',
'tf_efficientnet_b4_ns',
'tf_efficientnet_b4_ns',
'tf_effi... | X_train = X_train / 255
test = test / 255 | Digit Recognizer |
11,265,589 | 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 = False
torch.cuda.manual_seed_all(seed)
def get_img(path):
im_bgr = cv2.imread(p... | print("The shape of the labels before One Hot Encoding",Y_train.shape)
Y_train = to_categorical(Y_train, num_classes = 10)
print("The shape of the labels after One Hot Encoding",Y_train.shape ) | Digit Recognizer |
11,265,589 | 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__(sel... | random_seed = 2
X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size = 0.3, random_state=random_seed ) | Digit Recognizer |
11,265,589 | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | datagen = ImageDataGenerator(zoom_range = 0.1, width_shift_range = 0.1, height_shift_range = 0.1, rotation_range = 10 ) | Digit Recognizer |
11,265,589 | class CassvaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained, num_classes=5)
def forward(self, x):
x = self.model(x)
return x<create_dataframe> | model = Sequential()
model.add(Conv2D(filters = 32, kernel_size =(3, 3), activation = 'relu', input_shape =(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(filters = 32, kernel_size =(3, 3), activation = 'relu'))
model.add(BatchNormalization())
model.add(Conv2D(filters = 32, kernel_size =(5, 5), activa... | Digit Recognizer |
11,265,589 | seed_everything(CFG['seed'])
tst_preds = []
device = torch.device(CFG['device'])
test = pd.DataFrame()
test['image_id'] = list(os.listdir('.. /input/cassava-leaf-disease-classification/test_images/'))
for i, sub_model in enumerate(CFG['used_epochs']):
if "vit" not in sub_model:
test_ds = CassavaDataset(test, '.. /inp... | model.compile(optimizer='adam',metrics=['accuracy'],loss='categorical_crossentropy' ) | Digit Recognizer |
11,265,589 | test['label'] = np.argmax(tst_preds, axis=1)
test.to_csv('submission.csv', index=False )<install_modules> | reduction_lr = ReduceLROnPlateau(monitor='val_accuracy',patience=2, verbose=1, factor=0.2, min_lr=0.00001 ) | Digit Recognizer |
11,265,589 | !mkdir -p /tmp/pip/cache/
!cp.. /input/omegaconf/PyYAML-5.4b2-cp38-cp38-manylinux1_x86_64.whl /tmp/pip/cache/
!cp.. /input/omegaconf/omegaconf-2.0.5-py3-none-any.whl /tmp/pip/cache/
!cp.. /input/omegaconf/typing_extensions-3.7.4.3-py3-none-any.whl /tmp/pip/cache/
!pip install --no-index --find-links /tmp/pip/cache/ ome... | hist = model.fit_generator(datagen.flow(X_train,Y_train,batch_size=32),epochs=20,validation_data =(X_val,Y_val),callbacks=[reduction_lr] ) | Digit Recognizer |
11,265,589 | sys.path.append('.. /input/timm-pytorch-image-models/pytorch-image-models-master')
sys.path.append(".. /input/cleanlab/")
warnings.filterwarnings('ignore')
<set_options> | 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 |
11,265,589 | mean, std =(0.485, 0.456, 0.406),(0.229, 0.224, 0.225)
def get_transforms(img_size=(512, 512)) :
transformations = Compose([
PadIfNeeded(min_height=img_size[0], min_width=img_size[1]),
CenterCrop(img_size[0], img_size[1]),
Normalize(mean=mean, std=std, max_pixel_value=255.0, p=1.0),
ToTensorV2(p=1.0),
], p=1.0)
retur... | y_pred = model.predict(X_val, batch_size = 64)
y_pred = np.argmax(y_pred,axis = 1)
y_pred = pd.Series(y_pred,name="Label")
y_pred | Digit Recognizer |
11,265,589 | def create_model(model_name: str,
pretrained: bool,
num_classes: int,
in_chans: int):
model = timm.create_model(model_name=model_name,
pretrained=pretrained,
num_classes=num_classes,
in_chans=in_chans)
return model<load_pretrained> | y_pred1 = model.predict(test, batch_size = 64)
y_pred1 = np.argmax(y_pred1,axis = 1)
y_pred1 = pd.Series(y_pred1,name="Label")
y_pred1 | Digit Recognizer |
11,265,589 | <find_best_params><EOS> | submission = pd.concat([pd.Series(range(1,28001),name = "ImageId"),y_pred1],axis = 1)
submission.to_csv("submission.csv",index=False ) | Digit Recognizer |
11,342,302 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<define_search_space> | from matplotlib import pyplot as plt
import math, os, re, time, random
import numpy as np, pandas as pd, seaborn as sns
import tensorflow as tf
from sklearn.model_selection import train_test_split | Digit Recognizer |
11,342,302 | eff_b0_cfg_s =
eff_b0_cfg = OmegaConf.create(eff_b0_cfg_s )<define_variables> | rank_0_tensor = tf.constant(1)
print(rank_0_tensor); print('')
rank_1_tensor = tf.constant([1, 0, 0])
print(rank_1_tensor); print('')
rank_2_tensor = tf.constant([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]])
print(rank_2_tensor ) | Digit Recognizer |
11,342,302 | name = '14-10-36'
cfg = eff_b0_cfg
do_predict = True
do_submit = True
img_dir = '.. /input/cassava-leaf-disease-merged/train/'
label_path = '.. /input/cassava-leaf-disease-merged/merged.csv'
log_dir = os.path.join('.. /input/cassava-public-ckpt', name)
n_folds = len(glob(os.path.join(log_dir, 'checkpoints/*.ckpt')))
... | rank_0_tensor = tf.constant(1, dtype = tf.float16)
print(rank_0_tensor); print('')
rank_1_tensor = tf.constant([1, 0, 0], dtype = tf.float32)
print(rank_1_tensor); print('')
rank_2_tensor = tf.constant([[1, 0, 0],
[0, 1, 0],
[0, 0, 1]], dtype = tf.int32)
print(rank_2_tensor ) | Digit Recognizer |
11,342,302 | seed_everything(42)
label_df = pd.read_csv(label_path)
if 'fold' not in label_df.columns:
skf = StratifiedKFold(n_splits=5, shuffle=True)
label_df.loc[:, 'fold'] = 0
for fold_num,(train_index, val_index)in enumerate(skf.split(X=label_df.index, y=label_df.label.values)) :
label_df.loc[label_df.iloc[val_index].index, ... | print(type(rank_2_tensor.numpy()))
print(rank_2_tensor.numpy()); print('')
tensor_to_array = np.add(rank_2_tensor, 1)
print(type(tensor_to_array))
print(tensor_to_array); print('')
array_to_tensor = tf.add(rank_2_tensor.numpy() , 1)
print(array_to_tensor ) | Digit Recognizer |
11,342,302 | if do_submit:
sub = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
infer = pl.Trainer(gpus=1)
test_dataset = TestDataset('.. /input/cassava-leaf-disease-classification/test_images',
sub,
img_size=cfg.img_size)
test_dataloader = DataLoader(test_dataset,
batch_size=cfg.batch_size,
n... | model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(256, activation='relu', input_shape =(784,)))
model.add(tf.keras.layers.Dense(128, activation='swish'))
model.add(tf.keras.layers.Dense(10, activation='softmax'))
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["categorical_... | Digit Recognizer |
11,342,302 | label_df = label_df.sort_values(by='image_id', ascending=1)
pred_df = pred_df.sort_values(by='image_id', ascending=1)
ids, labels = label_df.image_id.values, label_df.label.values
preds = np.array([literal_eval(pred)if isinstance(pred, str)else pred for pred in pred_df.label.values])
print(f'total {len(ids)} images'... | model = tf.keras.models.Sequential([
tf.keras.layers.Dense(256, activation = 'relu', input_shape =(784,)) ,
tf.keras.layers.Dense(128, activation = 'swish'),
tf.keras.layers.Dense(10, activation = 'softmax')
])
model.compile(optimizer = "adam", loss = "categorical_crossentropy", metrics = ["categorical_accuracy"])
m... | Digit Recognizer |
11,342,302 | s = labels
psx = preds
K = len(np.unique(s))
thresholds = [np.mean(psx[:,k][s == k])for k in range(K)]
thresholds = np.asarray(thresholds)
confident_joint = np.zeros(( K, K), dtype = int)
for i, row in enumerate(psx):
s_label = s[i]
confident_bins = row >= thresholds - 1e-6
num_confident_bins = sum(confident_bins)
i... | inputs = tf.keras.Input(shape =(784,))
x = tf.keras.layers.Dense(256, activation = 'relu' )(inputs)
x = tf.keras.layers.Dense(128, activation = 'swish' )(x)
outputs = tf.keras.layers.Dense(10, activation = 'softmax' )(x)
model = tf.keras.Model(inputs = inputs, outputs = outputs)
model.compile(optimizer = "adam", lo... | Digit Recognizer |
11,342,302 | total_idx = np.arange(len(ids))
clean_idx = np.array([idx for idx in total_idx if idx not in label_errors_idx])
guesses = np.stack(noise_masks_per_class ).argmax(axis=0)
guesses[clean_idx] = labels[clean_idx]
clean_ids = ids[clean_idx]
clean_labels = labels[clean_idx]
clean_guesses = guesses[clean_idx]
noisy_ids = id... | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
train.head() | Digit Recognizer |
11,342,302 | all_data = pd.DataFrame({'image_id': ids,
'given_label': labels,
'guess_label': guesses})
all_data['is_noisy'] =(all_data.given_label != all_data.guess_label)
all_data['max_prob'] = preds.max(axis=1 )<define_variables> | labels = train['label']
train = train.drop('label', axis = 1)
train = train / 255.0
test = test / 255.0 | Digit Recognizer |
11,342,302 | class_colors = np.array(['
num2class = [f'{idx}-{elem}' for idx, elem in enumerate(num2class)]<load_pretrained> | labels = tf.one_hot(labels, depth = 10 ).numpy() | Digit Recognizer |
11,342,302 | with open('.. /input/train-weights-optimization/best_weights.json', 'r')as f:
weights_dict = json.load(f)
weights_dict<load_pretrained> | datagen = tf.keras.preprocessing.image.ImageDataGenerator(
rotation_range = 20,
zoom_range = 0.1,
width_shift_range = 0.1,
height_shift_range = 0.1
) | Digit Recognizer |
11,342,302 | normal_configs = []
tta_configs = []
normal_model_dirs = []
tta_model_dirs = []
for model_dir in weights_dict.keys() :
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... | EPOCHS = 45
BATCH_SIZE = 64
NUM_NETS = 25
VERBOSE = 0 | Digit Recognizer |
11,342,302 | def get_score(y_true, y_pred):
return accuracy_score(y_true, y_pred)
@contextmanager
def timer(name):
t0 = time.time()
LOGGER.info(f'[{name}] start')
yield
LOGGER.info(f'[{name}] done in {time.time() - t0:.0f} s.')
def seed_torch(seed=42):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(s... | model = [0] * NUM_NETS
for j in range(NUM_NETS):
model[j] = tf.keras.models.Sequential()
model[j].add(tf.keras.layers.Conv2D(32, kernel_size = 3, activation = 'relu', input_shape =(28, 28, 1)))
model[j].add(tf.keras.layers.BatchNormalization())
model[j].add(tf.keras.layers.Conv2D(32, kernel_size = 3, activation = 're... | Digit Recognizer |
11,342,302 | test = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
test.head()<normalization> | lr_callback = tf.keras.callbacks.LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
history = [0] * NUM_NETS
for j in range(NUM_NETS):
X_train, X_val, y_train, y_val = train_test_split(train, labels, test_size = 0.1)
STEPS_PER_EPOCH = X_train.shape[0] // 64
history[j] = model[j].fit_generator(datagen.flow(X_train, y_t... | Digit Recognizer |
11,342,302 | 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... | preds = np.zeros(( test.shape[0],10))
for j in range(NUM_NETS):
preds += model[j].predict(test)/ NUM_NETS
probs = pd.DataFrame(preds)
probs.to_csv('ensemble_probs')
probs.columns = probs.columns.astype(str)
print(probs.columns)
probs.head() | Digit Recognizer |
11,342,302 | 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... | submission = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv')
submission['Label'] = preds.argmax(axis = 1)
submission.to_csv("ensemble.csv", index = False)
submission.head(10 ) | Digit Recognizer |
11,342,302 | def get_transforms(*, aug_list, cfg):
return Compose(
_get_augmentations(aug_list, cfg)
)<choose_model_class> | prev_cnn_probs = pd.read_csv('.. /input/mnistsavedprobs/ensemble_probs')
prev_cnn_probs = prev_cnn_probs.drop('Unnamed: 0', axis = 1)
print(prev_cnn_probs.columns)
prev_cnn_probs.head() | Digit Recognizer |
11,342,302 | 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... | new_probs = probs.add(prev_cnn_probs ).divide(2)
new_probs.head() | Digit Recognizer |
11,342,302 | <load_pretrained><EOS> | submission2 = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv')
submission2['Label'] = new_probs.values.argmax(axis = 1)
submission2.to_csv("ensemble2.csv", index = False)
submission2.head(10 ) | Digit Recognizer |
11,333,538 | <SOS> metric: categorizationaccuracy Kaggle data source: digit-recognizer<save_to_csv> | %matplotlib inline
| Digit Recognizer |
11,333,538 | predictions_list = []
model_dir_list = []
for config, model_dir in zip(normal_configs, normal_model_dirs):
predictions_list.append(main(config, model_dir))
model_dir_list.append(model_dir)
for config, model_dir in zip(tta_configs, tta_model_dirs):
predictions_list.append(main_tta(config, model_dir))
model_dir_list.app... | print(tf.version.VERSION ) | Digit Recognizer |
11,333,538 | predictions = np.zeros(predictions_list[0].shape, dtype=predictions_list[0].dtype)
for i, key in zip(range(len(predictions_list)) , model_dir_list):
predictions += predictions_list[i] * weights_dict[key]
test['label'] = predictions.argmax(1)
test[['image_id', 'label']].to_csv(OUTPUT_DIR+'submission.csv', index=False)... | train = pd.read_csv("/kaggle/input/digit-recognizer/train.csv")
test = pd.read_csv("/kaggle/input/digit-recognizer/test.csv" ) | Digit Recognizer |
11,333,538 | !mkdir -p /tmp/pip/cache/
!cp.. /input/omegaconf/PyYAML-5.4b2-cp38-cp38-manylinux1_x86_64.whl /tmp/pip/cache/
!cp.. /input/omegaconf/omegaconf-2.0.5-py3-none-any.whl /tmp/pip/cache/
!cp.. /input/omegaconf/typing_extensions-3.7.4.3-py3-none-any.whl /tmp/pip/cache/
!pip install --no-index --find-links /tmp/pip/cache/ ome... | train_X = train.loc[:, "pixel0":"pixel783"]
train_y = train.loc[:, "label"]
| Digit Recognizer |
11,333,538 | sys.path.append('.. /input/timm-pytorch-image-models/pytorch-image-models-master')
sys.path.append(".. /input/cleanlab/")
warnings.filterwarnings('ignore')
<set_options> | treshhold=0.1
train_X[train_X<treshhold]=0
test[test<treshhold]=0 | Digit Recognizer |
11,333,538 | mean, std =(0.485, 0.456, 0.406),(0.229, 0.224, 0.225)
def get_transforms(img_size=(512, 512)) :
transformations = Compose([
PadIfNeeded(min_height=img_size[0], min_width=img_size[1]),
CenterCrop(img_size[0], img_size[1]),
Normalize(mean=mean, std=std, max_pixel_value=255.0, p=1.0),
ToTensorV2(p=1.0),
], p=1.0)
retur... | train_X = train_X / 255.0
test_X = test / 255.0
train_X = train_X.values.reshape(-1,28,28,1)
test_X = test_X.values.reshape(-1,28,28,1)
train_y = to_categorical(train_y, num_classes = 10 ) | Digit Recognizer |
11,333,538 | def create_model(model_name: str,
pretrained: bool,
num_classes: int,
in_chans: int):
model = timm.create_model(model_name=model_name,
pretrained=pretrained,
num_classes=num_classes,
in_chans=in_chans)
return model<load_pretrained> | def build_model(input_shape=(28, 28, 1)) :
model = Sequential()
model.add(Conv2D(32, kernel_size = 3, activation='swish', input_shape =(28, 28, 1)))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 3, activation='swish'))
model.add(BatchNormalization())
model.add(Conv2D(32, kernel_size = 5, strides... | Digit Recognizer |
11,333,538 | def get_state_dict_from_checkpoint(log_dir, fold_num):
ckpt_path = glob(os.path.join(log_dir, f'checkpoints/*fold{fold_num}*.ckpt')) [0]
state_dict = pl_load(ckpt_path, map_location='cpu')
if 'state_dict' in state_dict:
state_dict = state_dict['state_dict']
did_distillation = False
state_dict = OrderedDict(( k.replace... | 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 ) | Digit Recognizer |
11,333,538 | class LitTester(pl.LightningModule):
def __init__(self, network_cfg, state_dict):
super(LitTester, self ).__init__()
self.model = create_model(**network_cfg)
self.model.load_state_dict(state_dict)
self.model.eval()
def forward(self, x):
x = self.model(x)
return x
def test_step(self, batch, batch_idx):
score = torch.... | learning_rate_reduction = ReduceLROnPlateau(monitor='accuracy',
patience=3,
verbose=1,
factor=0.8,
min_lr=0.001)
annealer = LearningRateScheduler(lambda x: 1e-3 * 0.95 ** x)
early_stop=EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1, mode='auto',
baseline=None, restore_best_weights=True ) | Digit Recognizer |
11,333,538 | eff_b0_cfg_s =
eff_b0_cfg = OmegaConf.create(eff_b0_cfg_s )<define_variables> | %%time
nets=10
model = [0] *nets
history = [0] * nets
skf = StratifiedKFold(n_splits=nets, shuffle = True, random_state=1)
skf.get_n_splits(train_X, train['label'])
print(skf)
number=0
for train_index, test_index in skf.split(train_X, train['label']):
print("SPLIT ",number," TRAIN index:", train_index, "TEST index:"... | Digit Recognizer |
11,333,538 | name = '14-10-36'
cfg = eff_b0_cfg
do_predict = True
do_submit = False
img_dir = '.. /input/cassava-leaf-disease-merged/train/'
label_path = '.. /input/cassava-leaf-disease-merged/merged.csv'
log_dir = os.path.join('.. /input/cassava-public-ckpt', name)
n_folds = len(glob(os.path.join(log_dir, 'checkpoints/*.ckpt')))
... | for number in range(0,nets):
model[number].save("StratifiedKFold_10_batch100_double_val_loss_"+str(number)+".h5" ) | Digit Recognizer |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.