kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
15,025,111 | structures = pd.read_csv(".. /input/champs-scalar-coupling/structures.csv")
structures_df = structures.merge(structures, how='left', on= ['molecule_name'], suffixes =('_0', '_1'))
del structures
gc.collect()
structures_df['distance'] =(
(structures_df['x_0'] - structures_df['x_1'] ).pow(2)+(structures_df['y_0'] - stru... | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
sys.path.append(package_path)
| Cassava Leaf Disease Classification |
15,025,111 | for atom in ['O', 'F']:
rank_col = '{0}_rank'.format(atom)
structures_df.loc[structures_df.atom_1 == atom, rank_col] = structures_df[structures_df.atom_1 == atom].groupby(
['molecule_name', 'atom_index_0'])['distance'].rank(method='first')
atom_distance_ranks = structures_df[structures_df[rank_col] <= 2][['molecule_... | 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.... | Cassava Leaf Disease Classification |
15,025,111 | grps = [['molecule_name', 'atom_index_0'], ['molecule_name', 'atom_index_1']]
grp_columns = ['distance']
gc.collect()
for grp in grps:
for column in grp_columns:
stats = all_data.groupby(grp ).agg(
{column: ["mean", "min", "std", "max"]}
)
stats.columns = ['_'.join(col)for col in stats.columns]
stats.columns = ['_'.... | package_path = '.. /input/visiontransformer-pytorch/VisionTransformer-Pytorch-main'
sys.path.append(package_path)
| Cassava Leaf Disease Classification |
15,025,111 | bond_data = pd.read_csv(".. /input/submolecular-bond-data/structures_bond.csv", usecols = [
'molecule_name', 'atom_index', 'n_bonds', 'bond_lengths_mean', 'bond_lengths_std'])
all_data = all_data.merge(bond_data, left_on=['molecule_name', 'atom_index_0'],
right_on=['molecule_name', 'atom_index'], how='left')\
all_data... | class EnsembleClassifier(nn.Module):
def __init__(self, model_arch, n_class, pretrained=False):
super().__init__()
self.model1 = VisionTransformer.from_name('ViT-B_16', num_classes=5)
self.model1.load_state_dict(torch.load('.. /input/vit-model-1/ViT-B_16.pt'))
self.model2 = CassavaImgClassifier(model_arch, n_class, ... | Cassava Leaf Disease Classification |
15,025,111 | atomic_radius = {'H':0.38, 'C':0.77, 'N':0.75, 'O':0.73, 'F':0.71}
fudge_factor = 0.05
atomic_radius = {k:v + fudge_factor for k,v in atomic_radius.items() }
print(atomic_radius)
electronegativity = {'H':2.2, 'C':2.55, 'N':3.04, 'O':3.44, 'F':3.98}
for idx in [0,1]:
atom = 'atom_{0}'.format(idx)
atoms = all_data[atom... | 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... | Cassava Leaf Disease Classification |
15,025,111 | all_data['dot_product'] = all_data['x_0']*all_data['x_1'] + all_data['y_0']*all_data['y_1'] + all_data['z_0']*all_data['z_1']
all_data['norm_atom_0'] = all_data['x_0'].pow(2)+ all_data['y_0'].pow(2)+ all_data['z_0'].pow(2)
all_data['norm_atom_1'] = all_data['x_1'].pow(2)+ all_data['y_1'].pow(2)+ all_data['z_1'].pow(2)... | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
15,025,111 | <merge><EOS> | test.to_csv('submission.csv', index = False ) | Cassava Leaf Disease Classification |
14,983,204 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<feature_engineering> | 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 ) | Cassava Leaf Disease Classification |
14,983,204 | for col in all_data_index.columns:
if col not in all_data.columns:
all_data[col] = all_data_index[col]<set_options> | 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,983,204 | del all_data_index
gc.collect()<categorify> | 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... | Cassava Leaf Disease Classification |
14,983,204 | types = all_data.dtypes
cat_columns = [t[0] for t in types.iteritems() if(( t[1] not in ['int64', 'float64'])) ]
print('Label encoding categorical columns:', cat_columns)
encoders = {}
for col in cat_columns:
lbl = preprocessing.LabelEncoder()
all_data[col] = lbl.fit_transform(all_data[col].astype(str))
encoders[col] ... | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head() | Cassava Leaf Disease Classification |
14,983,204 | def group_mean_log_mae(y_true, y_pred, groups, floor=1e-9):
maes =(y_true-y_pred ).abs().groupby(groups ).mean()
print(( y_true-y_pred ).abs().groupby(groups))
return np.log(maes.map(lambda x: max(x, floor)) ).mean()<split> | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head() | Cassava Leaf Disease Classification |
14,983,204 | features = [col for col in all_data.columns if col != 'fc' and col != 'id' and col not in ['atom_index_0', 'atom_index_1', 'scalar_coupling_constant', 'molecule_name']]
def lgbm_model_oof(train_X, train_y, test_X, n_folds, lgbm_params):
folds = KFold(n_splits=n_folds, shuffle=False, random_state=7557)
oof = np.zeros(l... | 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... | Cassava Leaf Disease Classification |
14,983,204 | params_dict = {}
params_dict['1JHC'] = param = {
'num_leaves': 150,
'objective': 'huber',
'colsample_bytree': 0.5,
'subsample': 0.9,
'eta': 0.05,
'n_estimators': 20000,
'metric': 'mae'
}
params_dict['2JHC'] = param = {
'num_leaves': 200,
'objective': 'huber',
'colsample_bytree': 0.5,
'subsample': 0.9,
'eta': 0.05,
'n_e... | 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... | Cassava Leaf Disease Classification |
14,983,204 | predictions_type = np.zeros(len(test_df))
feature_importance_dfs = {}
oof_type = np.zeros(train_size)
for typ in all_data.type.unique() :
gc.collect()
print('Predicting type:', typ)
print(encoders['type'].classes_[typ])
if encoders['type'].classes_[typ] in params_dict.keys() :
param = params_dict[encoders['type'].cl... | 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,983,204 | types = encoders['type'].inverse_transform(all_data[:train_size]['type'])
maes =(target-oof_type ).abs().groupby(types ).mean()
floor=1e-9
print('Log of Mean absolute errors on VAL:')
print(np.log(maes.map(lambda x: max(x, floor))))
print('')
print('Overal Log Mae:')
print(np.log(maes.map(lambda x: max(x, floor)) )... | 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)
... | Cassava Leaf Disease Classification |
14,983,204 | test_df['scalar_coupling_constant'] = predictions_type
test_df[['id', 'scalar_coupling_constant']].to_csv('submission.csv', index=False )<save_to_csv> | 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... | Cassava Leaf Disease Classification |
14,983,204 | sub1['scalar_coupling_constant'] = 0.25*sub1['scalar_coupling_constant'] + 0.2*sub2['scalar_coupling_constant'] + 0.3*sub3['scalar_coupling_constant'] + 0.25*sub4['scalar_coupling_constant']
sub1.to_csv('submission.csv', index=False )<import_modules> | 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)... | Cassava Leaf Disease Classification |
14,983,204 | import shutil
from allennlp.common.params import Params
from allennlp.common.util import prepare_environment, dump_metrics
from allennlp.data.iterators import BasicIterator, BucketIterator
from allennlp.data.token_indexers import SingleIdTokenIndexer
from allennlp.data.token_indexers import PretrainedBertIndexer
from a... | 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.... | Cassava Leaf Disease Classification |
14,983,204 | class RAdam(Optimizer):
def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0):
defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)
self.buffer = [[None, None, None] for ind in range(10)]
super(RAdam, self ).__init__(params, defaults)
def __setstate__(self, state):
super... | 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... | Cassava Leaf Disease Classification |
14,983,204 | class Lookahead(Optimizer):
def __init__(self, base_optimizer,alpha=0.5, k=6):
if not 0.0 <= alpha <= 1.0:
raise ValueError(f'Invalid slow update rate: {alpha}')
if not 1 <= k:
raise ValueError(f'Invalid lookahead steps: {k}')
self.optimizer = base_optimizer
self.param_groups = self.optimizer.param_groups
self.alpha ... | 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... | Cassava Leaf Disease Classification |
14,983,204 | reader = ToxicCommentClassificationReader(token_indexers={
"tokens1": SingleIdTokenIndexer() ,
"tokens2": SingleIdTokenIndexer() ,
})
all_dataset = reader.read('.. /input/jigsaw-toxic-comment-classification-challenge/train.csv')
train_dataset, validation_dataset = train_test_split(all_dataset, test_size=0.2, random_s... | test['label'] = np.argmax(np.mean(sub, axis=0), axis=1)
test.head() | Cassava Leaf Disease Classification |
14,983,204 | glove_params = Params({
'pretrained_file': '.. /input/glove-stanford/glove.twitter.27B.200d.txt',
'embedding_dim': 200,
'trainable': False
})
fasttext_params = Params({
'pretrained_file': '.. /input/fatsttext-common-crawl/crawl-300d-2M/crawl-300d-2M.vec',
'embedding_dim': 300,
'trainable': False
})
glove_embedding = ... | test.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,973,010 | model = ToxicBaseClassifier(
text_field_embedder=word_embeddings,
seq2seq_encoder=None,
seq2vec_encoder=seq2vec_encoder,
dropout=0.5,
num_labels=6,
vocab=vocab
)
model.cuda()
trainer = Trainer(
model=model,
optimizer=Lookahead(RAdam(model.parameters())) ,
iterator=iterator,
train_dataset=train_dataset,
validation_d... | CONFIG_NAME = 'stacking12.yml'
debug = False
STAGE2_DIR = '.. /input/train-stacking-2dcnn-ver3/output' | Cassava Leaf Disease Classification |
14,973,010 | print('metrics: {}'.format(metrics))
print('best_validation_loss: {}'.format(metrics['best_validation_loss']))<categorify> | 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' | Cassava Leaf Disease Classification |
14,973,010 | seq2vec_encoder = SWEMEncoder(embedding_dim=word_embeddings.get_output_dim() )<choose_model_class> | Cassava Leaf Disease Classification | |
14,973,010 | model = ToxicBaseClassifier(
text_field_embedder=word_embeddings,
seq2seq_encoder=None,
seq2vec_encoder=seq2vec_encoder,
dropout=0.5,
num_labels=6,
vocab=vocab
)
model.cuda()
trainer = Trainer(
model=model,
optimizer=Lookahead(RAdam(model.parameters())) ,
iterator=iterator,
train_dataset=train_dataset,
validation_d... | 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
)
... | Cassava Leaf Disease Classification |
14,973,010 | print('metrics: {}'.format(metrics))
print('best_validation_loss: {}'.format(metrics['best_validation_loss']))<categorify> | 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 ) | Cassava Leaf Disease Classification |
14,973,010 | lstm = torch.nn.LSTM(
bidirectional=True,
input_size=word_embeddings.get_output_dim() ,
hidden_size=40,
num_layers=2,
batch_first=True
)
seq2seq_encoder = PytorchSeq2SeqWrapper(lstm)
seq2vec_encoder = SWEMEncoder(embedding_dim=seq2seq_encoder.get_output_dim() )<choose_model_class> | 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 | Cassava Leaf Disease Classification |
14,973,010 | model = ToxicBaseClassifier(
text_field_embedder=word_embeddings,
seq2seq_encoder=seq2seq_encoder,
seq2vec_encoder=seq2vec_encoder,
dropout=0.5,
num_labels=6,
vocab=vocab
)
model.cuda()
trainer = Trainer(
model=model,
optimizer=Lookahead(RAdam(model.parameters())) ,
iterator=iterator,
train_dataset=train_dataset,
v... | 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... | Cassava Leaf Disease Classification |
14,973,010 | print('metrics: {}'.format(metrics))
print('best_validation_loss: {}'.format(metrics['best_validation_loss']))<load_pretrained> | 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 {... | Cassava Leaf Disease Classification |
14,973,010 | BERT_MODEL_PATH = '.. /input/bertpretrained/uncased_l-12_h-768_a-12/uncased_L-12_H-768_A-12/'
WORK_DIR = ".. /working/"
convert_tf_checkpoint_to_pytorch.convert_tf_checkpoint_to_pytorch(
BERT_MODEL_PATH + 'bert_model.ckpt',
BERT_MODEL_PATH + 'bert_config.json',
WORK_DIR + 'pytorch_model.bin'
)
shutil.copyfile(BERT_M... | TRAIN_PATH = '.. /input/cassava-leaf-disease-classification/train_images'
TEST_PATH = '.. /input/cassava-leaf-disease-classification/test_images' | Cassava Leaf Disease Classification |
14,973,010 | token_indexer = PretrainedBertIndexer(
pretrained_model=BERT_MODEL_PATH,
max_pieces=128,
do_lowercase=True,
)
tokenizer = WordTokenizer(word_splitter=BertBasicWordSplitter())
reader = ToxicCommentClassificationReader(
tokenizer=tokenizer,
token_indexers={"bert": token_indexer}
)
all_dataset = reader.read('.. /in... | 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 |
14,973,010 | model.cuda()
trainer = Trainer(model=model,
optimizer=Lookahead(RAdam(model.parameters())) ,
iterator=iterator,
train_dataset=train_dataset,
validation_dataset=validation_dataset,
cuda_device=0,
num_epochs=1000,
grad_norm=5.0,
grad_clipping=1.0,
patience=3)
metrics = trainer.train()<train_model> | 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... | Cassava Leaf Disease Classification |
14,973,010 | print('metrics: {}'.format(metrics))
print('best_validation_loss: {}'.format(metrics['best_validation_loss']))<load_from_csv> | 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... | Cassava Leaf Disease Classification |
14,973,010 | test_dataset = reader.read('.. /input/jigsaw-toxic-comment-classification-challenge/test.csv')
seq_iterator = BasicIterator(batch_size=64)
seq_iterator.index_with(vocab )<save_to_csv> | 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_... | Cassava Leaf Disease Classification |
14,973,010 | predictor = ToxicCommentPredictor(model, seq_iterator, cuda_device=0)
test_preds = predictor.predict(test_dataset)
submission = pd.read_csv('.. /input/jigsaw-toxic-comment-classification-challenge/sample_submission.csv')
submission[["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]] = test_pre... | 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... | Cassava Leaf Disease Classification |
14,973,010 | import sys, os, re, csv, codecs, numpy as np, pandas as pd
import tensorflow as tf
from keras import backend as K
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
from keras.callbacks import Callback
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.se... | 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,... | Cassava Leaf Disease Classification |
14,973,010 | path = '.. /input/'
comp = 'jigsaw-toxic-comment-classification-challenge/'
EMBEDDING_FILE=f'{path}glove840b300dtxt/glove.840B.300d.txt'
TRAIN_DATA_FILE=f'{path}{comp}train.csv'
TEST_DATA_FILE=f'{path}{comp}test.csv'<define_variables> | 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... | Cassava Leaf Disease Classification |
14,973,010 | embed_size = 300
max_features = 150000
maxlen = 150<load_from_csv> | 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... | Cassava Leaf Disease Classification |
14,973,010 | train = pd.read_csv(TRAIN_DATA_FILE)
test = pd.read_csv(TEST_DATA_FILE)
list_sentences_train = train["comment_text"].fillna("_na_" ).values
list_classes = ["toxic", "severe_toxic", "obscene", "threat", "insult", "identity_hate"]
y = train[list_classes].values
list_sentences_test = test["comment_text"].fillna("_na_" )... | 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... | Cassava Leaf Disease Classification |
14,973,010 | tokenizer = Tokenizer(num_words=max_features)
tokenizer.fit_on_texts(list(list_sentences_train))
list_tokenized_train = tokenizer.texts_to_sequences(list_sentences_train)
list_tokenized_test = tokenizer.texts_to_sequences(list_sentences_test)
X_t = pad_sequences(list_tokenized_train, maxlen=maxlen)
X_te = pad_seque... | 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... | Cassava Leaf Disease Classification |
14,973,010 | embeddings_index = {}
with open(EMBEDDING_FILE,encoding='utf8')as f:
for line in f:
values = line.rstrip().rsplit(' ')
word = values[0]
coefs = np.asarray(values[1:], dtype='float32')
embeddings_index[word] = coefs<feature_engineering> | with open('.. /input/train-weights-optimization/best_weights.json', 'r')as f:
weights_dict = json.load(f)
weights_dict | Cassava Leaf Disease Classification |
14,973,010 | word_index = tokenizer.word_index
nb_words = min(max_features, len(word_index))
embedding_matrix = np.zeros(( nb_words, embed_size))
for word, i in word_index.items() :
if i >= max_features: continue
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None: embedding_matrix[i] = embedding_vector<c... | 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]] | Cassava Leaf Disease Classification |
14,973,010 | inp = Input(shape=(maxlen,))
x = Embedding(max_features, embed_size, weights=[embedding_matrix] )(inp)
x = Conv1D(64, kernel_size = 2, padding = "valid", kernel_initializer = "glorot_uniform" )(x)
x = Bidirectional(LSTM(100, return_sequences=True,dropout=0.05,recurrent_dropout=0.05))(x)
avg_pool = GlobalAveragePooli... | BLENDING_WEIGHTS = {
"stacking": 0.5,
"weights_opt": 0.5
} | Cassava Leaf Disease Classification |
14,973,010 | class RocAucEvaluation(Callback):
def __init__(self, validation_data=() , interval=1):
super(Callback, self ).__init__()
self.interval = interval
self.X_val, self.y_val = validation_data
def on_epoch_end(self, epoch, logs={}):
if epoch % self.interval == 0:
y_pred = self.model.predict(self.X_val, verbose=0)
score = ro... | predictions = pred_stacking * BLENDING_WEIGHTS['stacking'] + pred_weights_opt * BLENDING_WEIGHTS['weights_opt']
predictions | Cassava Leaf Disease Classification |
14,973,010 | <train_model><EOS> | test['label'] = predictions.argmax(1)
test[['image_id', 'label']].to_csv(OUTPUT_DIR+'submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,963,568 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<save_to_csv> | 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... | Cassava Leaf Disease Classification |
14,963,568 | y_test = model.predict([X_te], batch_size=1024, verbose=1)
sample_submission = pd.read_csv(f'{path}{comp}sample_submission.csv')
sample_submission[list_classes] = y_test
sample_submission.to_csv('submission.csv', index=False )<load_from_csv> | 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,963,568 | train_data = pd.read_csv('.. /input/train.csv')
test_data = pd.read_csv('.. /input/test.csv' )<count_values> | 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]
} | Cassava Leaf Disease Classification |
14,963,568 | value_counts = train_data.iloc[:,2:].apply(pd.Series.value_counts)
print(value_counts.iloc[1])
<choose_model_class> | 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: ... | Cassava Leaf Disease Classification |
14,963,568 | word_vectorizer = TfidfVectorizer(
sublinear_tf=True,
strip_accents='unicode',
analyzer='word',
token_pattern=r'\w{1,}',
ngram_range=(1, 2),
max_features=30000)
char_vectorizer = TfidfVectorizer(
sublinear_tf=True,
strip_accents='unicode',
analyzer='char',
ngram_range=(1, 4),
max_features=30000)
<concatenate> | train = pd.read_csv(f'{DATA_DIR}/train.csv' ) | Cassava Leaf Disease Classification |
14,963,568 | vectorizer = make_union(word_vectorizer, char_vectorizer, n_jobs=3 )<feature_engineering> | 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... | Cassava Leaf Disease Classification |
14,963,568 | train_comments = train_data['comment_text']
test_comments = test_data['comment_text']
vectorizer.fit(train_comments)
train_features = vectorizer.transform(train_comments)
test_features = vectorizer.transform(test_comments )<compute_train_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__(self, i... | Cassava Leaf Disease Classification |
14,963,568 | scores = []
class_names = ['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']
submission = pd.DataFrame.from_dict({'id': test_data['id']})
for class_name in class_names:
train_target = train_data[class_name]
classifier = LogisticRegression(solver='sag')
cv_score = np.mean(cross_val_score(
class... | 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... | Cassava Leaf Disease Classification |
14,963,568 | from datetime import date, timedelta
import pandas as pd
import numpy as np
from sklearn.metrics import mean_squared_error
import lightgbm as lgb<load_from_csv> | 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... | Cassava Leaf Disease Classification |
14,963,568 | df_train = pd.read_csv(
'.. /input/train.csv', usecols=[1, 2, 3, 4, 5],
dtype={'onpromotion': bool},
converters={'unit_sales': lambda u: np.log1p(
float(u)) if float(u)> 0 else 0},
parse_dates=["date"],
skiprows=range(1, 66458909)
)
df_test = pd.read_csv(
".. /input/test.csv", usecols=[0, 1, 2, 3, 4],
dtype={'onpro... | 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... | Cassava Leaf Disease Classification |
14,963,568 | df_2017 = df_train[df_train.date.isin(
pd.date_range("2017-05-31", periods=7 * 11)) ].copy()
del df_train<concatenate> | 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... | Cassava Leaf Disease Classification |
14,963,568 | promo_2017_train = df_2017.set_index(
["store_nbr", "item_nbr", "date"])[["onpromotion"]].unstack(
level=-1 ).fillna(False)
promo_2017_train.columns = promo_2017_train.columns.get_level_values(1)
promo_2017_test = df_test[["onpromotion"]].unstack(level=-1 ).fillna(False)
promo_2017_test.columns = promo_2017_test.c... | 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... | Cassava Leaf Disease Classification |
14,963,568 | items = items.reindex(df_2017.index.get_level_values(1))
items.head()<feature_engineering> | 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... | Cassava Leaf Disease Classification |
14,963,568 | def get_timespan(df, dt, minus, periods):
return df[
pd.date_range(dt - timedelta(days=minus), periods=periods)
]<create_dataframe> | 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... | Cassava Leaf Disease Classification |
14,963,568 | def prepare_dataset(t2017, is_train=True):
X = pd.DataFrame({
"mean_3_2017": get_timespan(df_2017, t2017, 3, 3 ).mean(axis=1 ).values,
"mean_7_2017": get_timespan(df_2017, t2017, 7, 7 ).mean(axis=1 ).values,
"mean_14_2017": get_timespan(df_2017, t2017, 14, 14 ).mean(axis=1 ).values,
"promo_14_2017": get_timespan(promo_... | 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_... | Cassava Leaf Disease Classification |
14,963,568 | print("Preparing dataset...")
t2017 = date(2017, 6, 21)
X_l, y_l = [], []
for i in range(6):
delta = timedelta(days=7 * i)
X_tmp, y_tmp = prepare_dataset(
t2017 + delta
)
X_l.append(X_tmp)
y_l.append(y_tmp)
X_train = pd.concat(X_l, axis=0)
y_train = np.concatenate(y_l, axis=0)
del X_l, y_l
X_test = prepare_da... | 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... | Cassava Leaf Disease Classification |
14,963,568 | print("Training and predicting models...")
params = {
'num_leaves': 2**5 - 1,
'objective': 'regression_l2',
'max_depth': 8,
'min_data_in_leaf': 50,
'learning_rate': 0.05,
'feature_fraction': 0.75,
'bagging_fraction': 0.75,
'bagging_freq': 1,
'metric': 'l2',
'num_threads': 4
}<define_variables> | tst_preds =(PRED0 + 2*PRED1 + PRED2 + PRED3)/5 | Cassava Leaf Disease Classification |
14,963,568 | MAX_ROUNDS = 1000
val_pred = []
test_pred = []
cate_vars = []
for i in range(16):
print("=" * 50)
print("Step %d" %(i+1))
print("=" * 50)
dtrain = lgb.Dataset(
X_train, label=y_train[:, i],
categorical_feature=cate_vars,
weight=pd.concat([items["perishable"]] * 6)* 0.25 + 1
)
bst = lgb.train(
params, dtrain, num_... | 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 ) | Cassava Leaf Disease Classification |
14,958,372 |
<feature_engineering> | CONFIG_NAME = 'stacking12.yml'
debug = False
STAGE2_DIR = '.. /input/train-stacking-2dcnn-ver3/output' | Cassava Leaf Disease Classification |
14,958,372 | print("Making submission...")
y_test = np.array(test_pred ).transpose()
df_preds = pd.DataFrame(
y_test, index=df_2017.index,
columns=pd.date_range("2017-08-16", periods=16)
).stack().to_frame("unit_sales")
df_preds.index.set_names(["store_nbr", "item_nbr", "date"], inplace=True)
submission = df_test[["id"]].join(... | 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' | Cassava Leaf Disease Classification |
14,958,372 | submission.to_csv('lgb6w.csv', float_format='%.4f', index=None )<import_modules> | Cassava Leaf Disease Classification | |
14,958,372 | ! nvidia-smi<install_modules> | 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
)
... | Cassava Leaf Disease Classification |
14,958,372 | ! pip install torch
! pip install torchvision<import_modules> | 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 ) | Cassava Leaf Disease Classification |
14,958,372 | import pandas as pd
import subprocess
import torch
import torch.optim as optim
from torch import nn
from torch.utils.data import Dataset
from torch.utils.data.sampler import SubsetRandomSampler
import torchvision
from torchvision import transforms
import os
import random
from glob import glob
import cv2
import numpy as... | 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 | Cassava Leaf Disease Classification |
14,958,372 | EPOCH = 100
BATCH_SIZE = 16
PATIENCE = 5
DATA_PATH = '.. /input/state-farm-distracted-driver-detection'
MODEL_NAME = './model.baseline.driver_split.data_aug'<normalization> | 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... | Cassava Leaf Disease Classification |
14,958,372 | transform = transforms.Compose([
transforms.RandomAffine(30, translate=(0.3, 0.3)) ,
transforms.RandomPerspective(p=0.1),
transforms.RandomRotation(degrees=30),
transforms.Resize(( 224, 224)) ,
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])] )<load_from_csv> | 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 {... | Cassava Leaf Disease Classification |
14,958,372 | classes = [f'c{i}' for i in range(10)]
seed = 2020
validation_split = 0.2
driver_list = pd.read_csv(f'{DATA_PATH}/driver_imgs_list.csv')
drivers = np.unique(driver_list['subject'].values)
split = int(np.floor(validation_split * len(drivers)))
np.random.seed(seed)
trn_idx, val_idx = drivers[split:], drivers[:split]<... | TRAIN_PATH = '.. /input/cassava-leaf-disease-classification/train_images'
TEST_PATH = '.. /input/cassava-leaf-disease-classification/test_images' | Cassava Leaf Disease Classification |
14,958,372 | train_dataset = torchvision.datasets.ImageFolder(f'./{split_dir}/train',
transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=2)
valid_transform = transforms.Compose([
transforms.Resize(( 224, 224)) ,
transforms.ToTensor() ,
transforms.Normali... | 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 |
14,958,372 | device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device )<choose_model_class> | 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... | Cassava Leaf Disease Classification |
14,958,372 | model_conv = torchvision.models.resnet50(pretrained=True)
num_ftrs = model_conv.fc.in_features
model_conv.fc = nn.Sequential(
nn.Linear(num_ftrs, num_ftrs),
nn.ReLU() ,
nn.Dropout(0.5),
nn.Linear(num_ftrs, num_ftrs),
nn.ReLU() ,
nn.Dropout(0.5),
nn.Linear(num_ftrs, len(classes)))
print(f'
model_conv = model_conv.to(... | 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... | Cassava Leaf Disease Classification |
14,958,372 | criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model_conv.parameters() , lr=0.0001, weight_decay=1e-6, momentum=0.9)
softmax = nn.Softmax(dim=1)
best_valid_score = 999
patience = 0<train_model> | 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_... | Cassava Leaf Disease Classification |
14,958,372 | def train(model_conv, train_loader, optimizer, criterion, trn_cnt):
running_loss = 0.
running_acc = 0.
pbar = tqdm(total=trn_cnt)
cnt = 0
for i, data in enumerate(train_loader, 0):
inputs, labels = data
inputs = inputs.to(device)
labels = labels.to(device)
optimizer.zero_grad()
model_conv.train()
outputs = model_c... | 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... | Cassava Leaf Disease Classification |
14,958,372 | def evaluate(model_conv, valid_loader, criterion):
with torch.no_grad() :
model_conv.eval()
valid_loss = 0.0
valid_acc = 0.0
cnt = 0
pbar = tqdm(total=val_cnt)
for data in valid_loader:
inputs, labels = data
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model_conv(inputs)
probs = softmax(outputs)
... | 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,... | Cassava Leaf Disease Classification |
14,958,372 | for epoch in range(EPOCH):
print(f'
trn_loss, trn_acc = train(model_conv, train_loader, optimizer, criterion, trn_cnt)
print(f'
valid_loss, valid_acc = evaluate(model_conv, valid_loader, criterion)
print(f'
if valid_loss < best_valid_score:
best_valid_score = valid_loss
print(f'
torch.save(model_conv, MODEL_NAME)
pa... | 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... | Cassava Leaf Disease Classification |
14,958,372 | TEST_SIZE = 79726
BATCH_SIZE = 128
test_ids = [os.path.basename(fl)for fl in glob(f'{DATA_PATH}/imgs/test/img_*.jpg')]
test_ids.sort()
transform = transforms.Compose([
transforms.Resize(( 224, 224)) ,
transforms.ToTensor() ,
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
test_dataset = torchvisio... | 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... | Cassava Leaf Disease Classification |
14,958,372 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os
import keras
import numpy
from keras.preprocessing.image import ImageDataGenerator<import_modules> | 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... | Cassava Leaf Disease Classification |
14,958,372 | import keras
import numpy
from keras.preprocessing.image import ImageDataGenerator<choose_model_class> | 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)
predicti... | Cassava Leaf Disease Classification |
14,952,688 | train_datagen = ImageDataGenerator(
rescale=1./255, validation_split=0.2)
<define_variables> | from fastai.vision.all import *
import albumentations | Cassava Leaf Disease Classification |
14,952,688 | train_data = '.. /input/state-farm-distracted-driver-detection/train'
test_data = '.. /input/state-farm-distracted-driver-detection/test'
train_generator = train_datagen.flow_from_directory(
train_data,
target_size=(224, 224),
batch_size=32,
class_mode='categorical',
subset='training')
val_generator = train_datagen.f... | set_seed(42 ) | Cassava Leaf Disease Classification |
14,952,688 | ac_labels= ["c0: safe driving",
"c1: texting - right",
"c2: talking on the phone - right",
"c3: texting - left",
"c4: talking on the phone - left",
"c5: operating the radio",
"c6: drinking",
"c7: reaching behind",
"c8: hair and makeup",
"c9: talking to passenger"]
<define_variables> | class AlbumentationsTransform(RandTransform):
"A transform handler for multiple `Albumentation` transforms"
split_idx,order=None,2
def __init__(self, train_aug, valid_aug): store_attr()
def before_call(self, b, split_idx):
self.idx = split_idx
def encodes(self, img: PILImage):
if self.idx == 0:
aug_img = self.train_aug... | Cassava Leaf Disease Classification |
14,952,688 | imgs, labels = next(train_generator )<count_values> | def get_x(row): return data_path/row['image_id']
def get_y(row): return row['label'] | Cassava Leaf Disease Classification |
14,952,688 | def list_counts(start_dir):
lst = sorted(os.listdir(start_dir))
out = [(fil, len(os.listdir(os.path.join(start_dir, fil)))) for fil in lst if os.path.isdir(os.path.join(start_dir,fil)) ]
return out
out = list_counts(train_data)
labels, counts = zip(*out)
print("Total number of images : ",functools.reduce(lambda a,b :... | class CassavaModel(Module):
def __init__(self, num_classes):
self.effnet = EfficientNet.from_pretrained("efficientnet-b3")
self.dropout = nn.Dropout(0.1)
self.out = nn.Linear(1536, num_classes)
def forward(self, image):
batch_size, _, _, _ = image.shape
x = self.effnet.extract_features(image)
x = F.adaptive_avg_poo... | Cassava Leaf Disease Classification |
14,952,688 | from keras.layers import ZeroPadding2D, Conv2D, MaxPooling2D, Flatten, Dense, Dropout, Input
from keras.layers import GlobalAveragePooling2D, MaxPooling2D
from keras.models import Model, Sequential
from keras.callbacks import ModelCheckpoint
from keras import regularizers<choose_model_class> | Path('/kaggle/input' ).ls() | Cassava Leaf Disease Classification |
14,952,688 | input_layer = Input(shape=(224,224, 3))
conv = Conv2D(filters=8, kernel_size=2 )(input_layer)
conv = Conv2D(filters=16, kernel_size=2, activation='relu' )(conv)
conv = Conv2D(filters=32, kernel_size=2, activation='relu' )(conv)
conv = MaxPooling2D()(conv)
conv = Conv2D(filters=64, kernel_size=2, activation='relu' )... | learn = load_learner(Path('/kaggle/input/effnet-inference/inference(1)'), cpu=False ) | Cassava Leaf Disease Classification |
14,952,688 | model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'] )<train_model> | path = Path(".. /input")
data_path = path/'cassava-leaf-disease-classification' | Cassava Leaf Disease Classification |
14,952,688 | checkpoint = ModelCheckpoint('best_model_1.hdf5', save_best_only=True, verbose=1)
history = model.fit_generator(train_generator, steps_per_epoch=len(train_generator),
epochs=10,
validation_data = val_generator,
validation_steps=len(val_generator),
callbacks=[checkpoint] )<load_pretrained> | test_df = pd.read_csv(data_path/'sample_submission.csv')
test_df.head() | Cassava Leaf Disease Classification |
14,952,688 | !ls.. /input/state-farm-distracted-driver-detection/
batch_index = 0
files_list = os.listdir(".. /input/state-farm-distracted-driver-detection/test/")
def load_test_images(batch_size=32, src='.. /input/state-farm-distracted-driver-detection/test/'):
global batch_index, files_list
imgs_list = files_list[batch_index: ba... | test_copy = test_df.copy()
test_copy['image_id'] = test_copy['image_id'].apply(lambda x: f'test_images/{x}' ) | Cassava Leaf Disease Classification |
14,952,688 | preds_list = np.array([])
batch_index=0
batch_size = 32
while True:
tst_imgs = load_test_images(batch_size=batch_size)
if(tst_imgs.shape[0] <= 0):
print("Batchsize is less : ",batch_index)
break
preds = model.predict(tst_imgs)
print("\r {}, batch_size : {}, nth_batch/all_batch : {}/{}".format(preds_list.shape,batch... | test_dl = learn.dls.test_dl(test_copy ) | Cassava Leaf Disease Classification |
14,952,688 | titles = "img,c0,c1,c2,c3,c4,c5,c6,c7,c8,c9".split(",")
names = pd.DataFrame(files_list[:len(preds_list)])
names.columns=["img"]
df = pd.DataFrame(preds_list)
df.columns=titles[1:]
df['img']=names['img']
df = df[titles]
df.tail()
df.to_csv('sub.csv',index=False)
<choose_model_class> | preds, _ = learn.get_preds(dl=test_dl ) | Cassava Leaf Disease Classification |
14,952,688 | def load_VGG16(weights_path=None, no_top=True):
input_shape =(224, 224, 3)
img_input = Input(shape=input_shape)
x = Conv2D(64,(3, 3), activation='relu', padding='same', name='block1_conv1' )(img_input)
x = Conv2D(64,(3, 3), activation='relu', padding='same', name='block1_conv2' )(x)
x = MaxPooling2D(( 2, 2), stride... | test_df['label'] = preds.argmax(dim=-1 ).numpy() | Cassava Leaf Disease Classification |
14,952,688 | <categorify><EOS> | test_df.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,938,817 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<choose_model_class> | package_paths = [
'.. /input/pytorch-image-models/pytorch-image-models-master'
]
for pth in package_paths:
sys.path.append(pth ) | Cassava Leaf Disease Classification |
14,938,817 | vgg_m.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.SGD(0.001), metrics=['accuracy'])
<train_model> | Cassava Leaf Disease Classification |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.