kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,464,807 | preds_v,y_v = learn.TTA(is_test=False,n_aug=2)
preds_v = np.stack(preds_v, axis=-1)
preds_v = np.exp(preds_v)
preds_v = preds_v.mean(axis=-1)
y_v += 1<prepare_output> | def decode_image(image):
image = tf.image.decode_jpeg(image, channels=3)
image = tf.cast(image, tf.float32)
image = tf.reshape(image, [*IMAGE_SIZE, 3])
return image | Cassava Leaf Disease Classification |
13,464,807 | TEST=TRAIN
total_new_whale = len(new_whale_df.index.values)
md = get_data(384, batch_size, test_names=new_whale_df.index.values[:int(total_new_whale*0.2)], test_dir=TRAIN)
learn.set_data(md)
preds_w,y_w = learn.TTA(is_test=True,n_aug=2)
preds_w = np.stack(preds_w, axis=-1)
preds_w = np.exp(preds_w)
preds_w = pred... | 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,464,807 | y = np.concatenate([y_v,y_w])
preds = np.concatenate([preds_v, preds_w],axis=0)
preds = np.concatenate([np.zeros(( preds.shape[0],1)) , preds],axis=1 )<find_best_params> | 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,464,807 | def map5(X, y):
score = 0
for i in range(X.shape[0]):
pred = X[i].argsort() [-5:][::-1]
for j in range(pred.shape[0]):
if pred[j] == y[i]:
score +=(5 - j)/5
break
return score/X.shape[0]
best_th = 0
best_score = 0
for th in np.arange(0.1, 0.801, 0.01):
preds[:,0] = th
score = map5(preds, y)
if score > best_score:
best... | 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,464,807 | TEST = '.. /input/test/'
md = get_data(384, batch_size, test_names=test_names, test_dir=TEST)
learn.set_data(md)
preds_t,y_t = learn.TTA(is_test=True,n_aug=8)
preds_t = np.stack(preds_t, axis=-1)
preds_t = np.exp(preds_t)
preds_t = preds_t.mean(axis=-1)
preds_t = np.concatenate([np.zeros(( preds_t.shape[0],1)) +b... | test_ds = get_test_dataset(ordered=True)
print('Computing predictions...')
test_images_ds = test_ds.map(lambda image, idnum: image)
probabilities = trained_model.predict(test_images_ds)
predictions = np.argmax(probabilities, axis=-1)
print(predictions ) | Cassava Leaf Disease Classification |
13,464,807 | <import_modules><EOS> | print('Generating submission.csv file...')
NUM_TEST_IMAGES = count_data_items(TEST_FILENAMES)
test_ids_ds = test_ds.map(lambda image, idnum: idnum ).unbatch()
test_ids = next(iter(test_ids_ds.batch(NUM_TEST_IMAGES)) ).numpy().astype('U')
np.savetxt('submission.csv', np.rec.fromarrays([test_ids, predictions]), fmt=['... | Cassava Leaf Disease Classification |
13,296,423 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<load_from_csv> | warnings.simplefilter(action = 'ignore', category = FutureWarning)
print("Tensorflow version " + tf.__version__ ) | Cassava Leaf Disease Classification |
13,296,423 | train_transaction = pd.read_csv('.. /input/ieee-fraud-detection/train_transaction.csv')
test_transaction = pd.read_csv('.. /input/ieee-fraud-detection/test_transaction.csv' )<load_from_csv> | def seed_everything(seed=0):
random.seed(seed)
np.random.seed(seed)
tf.random.set_seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
os.environ['TF_DETERMINISTIC_OPS'] = '1'
SEED = 414
seed_everything(SEED ) | Cassava Leaf Disease Classification |
13,296,423 | submit = pd.read_csv(".. /input/ieee-gb-2-make-amount-useful-again/submission.csv" )<data_type_conversions> | try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print('Running on TPU ', tpu.master())
except ValueError:
tpu = None
if tpu:
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
strategy = tf.distribute.experimental.TPUStrategy(tpu)
else:
strategy = tf.distrib... | Cassava Leaf Disease Classification |
13,296,423 | def make_day(df):
def fillna(x):
if "nan" in x:
return np.nan
else:
return x
START_DATE = datetime.datetime.strptime('2017-11-30', '%Y-%m-%d')
df['Date'] = df['TransactionDT'].apply(lambda x:(START_DATE + datetime.timedelta(seconds=x)))
df['Day'] =(df["Date"].dt.year - 2017)* 365 + df["Date"].dt.dayofyear
df["ID1"] =... | GCS_DS_PATH = '.. /input/cassava-leaf-disease-classification'
print(GCS_DS_PATH ) | Cassava Leaf Disease Classification |
13,296,423 | train_transaction = make_day(train_transaction)
test_transaction = make_day(test_transaction )<groupby> | BATCH_SIZE = 16 * REPLICAS
WARMUP_EPOCHS = 3
WARMUP_LEARNING_RATE = 1e-4 * REPLICAS
EPOCHS = 20
LEARNING_RATE = 5e-5 * REPLICAS
ES_PATIENCE = 5
CHANNELS = 3
N_CLASSES = 5
DIM = 512
HEIGHT = 512
WIDTH = 512
CLASSES = ['0', '1', '2', '3', '4']
AUTO = tf.data.experimental.AUTOTUNE | Cassava Leaf Disease Classification |
13,296,423 | q_id1 = train_transaction[["ID_D1D10", "isFraud"]].groupby("ID_D1D10" ).agg({"isFraud": ["count", "mean"]} ).reset_index()
q_id1.columns = ["ID_D1D10", "isFraud_countD1D10", "isFraud_meanD1D10"]
q_id2 = train_transaction[["ID_D1D10", "isFraud"]].groupby("ID_D1D10" ).agg({"isFraud": ["count", "mean"]} ).reset_index()
q_... | ROT_ = 180.0
SHR_ = 2.0
HZOOM_ = 8.0
WZOOM_ = 8.0
HSHIFT_ = 8.0
WSHIFT_ = 8.0 | Cassava Leaf Disease Classification |
13,296,423 | test_transaction = pd.merge(test_transaction, q_id1, how="left", on="ID_D1D10")
test_transaction = pd.merge(test_transaction, q_id2, how="left", on="ID_D1D12" )<merge> | def get_mat(rotation, shear, height_zoom, width_zoom, height_shift, width_shift):
rotation = math.pi * rotation / 180.
shear = math.pi * shear / 180.
c1 = tf.math.cos(rotation)
s1 = tf.math.sin(rotation)
one = tf.constant([1],dtype='float32')
zero = tf.constant([0],dtype='float32')
rotation_matrix = tf.reshape(tf... | Cassava Leaf Disease Classification |
13,296,423 | submit = pd.merge(submit, test_transaction, how="left", on="TransactionID" )<define_variables> | def transform(image, DIM=512):
XDIM = DIM%2
rot = ROT_ * tf.random.normal([1], dtype='float32')
shr = SHR_ * tf.random.normal([1], dtype='float32')
h_zoom = 1.0 + tf.random.normal([1], dtype='float32')/ HZOOM_
w_zoom = 1.0 + tf.random.normal([1], dtype='float32')/ WZOOM_
h_shift = HSHIFT_ * tf.random.normal([1], dtyp... | Cassava Leaf Disease Classification |
13,296,423 | q = "isFraud_countD1D10 > 1 and isFraud_meanD1D10 > 0.7 and ProductCD != 'C'"<feature_engineering> | 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']
def read_unlabeled_tfrecord(example, return_image_name):
tfrec_fo... | Cassava Leaf Disease Classification |
13,296,423 | submit["isFraud"][submit.query(q ).index] = 1<define_variables> | def get_dataset(files, augment = False, shuffle = False, repeat = False,
labeled=True, return_image_names=True, batch_size=BATCH_SIZE, dim=512):
ds = tf.data.TFRecordDataset(files, num_parallel_reads=AUTO)
ds = ds.cache()
if repeat:
ds = ds.repeat()
if shuffle:
ds = ds.shuffle(1024*8)
opt = tf.data.Options()
opt.expe... | Cassava Leaf Disease Classification |
13,296,423 | q = "isFraud_countD1D12 > 1 and isFraud_meanD1D12 == 1 and ProductCD == 'C'"<define_variables> | TEST_FILENAMES = tf.io.gfile.glob(GCS_DS_PATH + '/test_tfrecords/*.tfrec')
| Cassava Leaf Disease Classification |
13,296,423 | q = "isFraud_countD1D10 > 5 and isFraud_meanD1D10 == 0"<feature_engineering> | NUM_TEST_IMAGES = count_data_items(TEST_FILENAMES)
print('Dataset: {} unlabeled test images'.format(NUM_TEST_IMAGES)) | Cassava Leaf Disease Classification |
13,296,423 | submit["isFraud"][submit.query(q ).index] = 0<save_to_csv> | sys.path.append('/kaggle/input/efficientnet-keras-dataset/efficientnet_kaggle')
! pip install /kaggle/input/efficientnet-keras-dataset/efficientnet_kaggle | Cassava Leaf Disease Classification |
13,296,423 | submit[["TransactionID", "isFraud"]].to_csv("postprocessed.csv", index=False )<set_options> | import efficientnet.keras as efn
| Cassava Leaf Disease Classification |
13,296,423 | pd.options.display.max_rows = 500
pd.options.display.max_columns = 100<load_from_csv> | def create_model_efnB6() :
base_model = efn.EfficientNetB6(weights=None,
include_top=False,
input_shape=[HEIGHT, WIDTH, 3])
model = tf.keras.Sequential([
base_model,
tf.keras.layers.GlobalAveragePooling2D() ,
tf.keras.layers.Flatten() ,
tf.keras.layers.Dense(len(CLASSES), activation='softmax')
])
return model | Cassava Leaf Disease Classification |
13,296,423 | train = pd.read_csv('/kaggle/input/ieee-fraud-detection/train_transaction.csv')
train_ind = pd.read_csv('/kaggle/input/ieee-fraud-detection/train_identity.csv')
test = pd.read_csv('/kaggle/input/ieee-fraud-detection/test_transaction.csv')
test_ind = pd.read_csv('/kaggle/input/ieee-fraud-detection/test_identity.csv' ... | with strategy.scope() :
model_efnB6 = create_model_efnB6() | Cassava Leaf Disease Classification |
13,296,423 | train_len = len(train)
<merge> | TTA = 1
print('Predicting Test with TTA...')
test_ds = get_dataset(TEST_FILENAMES,labeled=False,return_image_names=False,augment=False,
repeat=False,shuffle=False)
test_ct = count_data_items(TEST_FILENAMES);
STEPS = TTA * test_ct/BATCH_SIZE/REPLICAS
if STEPS < 1:
STEPS = 1
test_df = pd.read_csv('.. /input/cassava-lea... | Cassava Leaf Disease Classification |
13,296,423 | <concatenate><EOS> | print('Generating submission.csv file...')
ds = get_dataset(TEST_FILENAMES,labeled=False,return_image_names=True,augment=False,
repeat=False,shuffle=False)
test_ids = np.array([img_name.numpy().decode("utf-8")
for img, img_name in iter(ds.unbatch())])
np.savetxt(
'submission.csv',
np.rec.fromarrays([test_ids, pred... | Cassava Leaf Disease Classification |
13,446,743 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<feature_engineering> | !pip install --no-deps.. /input/pretrined-models/timm-0.3.3-py3-none-any.whl | Cassava Leaf Disease Classification |
13,446,743 | START_DATE = datetime.datetime.strptime('2017-11-30', '%Y-%m-%d')
all_data['DT_time'] = all_data['TransactionDT'].apply(lambda x:(START_DATE + datetime.timedelta(seconds = x)))
all_data['count'] = 1
all_data['diff_days_from_first_transaction'] = all_data['D1'].fillna(0 ).apply(lambda x:(datetime.timedelta(days = x)))... | import os
import pandas as pd
import timm
from PIL import Image, ImageDraw, ImageChops
import matplotlib.pyplot as plt
from torchvision.utils import make_grid
from tqdm import tqdm | Cassava Leaf Disease Classification |
13,446,743 | anaysis_fea = [ 'TransactionID',
'isFraud',
'TransactionDT',
'TransactionAmt',
'ProductCD',
'device_hash','card_hash', 'V307','id_30','id_31','id_32','id_33','DeviceType','DeviceInfo',
'card1','card2','card3','card4','card5','card6','client_firstdate_days','dist1','dist2','P_emaildomain','addr1','addr2','train_or_test'... | df = pd.read_csv(path + "/train.csv" ) | Cassava Leaf Disease Classification |
13,446,743 | all_data = all_data.drop(drop_fea,axis=1 )<set_options> | df["path"] = df["image_id"].map(lambda x: path + "/train_images/" + x)
df = df.drop(columns=["image_id"])
df = df.sample(frac=1 ).reset_index(drop=True ) | Cassava Leaf Disease Classification |
13,446,743 | gc.collect()<data_type_conversions> | train_df, valid_df = model_selection.train_test_split(
df, test_size=0.2, random_state=42, stratify=df.label.values
) | Cassava Leaf Disease Classification |
13,446,743 | all_data['card1'] = all_data['card1'].fillna(0)
all_data['card2'] = all_data['card2'].fillna(0)
all_data['card3'] = all_data['card3'].fillna(0)
all_data['card5'] = all_data['card5'].fillna(0)
all_data['card4'] = all_data['card4'].fillna('nan')
all_data['card6'] = all_data['card6'].fillna('nan' )<feature_engineerin... | train_df = train_df.reset_index().drop(columns=["index"])
train_df.head() | Cassava Leaf Disease Classification |
13,446,743 | all_data['card_hash'] = all_data.apply(lambda x: card_info_hash(x), axis=1 )<filter> | valid_df = valid_df.reset_index().drop(columns=["index"])
valid_df.head() | Cassava Leaf Disease Classification |
13,446,743 | def get_data_by_card_hash(data, card_hash):
mask = data['card_hash']==card_hash
return data.loc[mask,:].copy()
def get_data_by_device_hash(data, device_hash):
mask = data['device_hash']==device_hash
return data.loc[mask,:].copy()
def get_data_by_card_and_startdate(data, card_hash, device_hash):
mask =(data['client_firs... | im = Image.open(train_df["path"][0] ) | Cassava Leaf Disease Classification |
13,446,743 | all_data['count']=1
grp = all_data.iloc[:train_len].groupby(['client_firstdate_days','card_hash'])['count'].agg('sum')
display_group = get_data_by_card_and_startdate(all_data,grp[grp>10].index[0][0],grp[grp>10].index[0][1])
display_group[['DT_time','TransactionAmt','V307','id_30','id_31','id_32','id_33','DeviceType',... | import torch
import torch.nn.functional as F
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import Dataset, DataLoader
from torch.utils.data.dataset import Subset
from sklearn.model_selection import KFold
import matplotlib.image as img | Cassava Leaf Disease Classification |
13,446,743 | s = all_data.iloc[:train_len].groupby(['client_firstdate_days','card_hash'])['isFraud'].agg(['mean', 'count'] )<concatenate> | class CassavaDataset(Dataset):
def __init__(self, dataframe, transform=None):
super().__init__()
self.df = dataframe
self.transform = transform
def __len__(self):
return len(self.df["path"])
def __getitem__(self, index):
path = self.df["path"][index]
label = self.df["label"][index]
with open(path, "rb")as f:
image = I... | Cassava Leaf Disease Classification |
13,446,743 | Test_ID=[]
for ind in tqdm(s[(s['mean']==1)].index):
very_strange_thing = get_data_by_card_and_startdate(all_data, ind[0],ind[1])
Test_ID.extend(very_strange_thing[very_strange_thing['isFraud'].isna() ]['TransactionID'].tolist() )<load_from_csv> | import random | Cassava Leaf Disease Classification |
13,446,743 | submit = pd.read_csv('.. /input/rank-blend/easy_blend4.csv' )<feature_engineering> | image_size = 512
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
train_transform = transforms.Compose(
[
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomVerticalFlip(p=0.5),
transforms.RandomResizedCrop(image_size),
make_mask_image(p=0.5, mask_size=50),
transforms.ToTensor() ,
transforms.Normalize(me... | Cassava Leaf Disease Classification |
13,446,743 | mask = submit['TransactionID'].isin(Test_ID)
submit.loc[mask,'isFraud'] =1<filter> | dataset = CassavaDataset(train_df, train_transform ) | Cassava Leaf Disease Classification |
13,446,743 | submit.loc[mask,:]<save_to_csv> | path = '.. /input/cassava-leaf-disease-classification/label_num_to_disease_map.json'
with open(path, mode = 'r')as f:
label_to_name = json.load(f ) | Cassava Leaf Disease Classification |
13,446,743 | submit.to_csv('submit_try.csv',index = False )<set_options> | class Unnormalize(object):
def __init__(self, mean, std):
self.mean = mean
self.std = std
def __call__(self, tensor):
for t, m, s in zip(tensor, self.mean, self.std):
t.mul_(s ).add_(m)
return tensor | Cassava Leaf Disease Classification |
13,446,743 | warnings.filterwarnings('ignore' )<load_from_csv> | unnorm = Unnormalize(mean, std ) | Cassava Leaf Disease Classification |
13,446,743 | sub_1 = pd.read_csv('.. /input/ieee-simple-lgbm/submission.csv')
sub_2 = pd.read_csv('.. /input/ieee-cv-options/submission.csv')
sub_3 = pd.read_csv('.. /input/ieee-lgbm-with-groupkfold-cv/submission.csv')
sub_4 = pd.read_csv('.. /input/ieee-catboost-baseline-with-groupkfold-cv/submission.csv')
sub_5 = pd.read_csv(... | loader = DataLoader(dataset, 16, shuffle = True)
display_batch(next(iter(loader)) ) | Cassava Leaf Disease Classification |
13,446,743 | train_transaction = pd.read_csv('.. /input//ieee-fraud-detection/train_transaction.csv', index_col='TransactionID')
train_f5 = pd.read_csv('.. /input/mysub18/fi_train4.csv', index_col='TransactionID')
train_transaction = train_transaction.merge(train_f5, how='left', left_index=True, right_index=True)
debug = False
i... | import torch
import torch.nn as nn
import torch.nn.functional as F | Cassava Leaf Disease Classification |
13,446,743 | count00 = 0
count01 = 0
count10 = 0
count11 = 0
ukey_dict = {}
ukey2_dict = {}
ukey3_dict = {}
if debug:
train_len = train_transaction.shape[0] * 4//5
else:
train_len = train_transaction.shape[0]
pred_np = []
for i in range(cache.shape[0]):
ukey = cache[i,0]
ukey2 = cache[i, 1]
ukey3 = cache[i, 2]
isFraud = cache[i,3]
... | epoch = 3
batch_size = 16
num_classes = 5
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" ) | Cassava Leaf Disease Classification |
13,446,743 | m15 = pd.read_csv('/kaggle/input/ieee-top-models-blend/m15.csv')
m17 = pd.read_csv('/kaggle/input/ieee-top-models-blend/m17.csv')
m18 = pd.read_csv('/kaggle/input/ieee-top-models-blend/m18.csv')
m19 = pd.read_csv('/kaggle/input/ieee-top-models-blend/m19.csv')
m20 = pd.read_csv('/kaggle/input/ieee-top-models-blend/m... | resNet = timm.create_model("resnet50", pretrained=False)
resNet.load_state_dict(torch.load(".. /input/pretrined-models/models/models/pretrained_resNet.pth"))
resNet.fc = nn.Linear(resNet.fc.in_features, num_classes)
resNet = resNet.to(device ) | Cassava Leaf Disease Classification |
13,446,743 | submission['isFraud'] =(0.20*m15.isFraud)+ \
(0.20*m17.isFraud)+ \
(0.20*m18.isFraud)+ \
(0.20*m19.isFraud)+ \
(0.10)*m20.isFraud + \
(0.10*m16.isFraud)+ \
(0.0*m0.isFraud)
submission.to_csv('my_blend_5.csv', index=False )<set_options> | ef_model = timm.create_model("tf_efficientnet_b2_ns", pretrained=False)
ef_model.load_state_dict(torch.load(".. /input/pretrined-models/models/models/pretrained_ef_model.pth"))
ef_model.classifier = nn.Linear(ef_model.classifier.in_features, num_classes)
ef_model = ef_model.to(device ) | Cassava Leaf Disease Classification |
13,446,743 | pd.options.mode.chained_assignment = None
warnings.filterwarnings("ignore", category = DeprecationWarning)
%matplotlib inline
<load_from_csv> | ef_optimizer = torch.optim.AdamW(ef_model.parameters() , lr=1e-4, weight_decay=0.0001)
ef_scheduler = torch.optim.lr_scheduler.StepLR(ef_optimizer, step_size=2, gamma=0.1)
resNet_optimizer = torch.optim.AdamW(resNet.parameters() , lr=1e-4, weight_decay=0.0001)
resNet_scheduler = torch.optim.lr_scheduler.StepLR(resNe... | Cassava Leaf Disease Classification |
13,446,743 | dailyData = pd.read_csv(".. /input/bike-sharing-demand/train.csv" )<feature_engineering> | def calc_correction(model, df):
model.eval()
path = df["path"]
label = df["label"]
count = 0
pred_list = [0, 0, 0, 0, 0]
for i in tqdm(range(len(path))):
image_path = path[i]
image_label = label[i]
image = Image.open(image_path)
image = valid_transform(image)
image = image.unsqueeze(0 ).to(device)
model = model.to(d... | Cassava Leaf Disease Classification |
13,446,743 | dailyData.datetime.apply(lambda x:x.split() [0] )<feature_engineering> | def train_model(model, dataset, batch_size, optimizer, criterion, scheduler, epoch, model_title):
best_model = None
best_loss = float("inf")
train_losses, valid_losses = [], []
kf = KFold(n_splits = 5)
for fold,(train_index, valid_index)in enumerate(kf.split(dataset)) :
print("fold: ", fold)
train_dataset = Subset(d... | Cassava Leaf Disease Classification |
13,446,743 | dailyData["date"] = dailyData.datetime.apply(lambda x:x.split() [0])
dailyData["hour"] = dailyData.datetime.apply(lambda x: x.split() [1].split(":")[0])
dailyData["weekday"] = dailyData.date.apply(lambda dateString: calendar.day_name[datetime.strptime(dateString, "%Y-%m-%d" ).weekday() ])
dailyData["month"] = dailyD... | train_models(resNet, ef_model ) | Cassava Leaf Disease Classification |
13,446,743 | categoryvariables = ["hour", "weekday", "month", "season", "weather", "holiday", "workingday"]
for var in categoryvariables:
dailyData[var] = dailyData[var].astype("category" )<drop_column> | ef_model.load_state_dict(torch.load(".. /input/models/ef_model.pth", map_location = device))
resNet.load_state_dict(torch.load(".. /input/models/res_model.pth", map_location = device)) | Cassava Leaf Disease Classification |
13,446,743 | dailyData = dailyData.drop(["datetime"], axis =1 )<create_dataframe> | class CassaveClassifier(nn.Module):
def __init__(self, model, ef_model):
super().__init__()
self.model = model
self.ef_model = ef_model
def forward(self, x):
x1 = self.model(x)
x2 = self.ef_model(x)
return(0.5 * x1 + 0.5 * x2)
def test(self, x, rate):
x1 = self.model(x)
x2 = self.ef_model(x)
p = rate * x1 +(1 - ra... | Cassava Leaf Disease Classification |
13,446,743 | typesCountSerie = dailyData.dtypes.value_counts()
typeNamesColumn = list(map(lambda t: t.name , typesCountSerie.index.values)) ;
typeCountColumn = typesCountSerie.values
intialDataTypeDf = pd.DataFrame({
"variableType": typeNamesColumn,
"count": typeCountColumn
})
groupedDataTypeDf = intialDataTypeDf.groupby(['variabl... | classifier = CassaveClassifier(resNet, ef_model)
classifier = classifier.to(device ) | Cassava Leaf Disease Classification |
13,446,743 | np.sum(np.abs(dailyData["count"]-dailyData["count"].mean())<=(3*dailyData["count"].std()))
<filter> | def test_rate() :
for rate in range(1, 10):
classifier.eval()
path = valid_df["path"]
label = valid_df["label"]
count = 0
pred_list = [0, 0, 0, 0, 0]
for i in tqdm(range(len(path))):
image_path = path[i]
image_label = label[i]
image = Image.open(image_path)
image = valid_transform(image)
image = image.unsqueeze(0 ).t... | Cassava Leaf Disease Classification |
13,446,743 | dailyDataWithoutOutliers = dailyData[np.abs(dailyData["count"]-dailyData["count"].mean())<=(3*dailyData["count"].std())]<load_from_csv> | path = ".. /input/cassava-leaf-disease-classification/test_images/" | Cassava Leaf Disease Classification |
13,446,743 | dataTrain = pd.read_csv(".. /input/bike-sharing-demand/train.csv")
dataTest = pd.read_csv(".. /input/bike-sharing-demand/test.csv" )<concatenate> | image_path = []
image_id = []
for i in os.listdir(path):
image_id.append(str(i))
image_path.append(path + str(i)) | Cassava Leaf Disease Classification |
13,446,743 | data = dataTrain.append(dataTest)
data.reset_index(inplace = True)
data.drop('index', inplace = True, axis = 1 )<feature_engineering> | pred = []
for path in image_path:
image = Image.open(path)
image = valid_transform(image)
image = image.unsqueeze(0 ).to(device)
predict = resNet(image ).argmax(1 ).item()
pred.append(predict ) | Cassava Leaf Disease Classification |
13,446,743 | data["date"] = data.datetime.apply(lambda x : x.split() [0])
data["hour"] = data.datetime.apply(lambda x : x.split() [1].split(":")[0] ).astype("int")
data["year"] = data.datetime.apply(lambda x : x.split() [0].split("-")[0])
data["weekday"] = data.date.apply(lambda dateString : datetime.strptime(dateString,"%Y-%m-%... | sub = pd.DataFrame({"image_id": image_id, "label": pred} ) | Cassava Leaf Disease Classification |
13,446,743 | <define_variables><EOS> | sub.to_csv("submission.csv", index=False ) | Cassava Leaf Disease Classification |
13,947,825 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<data_type_conversions> | Cassava Leaf Disease Classification | |
13,947,825 | for var in categoricalFeatureNames:
data[var] = data[var].astype("category" )<prepare_x_and_y> | from fastai.vision.all import * | Cassava Leaf Disease Classification |
13,947,825 | dataTrain = data[pd.notnull(data['count'])].sort_values(by=["datetime"])
dataTest = data[~pd.notnull(data['count'])].sort_values(by = ["datetime"])
datetimecol = dataTest["datetime"]
yLabels = dataTrain["count"]
yLabelsRegistered = dataTrain["registered"]
yLabelsCasual = dataTrain["casual"]<split> | 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 |
13,947,825 | X_train, X_validate, y_train, y_validate = train_test_split(dataTrain, yLabels, test_size=0.3, random_state=42)
dateTimeColValidate = X_validate["datetime"]<drop_column> | def get_x(row): return row['image_id']
def get_y(row): return row['label'] | Cassava Leaf Disease Classification |
13,947,825 | dataTrain = dataTrain.drop(dropFeatures,axis=1)
dataTest = dataTest.drop(dropFeatures,axis=1)
X_train = X_train.drop(dropFeatures,axis=1)
X_validate = X_validate.drop(dropFeatures,axis=1 )<compute_test_metric> | Cassava Leaf Disease Classification | |
13,947,825 | def rmsle(y, y_,convertExp=True):
if convertExp:
y = np.exp(y),
y_ = np.exp(y_)
log1 = np.nan_to_num(np.array([np.log(v + 1)for v in y]))
log2 = np.nan_to_num(np.array([np.log(v + 1)for v in y_]))
calc =(log1 - log2)** 2
return np.sqrt(np.mean(calc))<set_options> | learn=load_learner(".. /input/resnext50/baseline_rsnx",cpu=False ) | Cassava Leaf Disease Classification |
13,947,825 | pd.options.mode.chained_assignment = None
warnings.filterwarnings("ignore", category=DeprecationWarning )<predict_on_test> | learn = learn.to_native_fp32() | Cassava Leaf Disease Classification |
13,947,825 | lModel = LinearRegression()
lModel.fit(X = X_train,y = np.log1p(y_train))
preds = lModel.predict(X= X_validate)
print("RMSLE Value For Linear Regression In Validation: ",rmsle(np.exp(np.log1p(y_validate)) ,np.exp(preds),False))<compute_test_metric> | data_path=".. /input/cassava-leaf-disease-classification/" | Cassava Leaf Disease Classification |
13,947,825 |
<train_on_grid> | sample_df = pd.read_csv(data_path+'sample_submission.csv')
sample_df.head() | Cassava Leaf Disease Classification |
13,947,825 | ridge_m_ = Ridge()
ridge_params_ = { 'max_iter':[3000],'alpha':[0.01,0.05,0.1, 1, 2, 3, 4, 10, 30,100,200,300,400,800,900,1000]}
rmsle_scorer = metrics.make_scorer(rmsle, greater_is_better = False)
grid_ridge_m = GridSearchCV(ridge_m_,
ridge_params_,
scoring = rmsle_scorer,
cv=5)
grid_ridge_m.fit(X = X_train, y = np.... | sample_copy = sample_df.copy()
sample_copy['image_id'] = sample_copy['image_id'].apply(lambda x: ".. /input/cassava-leaf-disease-classification/test_images/"+x ) | Cassava Leaf Disease Classification |
13,947,825 | lasso_m_ = Lasso()
alpha = [0.001,0.005,0.01,0.3,0.1,0.3,0.5,0.7,1]
lasso_params_ = { 'max_iter':[3000],'alpha':alpha}
grid_lasso_m = GridSearchCV(lasso_m_, lasso_params_, scoring = rmsle_scorer, cv = 5)
grid_lasso_m.fit(X = X_train,y = np.log1p(y_train))
preds = grid_lasso_m.predict(X= X_validate)
print(grid_lasso_m... | test_dl = learn.dls.test_dl(sample_copy ) | Cassava Leaf Disease Classification |
13,947,825 | rfModel = RandomForestRegressor(n_estimators=100)
rfModel.fit(X = X_train,y = np.log1p(y_train))
preds = rfModel.predict(X= X_validate)
print("RMSLE Value: ",rmsle(np.exp(np.log1p(y_validate)) ,np.exp(preds), False))<save_to_csv> | preds, _ = learn.tta(dl=test_dl, n=15, beta=0 ) | Cassava Leaf Disease Classification |
13,947,825 | submission = pd.DataFrame({
"datetime": datetimecol,
"count": [max(0, x)for x in np.exp(predsTest)]
})
submission.to_csv('bike_predictions_gbm_separate_without_fe.csv', index=False )<load_from_csv> | sample_df['label'] = preds.argmax(dim=-1 ).numpy() | Cassava Leaf Disease Classification |
13,947,825 | train = pd.read_csv("/kaggle/input/bike-sharing-demand/train.csv", parse_dates=["datetime"])
test = pd.read_csv("/kaggle/input/bike-sharing-demand/test.csv", parse_dates=["datetime"] )<feature_engineering> | sample_df.to_csv('submission.csv',index=False ) | Cassava Leaf Disease Classification |
13,947,825 | <feature_engineering><EOS> | pd.read_csv("./submission.csv" ) | Cassava Leaf Disease Classification |
14,044,490 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<feature_engineering> | !nvidia-smi | Cassava Leaf Disease Classification |
14,044,490 | test["datetime-year"] = test["datetime"].dt.year
test["datetime-month"] = test["datetime"].dt.month
test["datetime-day"] = test["datetime"].dt.day
test["datetime-hour"] = test["datetime"].dt.hour
test["datetime-minute"] = test["datetime"].dt.minute
test["datetime-second"] = test["datetime"].dt.second
test["datetime-day... | !pip install.. /input/timmmodels/dist/timm-0.3.4.tar | Cassava Leaf Disease Classification |
14,044,490 | test.loc[test["datetime-dayofweek"] == 0, "datetime-dayofweek(humanized)"] = "Monday"
test.loc[test["datetime-dayofweek"] == 1, "datetime-dayofweek(humanized)"] = "Tuesday"
test.loc[test["datetime-dayofweek"] == 2, "datetime-dayofweek(humanized)"] = "Wednesday"
test.loc[test["datetime-dayofweek"] == 3, "datetime-dayofw... | import os
import cv2
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torchvision import models
from torch.utils.data import DataLoader, Dataset
from torch.cuda import amp
import albumentations as A
from albumentations.pytorch import ToTen... | Cassava Leaf Disease Classification |
14,044,490 | %matplotlib inline
<data_type_conversions> | ROOT_DIR = ".. /input/cassava-leaf-disease-classification"
TEST_DIR = ".. /input/cassava-leaf-disease-classification/test_images" | Cassava Leaf Disease Classification |
14,044,490 | train["datetime-year(str)"] = train["datetime-year"].astype('str')
train["datetime-month(str)"] = train["datetime-month"].astype('str')
train["datetime-year_month"] = train["datetime-year(str)"] + "-" + train["datetime-month(str)"]
print(train.shape)
train[["datetime", "datetime-year_month"]].head()<define_variables... | class CFG:
model_name = 'tf_efficientnet_b4_ns'
img_size = 512
loadmodelpath = '/kaggle/input/cassava-bitempered-logistic-loss/bitemp-01.pth'
num_classes = 5
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu" ) | Cassava Leaf Disease Classification |
14,044,490 | feature_names = ["datetime-year", "season", "datetime-hour", "datetime-dayofweek", "workingday", "holiday",
"weather", "humidity", "temp", "atemp", "windspeed"]
feature_names<define_variables> | model = timm.create_model(CFG.model_name, pretrained=False)
num_features = model.classifier.in_features
model.classifier = nn.Linear(num_features, CFG.num_classes)
model.to(CFG.device); | Cassava Leaf Disease Classification |
14,044,490 | label_name = "count"
label_name<choose_model_class> | model = torch.load(CFG.loadmodelpath)
model.eval() | Cassava Leaf Disease Classification |
14,044,490 | model = RandomForestRegressor(n_jobs=-1,
random_state=37)
model<compute_test_metric> | T_DIR = TEST_DIR
t_df = pd.read_csv(f"{ROOT_DIR}/sample_submission.csv" ) | Cassava Leaf Disease Classification |
14,044,490 | def rmsle(predict, actual):
predict = np.array(predict)
actual = np.array(actual)
log_predict = np.log(predict + 1)
log_actual = np.log(actual + 1)
distance = log_predict - log_actual
square_distance = distance ** 2
mean_square_distance = square_distance.mean()
score = np.sqrt(mean_square_distance)
return score
rm... | t_data = CassavaLeafDataset(T_DIR, t_df, transforms=data_transforms["valid"])
t_loader = DataLoader(dataset=t_data, batch_size=1, num_workers=4, pin_memory=True, shuffle=False ) | Cassava Leaf Disease Classification |
14,044,490 | score = cross_val_score(model, X_train, y_train,
cv=20, scoring=rmsle_score ).mean()
print("Score = {0:.5f}".format(score))<train_model> | submit_df = pd.DataFrame(t_df ).copy(deep=True)
for i,(inputs, _)in enumerate(t_loader):
inputs = inputs.to(CFG.device)
outputs = model(inputs ).detach().cpu().numpy()
pred_label = np.argmax(outputs)
submit_df.iloc[i] = [t_df.iloc[i]['image_id'], pred_label] | Cassava Leaf Disease Classification |
14,044,490 | <train_model><EOS> | submit_df.to_csv("/kaggle/working/submission.csv", index=False ) | Cassava Leaf Disease Classification |
13,427,958 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<predict_on_test> | warnings.simplefilter("ignore")
| Cassava Leaf Disease Classification |
13,427,958 | predictions = model.predict(X_test)
print(predictions.shape)
predictions<load_from_csv> | print('Train images: %d' %len(os.listdir(
os.path.join(WORK_DIR, "train_images")))) | Cassava Leaf Disease Classification |
13,427,958 | submission = pd.read_csv("/kaggle/input/bike-sharing-demand/sampleSubmission.csv")
print(submission.shape)
submission.head()<prepare_output> | with open(os.path.join(WORK_DIR, "label_num_to_disease_map.json")) as file:
print(json.dumps(json.loads(file.read()), indent=4)) | Cassava Leaf Disease Classification |
13,427,958 | submission["count"] = predictions
print(submission.shape)
submission.head()<save_to_csv> | train_labels = pd.read_csv(os.path.join(WORK_DIR, "train.csv"))
train_labels.head() | Cassava Leaf Disease Classification |
13,427,958 | submission.to_csv("submission.csv", index=False )<save_to_csv> | BATCH_SIZE = 8
STEPS_PER_EPOCH = len(train_labels)*0.8 / BATCH_SIZE
VALIDATION_STEPS = len(train_labels)*0.2 / BATCH_SIZE
EPOCHS = 5
TARGET_SIZE = 512 | Cassava Leaf Disease Classification |
13,427,958 | submission.to_csv("submission.csv", index=False )<load_from_csv> | train_labels.label = train_labels.label.astype('str')
train_datagen = ImageDataGenerator(validation_split = 0.2,
preprocessing_function = None,
rotation_range = 45,
zoom_range = 0.2,
horizontal_flip = True,
vertical_flip = True,
fill_mode = 'nearest',
shear_range = 0.1,
height_shift_range = 0.1,
width_shift_range = 0.... | Cassava Leaf Disease Classification |
13,427,958 | train=data=pd.read_csv('/kaggle/input/bike-sharing-demand/train.csv')
test=pd.read_csv('/kaggle/input/bike-sharing-demand/test.csv')
train.info()
Y1train=train['casual']
Y2train=train['registered']
Ytrain=train['count']
<feature_engineering> | generator = train_datagen.flow_from_dataframe(train_labels.iloc[20:21],
directory = os.path.join(WORK_DIR, "train_images"),
x_col = "image_id",
y_col = "label",
target_size =(TARGET_SIZE, TARGET_SIZE),
batch_size = BATCH_SIZE,
class_mode = "sparse")
aug_images = [generator[0][0][0]/255 for i in range(10)]
fig, axes = ... | Cassava Leaf Disease Classification |
13,427,958 | feature_names=list(test)
train=train[feature_names]
all_data=pd.concat(( train, test))
print(train.shape, test.shape, all_data.shape)
print(Ytrain)
all_data['datetime']=pd.to_datetime(all_data['datetime'])
all_data['year']=all_data['datetime'].dt.year
all_data['month']=all_data['datetime'].dt.month
all_data['day']=... | classes_to_predict = sorted(train_labels.label.unique())
dropout_rate = 0.3
def create_model() :
model = models.Sequential()
model.add(EfficientNetB4(include_top = False, weights = None,
input_shape =(TARGET_SIZE, TARGET_SIZE, 3)))
model.add(layers.GlobalAveragePooling2D())
model.add(Dropout(dropout_rate))
model.add... | Cassava Leaf Disease Classification |
13,427,958 | Xtrain=all_data[:len(train)]
Xtest=all_data[len(train):]
Xtrain.info()
tmpXtrain = copy.deepcopy(Xtrain)
tmpXtest = copy.deepcopy(Xtest)
for cmb in itertools.combinations_with_replacement(list(Xtrain.keys()), 2):
tmpXtrain["-".join(cmb)] = Xtrain[cmb[0]] * Xtrain[cmb[1]]
tmpXtest["-".join(cmb)] = Xtest[cmb[0]] * Xtes... | print('Our EfficientNet CNN has %d layers' %len(model.layers)) | Cassava Leaf Disease Classification |
13,427,958 | !pip install optuna<train_model> | model.load_weights('.. /input/cassava-leaf-keras-efficientnetb-baseline/best_baseline_model.h5' ) | Cassava Leaf Disease Classification |
13,427,958 | X_train, X_test, y_train, y_test = train_test_split(tmpXtrain, np.log1p(Y1train), test_size=0.1)
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
lgbm_params = {
'objective': 'regression',
'metric': 'rmse',
}
best_params, tuning_history = dict() , list()
booster_c... | model_save = ModelCheckpoint('./EffNetB4_best_weights.h5',
save_best_only = True,
save_weights_only = True,
monitor = 'val_loss',
mode = 'min', verbose = 1)
early_stop = EarlyStopping(monitor = 'val_loss', min_delta = 0.001,
patience = 5, mode = 'min', verbose = 1,
restore_best_weights = True)
reduce_lr = ReduceLROnP... | Cassava Leaf Disease Classification |
13,427,958 | X_train, X_test, y_train, y_test = train_test_split(tmpXtrain, np.log1p(Y2train), test_size=0.1)
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
lgbm_params = {
'objective': 'regression',
'metric': 'rmse',
}
best_params, tuning_history = dict() , list()
booster_r... | avg_acc = sum(history.history['acc'])/len(history.history['acc'])
avg_val_acc = sum(history.history['val_acc'])/len(history.history['val_acc'])
avg_loss = sum(history.history['loss'])/len(history.history['loss'])
avg_val_loss = sum(history.history['val_loss'])/len(history.history['val_loss'])
print('Training produc... | Cassava Leaf Disease Classification |
13,427,958 | pred_casual = booster_casual.predict(tmpXtest, num_iteration=booster_casual.best_iteration)
pred_casual = np.expm1(pred_casual)
pred_registered = booster_registered.predict(tmpXtest, num_iteration=booster_registered.best_iteration)
pred_registered = np.expm1(pred_registered)
pred = pred_casual + pred_registered
pre... | ss = pd.read_csv(os.path.join(WORK_DIR, "sample_submission.csv"))
ss | Cassava Leaf Disease Classification |
13,427,958 | %matplotlib inline<load_from_csv> | preds = []
for image_id in ss.image_id:
image = Image.open(os.path.join(WORK_DIR, "test_images", image_id))
image = image.resize(( TARGET_SIZE, TARGET_SIZE))
image = np.expand_dims(image, axis = 0)
preds.append(np.argmax(model.predict(image)))
ss['label'] = preds
ss | Cassava Leaf Disease Classification |
13,427,958 | <load_from_csv><EOS> | ss.to_csv('submission.csv', index = False ) | Cassava Leaf Disease Classification |
14,035,136 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<filter> | !pip install --quiet /kaggle/input/kerasapplications
!pip install --quiet /kaggle/input/efficientnet-git | Cassava Leaf Disease Classification |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.