kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,309,110 | lrs = []
losses = []
wds = []
iter_count = 600
learner.lr_find(wd=1e-6, num_it=iter_count)
lrs.append(learner.recorder.lrs)
losses.append(learner.recorder.losses)
wds.append('1e-6')
learner = getLearner()
learner.lr_find(wd=1e-4, num_it=iter_count)
lrs.append(learner.recorder.lrs)
losses.append(learner.recorder.l... | 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... | Cassava Leaf Disease Classification |
14,309,110 | max_lr = 2e-2
wd = 1e-4
learner.fit_one_cycle(cyc_len=8, max_lr=max_lr, wd=wd )<save_model> | CFG = {
'fold_num': 10,
'seed': 719,
'model_arch': 'tf_efficientnet_b3_ns',
'img_size': 384,
'epochs': 60,
'train_bs': 28,
'valid_bs': 32,
'lr': 1e-2,
'num_workers': 5,
'accum_iter': 1,
'verbose_step': 2,
'device': 'cuda:0',
'tta': 6,
'used_epochs': [6,7,8,9],
'weights': [1,1,1,1]
} | Cassava Leaf Disease Classification |
14,309,110 | learner.save(MODEL_PATH + '_stage1' )<train_model> | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head() | Cassava Leaf Disease Classification |
14,309,110 | learner.fit_one_cycle(cyc_len=12, max_lr=slice(4e-5,4e-4))<save_model> | train.label.value_counts() | Cassava Leaf Disease Classification |
14,309,110 | learner.save(MODEL_PATH + '_stage2' )<train_model> | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head() | Cassava Leaf Disease Classification |
14,309,110 |
<compute_test_metric> | 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... | Cassava Leaf Disease Classification |
14,309,110 | preds,y, loss = learner.get_preds(with_loss=True)
acc = accuracy(preds, y)
print('The accuracy is {0} %.'.format(acc))<categorify> | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | Cassava Leaf Disease Classification |
14,309,110 | def hooked_backward(m, oneBatch, cat):
with hook_output(m[0])as hook_a:
with hook_output(m[0], grad=True)as hook_g:
preds = m(oneBatch)
preds[0,int(cat)].backward()
return hook_a,hook_g<compute_train_metric> | 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... | Cassava Leaf Disease Classification |
14,309,110 | probs = np.exp(preds[:,1])
fpr, tpr, thresholds = roc_curve(y, probs, pos_label=1)
roc_auc = auc(fpr, tpr)
print('ROC area is {0}'.format(roc_auc))<init_hyperparams> | if __name__ == '__main__':
seed_everything(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(d... | Cassava Leaf Disease Classification |
14,309,110 | learner.load(MODEL_PATH + '_stage2')
n_aug = 12
preds_n_avg = np.zeros(( len(learner.data.test_ds.items),2))
for n in tqdm_notebook(range(n_aug), 'Running TTA...'):
preds,y = learner.get_preds(ds_type=DatasetType.Test, with_loss=False)
preds_n_avg = np.sum([preds_n_avg, preds.numpy() ], axis=0)
preds_n_avg = preds_n... | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
14,309,110 | <load_from_csv><EOS> | test.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,259,667 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<save_to_csv> | !pip install.. /input/timm034/timm-0.3.4-py3-none-any.whl | Cassava Leaf Disease Classification |
14,259,667 | imgDataBunch.export(fname='./export.pkl' )<categorify> | import time
import os
import timm
import numpy as np
import pandas as pd
import cv2
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset
from torch.utils.data.sampler import SubsetRandomSampler, RandomSampler, SequentialSampler
import albumentations
from al... | Cassava Leaf Disease Classification |
14,259,667 | sz = 68
def imageToTensorImage(path):
bgr_img = cv2.imread(path)
b,g,r = cv2.split(bgr_img)
rgb_img = cv2.merge([r,g,b])
H,W,C = rgb_img.shape
rgb_img = rgb_img[(H-sz)//2:(sz +(H-sz)//2),(H-sz)//2:(sz +(H-sz)//2),:] / 256
return vision.Image(px=pil2tensor(rgb_img, np.float32))
img = imageToTensorImage('/kaggle/input... | image_folder = '.. /input/cassava-leaf-disease-classification/test_images/'
enet_type = 'cspresnext50'
image_size = 512
batch_size = 4
num_workers = 4
out_dim = 5
device = torch.device('cuda' ) | Cassava Leaf Disease Classification |
14,259,667 | !pip install fastai==0.7.0 --no-deps
!pip install torch==0.4.1 torchvision==0.2.1<import_modules> | ls.. /input/cdl-cspresnext50-512/ | Cassava Leaf Disease Classification |
14,259,667 | from fastai.conv_learner import *
from fastai.dataset import *
import pandas as pd
import numpy as np
import os
from sklearn.model_selection import train_test_split
<define_variables> | model_pths = [
'.. /input/cdl-cspresnext50-512/light_best_model_fold0.pth',
'.. /input/cdl-cspresnext50-512/light_best_model_fold1.pth',
'.. /input/cdl-cspresnext50-512/light_best_model_fold2.pth',
'.. /input/cdl-cspresnext50-512/light_best_model_fold3.pth',
'.. /input/cdl-cspresnext50-512/light_best_model_fold4.pth',
... | Cassava Leaf Disease Classification |
14,259,667 | MODEL_PATH = 'Dn121_v1'
TRAIN = '.. /input/train/'
TEST = '.. /input/test/'
LABELS = '.. /input/train_labels.csv'
SAMPLE_SUB = '.. /input/sample_submission.csv'
ORG_SIZE=96
BATCH_SIZE = 128<choose_model_class> | class net(nn.Module):
def __init__(self, model_name=enet_type, pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=pretrained)
n_features = self.model.head.fc.in_features
self.model.head.fc = nn.Linear(n_features, 5)
def forward(self, x):
output = self.model(x)
return output | Cassava Leaf Disease Classification |
14,259,667 | arch = dn121
nw = 4<split> | class LEAFDataset(Dataset):
def __init__(self, folder, transforms=None):
self.file_names = os.listdir(folder)
self.transforms = transforms
def __len__(self):
return len(self.file_names)
def __getitem__(self, index):
image_id = self.file_names[index]
image_file = os.path.join(image_folder, image_id)
image = cv2.imrea... | Cassava Leaf Disease Classification |
14,259,667 | train_df = pd.read_csv(LABELS ).set_index('id')
train_names = train_df.index.values
train_labels = np.asarray(train_df['label'].values)
print("Number of positive samples = {:.4f}%".format(np.count_nonzero(train_labels)*100/len(train_labels)))
test_names = [f.replace(".tif","")for f in os.listdir(TEST)]
tr_n, val_n =... | transform = albumentations.Compose([
albumentations.Resize(image_size, image_size),
albumentations.Normalize() ,
ToTensorV2()
] ) | Cassava Leaf Disease Classification |
14,259,667 | class HCDDataset(FilesDataset):
def __init__(self, fnames, path, transform):
self.train_df = train_df
super().__init__(fnames, transform, path)
def get_x(self, i):
img = open_image(os.path.join(self.path, self.fnames[i]+".tif"))
img = img[(ORG_SIZE-self.sz)//2:(ORG_SIZE+self.sz)//2,(ORG_SIZE-self.sz)//2:(ORG_SIZE+self... | res = []
for model_pth in model_pths:
model = net(enet_type)
model.load_state_dict(torch.load(model_pth))
model.eval()
model.to(device)
test_dataset = LEAFDataset(image_folder, transforms=transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, num_workers=num_workers)
single_model_... | Cassava Leaf Disease Classification |
14,259,667 | def get_data(sz, bs):
aug_tfms = [RandomRotate(20, tfm_y=TfmType.NO),
RandomDihedral(tfm_y=TfmType.NO)]
tfms = tfms_from_model(arch, sz, crop_type=CropType.NO, tfm_y=TfmType.NO,
aug_tfms=aug_tfms)
ds = ImageData.get_ds(HCDDataset,(tr_n[:-(len(tr_n)% bs)], TRAIN),
(val_n, TRAIN), tfms, test=(test_names, TEST))
md = Im... | sub = pd.DataFrame({'image_id': image_ids_list, 'label': probs});sub.head() | Cassava Leaf Disease Classification |
14,259,667 | md = get_data(96, BATCH_SIZE)
learn = ConvLearner.pretrained(arch, md)
learn.opt_fn = optim.Adam<train_model> | sub.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,259,667 | <predict_on_test><EOS> | sub.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,313,153 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<save_to_csv> | package_path = '.. /input/vision-transformer-pytorch/VisionTransformer-Pytorch'
sys.path.append(package_path)
| Cassava Leaf Disease Classification |
14,313,153 | sample_df = pd.read_csv(SAMPLE_SUB)
sample_list = list(sample_df.id)
pred_list = [p for p in preds_t]
pred_dic = dict(( key, value)for(key, value)in zip(learn.data.test_ds.fnames,pred_list))
pred_list_cor = [pred_dic[id] for id in sample_list]
df = pd.DataFrame({'id':sample_list,'label':pred_list_cor})
df.to_csv('su... | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
sys.path.append(package_path ) | Cassava Leaf Disease Classification |
14,313,153 | %matplotlib inline
<categorify> | 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... | Cassava Leaf Disease Classification |
14,313,153 | class CancerDataset(Dataset):
def __init__(self, datafolder, datatype='train', transform = transforms.Compose([transforms.ToTensor() ]), labels_dict={}):
self.datafolder = datafolder
self.datatype = datatype
self.image_files_list = [s for s in os.listdir(datafolder)]
self.transform = transform
self.labels_dict = labels... | CFG = {
'fold_num': 10,
'seed': 719,
'model_arch': 'tf_efficientnet_b3_ns',
'img_size': 384,
'epochs': 100,
'train_bs': 28,
'valid_bs': 32,
'lr': 1e-2,
'num_workers': 10,
'accum_iter': 1,
'verbose_step': 2,
'device': 'cuda:0',
'tta': 10,
'used_epochs': [6,7,8,9],
'weights': [1,1,1,1]
} | Cassava Leaf Disease Classification |
14,313,153 | IMAGE_NOT_FOUND_COUNTER = 0
labels = pd.read_csv('.. /input/train_labels.csv')
data_transforms = transforms.Compose([
transforms.RandomHorizontalFlip() ,
transforms.RandomVerticalFlip() ,
transforms.ToTensor() ,
transforms.Normalize(( 0.5, 0.5, 0.5),(0.5, 0.5, 0.5))
])
data_transforms_test = transforms.Compose([
tran... | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head() | Cassava Leaf Disease Classification |
14,313,153 | class Flatten(nn.Module):
def forward(self, x):
N, C, H, W = x.size()
return x.view(N, -1 )<train_model> | train.label.value_counts() | Cassava Leaf Disease Classification |
14,313,153 | avg_loss_list = []
acc_list = []
def train(model, train_loader ,loss_fn, optimizer, num_epochs = 1):
total_loss =0
for epoch in range(num_epochs):
print('Starting epoch %d / %d' %(epoch + 1, num_epochs))
model.train()
for t,(x, y)in enumerate(train_loader):
x_var = Variable(x.type(gpu_dtype))
y_var = Variable(y.type(gp... | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head() | Cassava Leaf Disease Classification |
14,313,153 | print_every = 100
gpu_dtype = torch.cuda.FloatTensor
out_1 = 32
out_2 = 64
out_3 = 128
out_4 = 256
k_size_1 = 3
padding_1 = 1
num_epochs = 10
fixed_model_base = nn.Sequential(
nn.Conv2d(3, out_1, padding= padding_1, kernel_size=k_size_1, stride=1),
nn.ReLU(inplace=True),
nn.BatchNorm2d(out_1),
nn.Conv2d(out_1 , out_1,... | 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... | Cassava Leaf Disease Classification |
14,313,153 | print(avg_loss_list,acc_list )<feature_engineering> | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | Cassava Leaf Disease Classification |
14,313,153 | fixed_model_gpu.eval()
preds = []
for batch_i,(data, target)in enumerate(test_loader):
data, target = data.cuda() , target.cuda()
output = fixed_model_gpu(data)
pr = output[:,1].detach().cpu().numpy()
for i in pr:
preds.append(i)
test_preds = pd.DataFrame({'imgs': test_set.image_files_list, 'preds': preds})
test_pre... | 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... | Cassava Leaf Disease Classification |
14,313,153 | data_to_submit.to_csv('csv_to_submit.csv', index = False )<import_modules> | if __name__ == '__main__':
seed_everything(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(d... | Cassava Leaf Disease Classification |
14,313,153 | Conv2D, SeparableConv1D, Add, BatchNormalization, Activation, GlobalAveragePooling2D, LeakyReLU, Flatten
Lambda, Multiply, LSTM, Bidirectional, PReLU, MaxPooling1D
print(os.listdir(".. /input"))
<load_from_csv> | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
14,313,153 | <define_variables><EOS> | test.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,260,338 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<define_variables> | tez_path = '.. /input/tez-lib/'
effnet_path = '.. /input/efficientnet-pytorch/'
timm_path = '.. /input/timm-pytorch-image-models/pytorch-image-models-master'
sys.path.append(tez_path)
sys.path.append(effnet_path)
sys.path.append(timm_path ) | Cassava Leaf Disease Classification |
14,260,338 | labeled_files = glob('.. /input/train/*.tif')
test_files = glob('.. /input/test/*.tif' )<split> | import os
import albumentations
import pandas as pd
import numpy as np
import timm
import tez
from tez.datasets import ImageDataset
import torch
import torch.nn as nn
from torch.nn import functional as F
from tqdm import tqdm
from efficientnet_pytorch import EfficientNet | Cassava Leaf Disease Classification |
14,260,338 | train, val = train_test_split(labeled_files, test_size=0.1, random_state=101010 )<choose_model_class> | class EfficientnetModel(tez.Model):
def __init__(self, num_classes):
super().__init__()
self.effnet = EfficientNet.from_name("efficientnet-b4")
self.dropout = nn.Dropout(0.1)
self.out = nn.Linear(1792, num_classes)
self.step_scheduler_after = "epoch"
def forward(self, image, targets=None):
batch_size, _, _, _ = imag... | Cassava Leaf Disease Classification |
14,260,338 | def get_model_classif_mobilenetv2() :
inputs = Input(( 96, 96, 3))
base_model = DenseNet169(include_top=False, input_shape=(96, 96, 3))
x = base_model(inputs)
out1 = GlobalMaxPooling2D()(x)
out2 = GlobalAveragePooling2D()(x)
out3 = Flatten()(x)
out = Concatenate(axis=-1 )([out1, out2, out3])
out = Dropout(0.5 )(ou... | class CustomResNext(tez.Model):
def __init__(self, num_classes, model_name='resnext50_32x4d', pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=pretrained)
n_features = self.model.fc.in_features
self.out = nn.Linear(n_features, num_classes)
self.step_scheduler_after = "epoch"... | Cassava Leaf Disease Classification |
14,260,338 | model = get_model_classif_mobilenetv2()<train_model> | img_size = 512
test_aug = albumentations.Compose([
albumentations.RandomResizedCrop(img_size, img_size),
albumentations.Transpose(p=0.5),
albumentations.HorizontalFlip(p=0.5),
albumentations.VerticalFlip(p=0.5),
albumentations.HueSaturationValue(
hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2,
p=0.5
),... | Cassava Leaf Disease Classification |
14,260,338 | batch_size=32
h5_path = "model.h5"
checkpoint = ModelCheckpoint(h5_path, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
history = model.fit_generator(
data_gen(train, id_label_map, batch_size, augment=True),
validation_data=data_gen(val, id_label_map, batch_size),
epochs=2, verbose=1,
callbacks=[check... | dfx = pd.read_csv(".. /input/cassava-leaf-disease-classification/sample_submission.csv")
image_path = ".. /input/cassava-leaf-disease-classification/test_images/"
test_image_paths = [os.path.join(image_path, x)for x in dfx.image_id.values]
test_targets = dfx.label.values
test_dataset = ImageDataset(
image_paths=test_... | Cassava Leaf Disease Classification |
14,260,338 | preds = []
ids = []<predict_on_test> | train_dfx = pd.read_csv(".. /input/cassava-leaf-disease-classification/train.csv")
model_path = ".. /input/cassava-model-3"
model0 = EfficientnetModel(num_classes=train_dfx.label.nunique())
model0.load(f"{model_path}/efficentnet_model_fold0.bin", device='cuda')
model1 = EfficientnetModel(num_classes=train_dfx.label.... | Cassava Leaf Disease Classification |
14,260,338 | for batch in chunker(test_files, batch_size):
X = [preprocess_input(cv2.imread(x)) for x in batch]
ids_batch = [get_id_from_file_path(x)for x in batch]
X = np.array(X)
preds_batch =(( model.predict(X ).ravel() *model.predict(X[:, ::-1, :, :] ).ravel() *model.predict(X[:, ::-1, ::-1, :] ).ravel() *model.predict(X[:, :,... | model_list = [model0, model1, model2, model3, model4, model5, model6, model7, model8, model9]
def run_inference(model):
final_preds = None
for j in range(7):
preds = model.predict(test_dataset, batch_size=64, n_jobs=-1)
temp_preds = None
for p in preds:
if temp_preds is None:
temp_preds = p
else:
temp_preds = np.vstac... | Cassava Leaf Disease Classification |
14,260,338 | df = pd.DataFrame({'id':ids, 'label':preds})
df.to_csv("baseline_nasnet.csv", index=False)
df.head()<set_options> | new_df = pd.DataFrame()
new_df['model0'], new_df['model0_prob'] = run_inference(model_list[0])
new_df['model1'], new_df['model1_prob'] = run_inference(model_list[1])
new_df['model2'], new_df['model2_prob'] = run_inference(model_list[2])
new_df['model3'], new_df['model3_prob'] = run_inference(model_list[3])
new_df['... | Cassava Leaf Disease Classification |
14,260,338 | %matplotlib inline
<import_modules> | def most_common(lst):
data = Counter(lst)
return max(lst, key=data.get)
final_preds = list()
for index, row in new_df.iterrows() :
out_list = [row['model0'], row['model1'], row['model2'], row['model3'], row['model4'],row['model5'], row['model6'], row['model7'], row['model8'], row['model9'] ]
final_preds.append(most_c... | Cassava Leaf Disease Classification |
14,260,338 | tf.__version__<load_from_csv> | Cassava Leaf Disease Classification | |
14,260,338 | train = pd.read_csv('.. /input/digit-recognizer/train.csv')
test = pd.read_csv('.. /input/digit-recognizer/test.csv')
sub = pd.read_csv('.. /input/digit-recognizer/sample_submission.csv' )<prepare_x_and_y> | Cassava Leaf Disease Classification | |
14,260,338 | <split><EOS> | dfx.label = final_preds
dfx.to_csv("submission.csv", index=False ) | Cassava Leaf Disease Classification |
14,216,398 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<data_type_conversions> | BATCH_SIZE = 1
image_size = 512
enet_type = ['tf_efficientnet_b4_ns'] * 5
model_path = ['.. /input/cassava-models-eff/baseline_cld_fold0_epoch8_tf_efficientnet_b4_ns_512.pth',
'.. /input/cassava-models-eff/baseline_cld_fold1_epoch9_tf_efficientnet_b4_ns_512.pth',
'.. /input/cassava-models-eff/baseline_cld_fold2_epoch9_... | Cassava Leaf Disease Classification |
14,216,398 | train_X = train_X.reshape(-1, 28, 28, 1 ).astype("float32")/255.0
val_X = val_X.reshape(-1, 28, 28, 1 ).astype("float32")/255.0
test = test.values.reshape(-1, 28, 28, 1 ).astype("float32")/255.0
train_y = tf.keras.utils.to_categorical(train_y)
val_y = tf.keras.utils.to_categorical(val_y )<load_from_zip> | transforms_valid = albumentations.Compose([
albumentations.CenterCrop(image_size, image_size, p=1),
albumentations.Resize(image_size, image_size),
albumentations.Normalize()
] ) | Cassava Leaf Disease Classification |
14,216,398 | ! git clone https://github.com/bckenstler/CLR.git<choose_model_class> | OUTPUT_DIR = './'
MODEL_DIR = '.. /input/cassava-models-res/'
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
TRAIN_PATH = '.. /input/cassava-leaf-disease-classification/train_images'
TEST_PATH = '.. /input/cassava-leaf-disease-classification/test_images' | Cassava Leaf Disease Classification |
14,216,398 | clr_triangular = CyclicLR(mode='triangular' )<choose_model_class> | class CFG:
debug=False
num_workers=8
model_name='resnext50_32x4d'
size=512
batch_size=32
seed=2020
target_size=5
target_col='label'
n_fold=5
trn_fold=[0, 1, 2, 3, 4]
inference=True | Cassava Leaf Disease Classification |
14,216,398 | class myCallback(tf.keras.callbacks.Callback):
def on_epoch_end(self, epoch, logs={}):
if(logs.get('accuracy')>0.9999):
print("
Reached 99.99% accuracy so cancelling training!")
self.model.stop_training = True
callbacks = myCallback()
learning_rate_reduction = tf.keras.callbacks.ReduceLROnPlateau(monitor = 'val_loss',... | test = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
test['filepath'] = test.image_id.apply(lambda x: os.path.join('.. /input/cassava-leaf-disease-classification/test_images', f'{x}'))
| Cassava Leaf Disease Classification |
14,216,398 | IMG_SIZE = 28
BATCH_SIZE = 64
AUTOTUNE = tf.data.experimental.AUTOTUNE
num_classes = 10
def augment(image_label, seed):
image, label = image_label
image = tf.image.resize_with_crop_or_pad(
image,
IMG_SIZE + 6,
IMG_SIZE + 6
)
new_seed = tf.random.experimental.stateless_split(seed, num=1)[0,:]
image = tf.image.statele... | test_dataset_efficient = CLDDataset(test, 'test', transform=transforms_valid)
test_loader_efficient = torch.utils.data.DataLoader(test_dataset_efficient, batch_size=BATCH_SIZE, shuffle=False, num_workers=4 ) | Cassava Leaf Disease Classification |
14,216,398 | startTime = timeit.default_timer()
history = cnn_model.fit(
train_ds,
steps_per_epoch = train_X.shape[0] // BATCH_SIZE,
epochs = 50,
validation_data = val_ds,
validation_steps = val_X.shape[0] // BATCH_SIZE,
callbacks = [callbacks, learning_rate_reduction]
)
elapsedTime = timeit.default_timer() - startTime
print("Ti... | def get_transforms(*, data):
if data == 'valid':
return A.Compose([
A.Resize(CFG.size, CFG.size),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2() ,
] ) | Cassava Leaf Disease Classification |
14,216,398 | startTime = timeit.default_timer()
history = cnn_model.fit(
train_ds,
steps_per_epoch = train_X.shape[0] // BATCH_SIZE,
epochs = 50,
validation_data = val_ds,
validation_steps = val_X.shape[0] // BATCH_SIZE,
callbacks = [clr_triangular]
)
elapsedTime = timeit.default_timer() - startTime
print("Time taken for the Net... | class CustomResNext(nn.Module):
def __init__(self, model_name='resnext50_32x4d', pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=pretrained)
n_features = self.model.fc.in_features
self.model.fc = nn.Linear(n_features, CFG.target_size)
def forward(self, x):
x = self.model(x)... | Cassava Leaf Disease Classification |
14,216,398 | prediction = cnn_model.predict(test ).argmax(axis=1)
sub['Label'] = prediction
sub.to_csv("MNIST_sub_cnn1.csv", index=False)
sub.head()<set_options> | class enet_v2(nn.Module):
def __init__(self, backbone, out_dim, pretrained=False):
super(enet_v2, self ).__init__()
self.enet = timm.create_model(backbone, pretrained=pretrained)
in_ch = self.enet.classifier.in_features
self.myfc = nn.Linear(in_ch, out_dim)
self.enet.classifier = nn.Identity()
def forward(self, x):
x... | Cassava Leaf Disease Classification |
14,216,398 | np.random.seed(42)
torch.random.seed = 42<load_from_csv> | def load_state(model_path):
model = CustomResNext(CFG.model_name, pretrained=False)
try:
model.load_state_dict(torch.load(model_path)['model'], strict=True)
state_dict = torch.load(model_path)['model']
except:
state_dict = torch.load(model_path)['model']
state_dict = {k[7:] if k.startswith('module.')else k: state_dic... | Cassava Leaf Disease Classification |
14,216,398 | <data_type_conversions><EOS> | model = CustomResNext(CFG.model_name, pretrained=False)
states = [load_state(MODEL_DIR+f'{CFG.model_name}_fold{fold}.pth')for fold in CFG.trn_fold]
test_dataset = TestDataset(test, transform=get_transforms(data='valid'))
test_loader = DataLoader(test_dataset, batch_size=CFG.batch_size, shuffle=False,
num_workers=CFG.n... | Cassava Leaf Disease Classification |
14,049,836 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<categorify> | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
| Cassava Leaf Disease Classification |
14,049,836 | @Transform
def get_label(a):
return a[0]
@Transform
def get_x(a):
return a[-28*28:]
@Transform
def nums_to_tensor(a):
return TensorImageBW(torch.from_numpy(a ).view(1,28,28))
<prepare_x_and_y> | 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... | Cassava Leaf Disease Classification |
14,049,836 | x_tfms = [get_x,nums_to_tensor, ]
y_tfms = [get_label, Categorize]
cut = int(len(train)*0.8)
splits = [list(range(cut)) , list(range(cut,len(train)-1)) ]
bs = 128<create_dataframe> | CFG = {
'fold_num': 5,
'seed': 719,
'model_arch': 'tf_efficientnet_b4_ns',
'img_size': 512,
'use_benchmark': False,
'use_deterministic': False,
'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,8],
'weights': [... | Cassava Leaf Disease Classification |
14,049,836 | dsets = Datasets(train,[x_tfms, y_tfms], splits = splits)
dls = dsets.dataloaders(bs=bs, after_batch=[IntToFloatTensor() ,*aug_transforms(do_flip=False,batch=True,), Normalize.from_stats(*mnist_stats)] )<compute_test_metric> | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head() | Cassava Leaf Disease Classification |
14,049,836 | test_dl =dls.test_dl(test )<choose_model_class> | train.label.value_counts() | Cassava Leaf Disease Classification |
14,049,836 | model = xresnet18(c_in=1,n_out=10, sa=True, act_cls=Mish )<choose_model_class> | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head() | Cassava Leaf Disease Classification |
14,049,836 | learn = Learner(dls,model, loss_func=CrossEntropyLossFlat() , metrics=accuracy, )<find_best_params> | if CFG['use_benchmark']:
torch.backends.cudnn.benchmark = True
if CFG['use_deterministic']:
torch.backends.cudnn.deterministic = True | Cassava Leaf Disease Classification |
14,049,836 | lr_min, lr_steep = learn.lr_find() ;lr_min, lr_steep<train_model> | 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... | Cassava Leaf Disease Classification |
14,049,836 | learn.fit_one_cycle(20,lr_min )<save_model> | HorizontalFlip, VerticalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine, RandomResizedCrop,
IAASharpen, IAAEmboss, RandomBrightnessCon... | Cassava Leaf Disease Classification |
14,049,836 | learn.save('20epoch_Xresnet18-sa' )<load_pretrained> | class ContrastiveLoss(nn.Module):
def __init__(self, margin=0.3, **kwargs):
super(ContrastiveLoss, self ).__init__()
self.margin = margin
def forward(self, inputs, targets):
n = inputs.size(0)
sim_mat = torch.matmul(inputs, inputs.t())
targets = targets
loss = list()
c = 0
for i in range(n):
pos_pair_ = torch.masked_... | Cassava Leaf Disease Classification |
14,049,836 | learn = learn.load('20epoch_Xresnet18-sa' )<train_model> | class CassvaImgClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
backbone = timm.create_model(model_arch, pretrained=pretrained)
n_features = backbone.classifier.in_features
self.backbone = nn.Sequential(*backbone.children())[:-1]
if CFG['classifier_type'] == "arcfa... | Cassava Leaf Disease Classification |
14,049,836 | learn.fit_one_cycle(2,lr_min/50 )<save_model> | if __name__ == '__main__':
seed_everything(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):
print('Inference fold {} started'.format(fold))
valid_ = train.loc[val_idx,:].reset_index(drop=True)
valid_ds... | Cassava Leaf Disease Classification |
14,049,836 | learn.save('20+2epoch_Xresnet18-sa' )<compute_test_metric> | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
14,049,836 | <feature_engineering><EOS> | test.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
13,039,151 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<prepare_output> | OUTPUT_DIR = './'
MODEL_DIR = '.. /input/resnextv2/'
TRAIN_PATH = '.. /input/cassava-leaf-disease-classification/train_images'
TEST_PATH = '.. /input/cassava-leaf-disease-classification/test_images' | Cassava Leaf Disease Classification |
13,039,151 | class_preds =np.argmax(preds,axis=1)
pred_submission = [dls.vocab[i] for i in class_preds]<save_to_csv> | class CFG:
debug=False
num_workers=4
model_name='resnext50_32x4d'
size=512
batch_size=32
seed=42
target_size=5
target_col='label'
n_fold=5
trn_fold=[0, 1, 2, 3, 4]
train=False
inference=True | Cassava Leaf Disease Classification |
13,039,151 | submission = pd.read_csv(dirname+'/sample_submission.csv')
submission['Label']=pred_submission
submission.to_csv('submission.csv',index=False )<set_options> | 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... | Cassava Leaf Disease Classification |
13,039,151 | %matplotlib inline
<train_model> | class CustomResNext(nn.Module):
def __init__(self, model_name='resnext50_32x4d', pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=pretrained)
n_features = self.model.fc.in_features
self.model.fc = nn.Linear(n_features, CFG.target_size)
def forward(self, x):
x = self.model(x)... | Cassava Leaf Disease Classification |
13,039,151 | train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('Training on CPU...')
else:
print('Training on GPU...')
<set_options> | def inference(model, states, test_loader, device):
model.to(device)
tk0 = tqdm(enumerate(test_loader), total=len(test_loader))
probs = []
for i,(images)in tk0:
images = images.to(device)
avg_preds = []
for state in states:
model.load_state_dict(state['model'])
model.eval()
with torch.no_grad() :
y_preds = model(imag... | Cassava Leaf Disease Classification |
13,039,151 | device = torch.device('cuda:0' )<load_from_csv> | test = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
test.head() | Cassava Leaf Disease Classification |
13,039,151 | <count_missing_values><EOS> | model = CustomResNext(CFG.model_name, pretrained=False)
states = [torch.load(MODEL_DIR+f'{CFG.model_name}_fold{fold}_best.pth')for fold in CFG.trn_fold]
test_dataset = TestDataset(test, transform=get_transforms(data='valid'))
test_loader = DataLoader(test_dataset, batch_size=CFG.batch_size, shuffle=False,
num_workers=... | Cassava Leaf Disease Classification |
13,011,840 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<drop_column> | print("Tensorflow version " + tf.__version__ ) | Cassava Leaf Disease Classification |
13,011,840 | train_data = df_train.drop('label',axis=1 ).values<feature_engineering> | AUTOTUNE = tf.data.experimental.AUTOTUNE
GCS_PATH = ".. /input/cassava-leaf-disease-classification"
GCS_PATH_STRATIFICATED =".. /input/cassava-recreate-stratificated-tfrecords"
REPLICAS = strategy.num_replicas_in_sync
BATCH_SIZE = 32
AUG_BATCH = BATCH_SIZE
IMAGE_SIZE = [512, 512]
DIM = IMAGE_SIZE[0]
CLASSES = ['0', '1'... | Cassava Leaf Disease Classification |
13,011,840 | train_data = train_data/255.0
df_test = df_test/255.0<train_model> | test_df = pd.read_csv(GCS_PATH + '/sample_submission.csv')
train_df = pd.read_csv(GCS_PATH + '/train.csv' ) | Cassava Leaf Disease Classification |
13,011,840 | mask = np.random.rand(len(df_train)) < 0.8
df_val = df_train[~mask]
df_train = df_train[mask]
print('Train size: ', df_train.shape)
print('Val size: ', df_val.shape)
print('Test size: ', df_test.shape)
df_train.head()<categorify> | files_test = np.sort(np.array(tf.io.gfile.glob(GCS_PATH + '/test_tfrecords/*.tfrec')) ) | Cassava Leaf Disease Classification |
13,011,840 | class DatasetMNIST(torch.utils.data.Dataset):
def __init__(self, data, transform=None):
self.data = data
self.transform = transform
def __len__(self):
return len(self.data)
def __getitem__(self, index):
item = self.data.iloc[index]
image = item[1:].values.astype(np.uint8 ).reshape(( 28, 28))
label = item[0]
if self.tr... | ROT_ = 180.0
SHR_ = 2.0
HZOOM_ = 8.0
WZOOM_ = 8.0
HSHIFT_ = 8.0
WSHIFT_ = 8.0 | Cassava Leaf Disease Classification |
13,011,840 | train_transform = transforms.Compose(
[
transforms.ToPILImage() ,
transforms.ToTensor() ,
transforms.Normalize(mean=train_data.mean() , std=train_data.std()),
])
val_transform = transforms.Compose(
[
transforms.ToPILImage() ,
transforms.ToTensor() ,
transforms.Normalize(mean=train_data.mean() , std=train_data.std())... | def get_mat(rotation, shear, height_zoom, width_zoom, height_shift, width_shift):
rotation = math.pi * rotation / 180.
shear = math.pi * shear / 180.
def get_3x3_mat(lst):
return tf.reshape(tf.concat([lst],axis=0), [3,3])
c1 = tf.math.cos(rotation)
s1 = tf.math.sin(rotation)
one = tf.constant([1],dtype='float32')
... | Cassava Leaf Disease Classification |
13,011,840 | train_dataset = DatasetMNIST(df_train, transform = train_transform)
validation_dataset = DatasetMNIST(df_val, transform = val_transform)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=16)
validation_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=16)
<choose_... | def to_float32(image, label):
return tf.cast(image, tf.float32), label | Cassava Leaf Disease Classification |
13,011,840 | class CNN(nn.Module):
def __init__(self):
super(CNN,self ).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(1, 32, 3, padding=1),
nn.ReLU() ,
nn.BatchNorm2d(32),
nn.Conv2d(32, 32, 3, stride=2, padding=1),
nn.ReLU() ,
nn.BatchNorm2d(32),
nn.MaxPool2d(2, 2),
nn.Dropout(0.25)
)
self.conv2 = nn.Sequential(
nn.Conv2d(32,... | def decode_image(image):
image = tf.image.decode_jpeg(image, channels=3)
image = tf.cast(image, tf.float32)/ 255.0
image = tf.reshape(image, [*IMAGE_SIZE, 3])
return image | Cassava Leaf Disease Classification |
13,011,840 | LEARNING_RATE = 0.001680
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters() , lr=LEARNING_RATE )<train_model> | def read_labeled_tfrecord(example):
tfrec_format = {
'image' : tf.io.FixedLenFeature([], tf.string),
'target' : tf.io.FixedLenFeature([], tf.int64)
}
example = tf.io.parse_single_example(example, tfrec_format)
return example['image'], example['target'] | Cassava Leaf Disease Classification |
13,011,840 | def train_model(model,train_loader, validation_loader, optimizer, n_epochs=100):
N_test=len(validation_dataset)
accuracy_list=[]
loss_list=[]
for epoch in range(n_epochs):
for x, y in train_loader:
x, y = x.to(device), y.to(device)
model.train()
optimizer.zero_grad()
z = model(x)
loss = criterion(z, y)
loss.backwar... | def read_tfrecord(example, labeled):
tfrecord_format = {
"image": tf.io.FixedLenFeature([], tf.string),
"target": tf.io.FixedLenFeature([], tf.int64)
} if labeled else {
"image": tf.io.FixedLenFeature([], tf.string),
"image_name": tf.io.FixedLenFeature([], tf.string)
}
example = tf.io.parse_single_example(example, tf... | Cassava Leaf Disease Classification |
13,011,840 | accuracy_list, loss_list=train_model(model=model,n_epochs=100,train_loader=train_loader,validation_loader=validation_loader,optimizer=optimizer )<compute_test_metric> | def read_unlabeled_tfrecord(example, return_image_name):
tfrec_format = {
'image' : tf.io.FixedLenFeature([], tf.string),
'image_name' : tf.io.FixedLenFeature([], tf.string),
}
example = tf.io.parse_single_example(example, tfrec_format)
return example['image'], example['image_name'] if return_image_name else '0' | Cassava Leaf Disease Classification |
13,011,840 | print(accuracy_list, loss_list )<load_pretrained> | def load_dataset(filenames, labeled=True, ordered=False):
ignore_order = tf.data.Options()
if not ordered:
ignore_order.experimental_deterministic = False
dataset = tf.data.TFRecordDataset(filenames, num_parallel_reads=AUTOTUNE)
dataset = dataset.with_options(ignore_order)
dataset = dataset.map(partial(read_tfrecord,... | Cassava Leaf Disease Classification |
13,011,840 | test_dataset = DatasetMNIST(df_test, transform = val_transform)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=16 )<categorify> | TRAINING_FILENAMES = tf.io.gfile.glob('.. /input/cassava-leaf-disease-classification/train_tfrecords/' + '*train*.tfrec')
TEST_FILENAMES = tf.io.gfile.glob('.. /input/cassava-leaf-disease-classification/test_tfrecords/' + 'ld_test*.tfrec' ) | Cassava Leaf Disease Classification |
13,011,840 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
x_test = np.expand_dims(x_test, axis=1)
x_test = torch.from_numpy(x_test ).float().to(device)
x_test.type()<predict_on_test> | def count_data_items(filenames):
n = [int(re.compile(r"-([0-9]*)\." ).search(filename ).group(1)) for filename in filenames]
return np.sum(n)
NUM_TRAINING_IMAGES = int(count_data_items(TRAINING_FILENAMES)*(FOLDS-1.) /FOLDS)
NUM_VALIDATION_IMAGES = int(count_data_items(TRAINING_FILENAMES)*(1./FOLDS))
NUM_TEST_IMAGES =... | Cassava Leaf Disease Classification |
13,011,840 | model.eval()
with torch.no_grad() :
ps = model(x_test)
prediction = torch.argmax(ps, 1)
print('Prediction',prediction )<prepare_output> | def data_augment(image, label):
image = tf.image.random_flip_left_right(image)
return image, label | Cassava Leaf Disease Classification |
13,011,840 | df_export = pd.DataFrame(prediction.cpu().tolist() , columns = ['Label'])
df_export['ImageId'] = df_export.index +1
df_export = df_export[['ImageId', 'Label']]
df_export.head()<save_to_csv> | def get_test_dataset(ordered=False):
dataset = load_dataset(TEST_FILENAMES, labeled=False, ordered=ordered)
dataset = dataset.batch(BATCH_SIZE)
dataset = dataset.prefetch(AUTOTUNE)
return dataset | Cassava Leaf Disease Classification |
13,011,840 | df_export.to_csv('output.csv', index=False )<set_options> | def count_data_items(filenames):
n = [int(re.compile(r"-([0-9]*)\." ).search(filename ).group(1)) for filename in filenames]
return np.sum(n ) | Cassava Leaf Disease Classification |
13,011,840 | %matplotlib inline<load_from_csv> | def onehot(image,label):
CLASSES = 5
return image,tf.one_hot(label,CLASSES ) | Cassava Leaf Disease Classification |
13,011,840 | train = pd.read_csv('/kaggle/input/digit-recognizer/train.csv')
test = pd.read_csv('/kaggle/input/digit-recognizer/test.csv' )<define_variables> | def get_validation_dataset(dataset, do_onehot=True):
dataset = dataset.batch(BATCH_SIZE)
if do_onehot: dataset = dataset.map(onehot, num_parallel_calls=AUTOTUNE)
dataset = dataset.cache()
dataset = dataset.prefetch(AUTOTUNE)
return dataset | Cassava Leaf Disease Classification |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.