kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
13,284,813 | preds = rf.predict(valid[feats] )<compute_test_metric> | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head() | Cassava Leaf Disease Classification |
13,284,813 | mean_squared_error(valid['rentals'],preds)**(1/2 )<predict_on_test> | train.label.value_counts() | Cassava Leaf Disease Classification |
13,284,813 | preds_test = rf.predict(test[feats] )<prepare_output> | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head() | Cassava Leaf Disease Classification |
13,284,813 | test['count'] = np.exp(preds_test)-1
<save_to_csv> | 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 |
13,284,813 | test[['datetime','count']].to_csv('rf2.csv', index=False)
<choose_model_class> | 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 |
13,284,813 | rf = RandomForestRegressor(random_state=42, n_estimators=100,n_jobs=-1,oob_score=True )<train_model> | 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 |
13,284,813 | rf.fit(df[feats],df['rentals'])
rf.oob_score_<prepare_output> | 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 |
13,284,813 | preds = rf.oob_prediction_<compute_test_metric> | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
13,284,813 | <predict_on_test><EOS> | test.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
13,212,123 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<prepare_output> | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
| Cassava Leaf Disease Classification |
13,212,123 | test['count'] = np.exp(preds_test)-1
<save_to_csv> | 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 |
13,212,123 | test[['datetime','count']].to_csv('rf3.csv', index=False)
<compute_test_metric> | CFG = {
'fold_num': 10,
'seed': 719,
'model_arch': 'tf_efficientnet_b3_ns',
'img_size': 512,
'epochs': 32,
'train_bs': 28,
'valid_bs': 32,
'lr': 1e-4,
'num_workers': 4,
'accum_iter': 1,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 3,
'used_epochs': [6,7,8,9],
'weights': [1,1,1,1]
} | Cassava Leaf Disease Classification |
13,212,123 | def cv(df, test, feats, y_name, k=5):
score, preds, fis = [], [], []
chunk = df.shape[0] // k
for i in range(k):
if i+1 < k:
valid = df.iloc[i*chunk:(i+1)*chunk]
train = df.iloc[:i*chunk].append(df.iloc[(i+1)*chunk:])
else:
valid: df.iloc[i*chunk:]
train: df.iloc[:i*chunk]
rf = RandomForestRegressor(random_state=42, n... | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head() | Cassava Leaf Disease Classification |
13,212,123 | score, preds, fis = cv(df, test, feats, 'rentals' )<train_model> | train.label.value_counts() | Cassava Leaf Disease Classification |
13,212,123 | pd.Series(score ).mean()
<save_to_csv> | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head() | Cassava Leaf Disease Classification |
13,212,123 | test['count'] = np.exp(pd.DataFrame(preds ).mean())-1
test[['datetime','count']].to_csv('rf4.csv', index=False)
<set_options> | 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 |
13,212,123 | %matplotlib inline<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 |
13,212,123 | train = pd.read_csv(".. /input/bike-sharing-demand/train.csv")
test = pd.read_csv(".. /input/bike-sharing-demand/test.csv")
submit = pd.read_csv('.. /input/bike-sharing-demand/sampleSubmission.csv')
train_weather = pd.read_csv(".. /input/train-weather-last/bike.csv" )<feature_engineering> | 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 |
13,212,123 | data = train.append(test, sort=True)
data.shape
data.reset_index(inplace=True)
data.drop('index',inplace=True,axis=1)
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 : ... | 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 |
13,212,123 | year = pd.get_dummies(data['year'], drop_first=True)
data = data.merge(year, left_index=True, right_index=True)
data.rename(columns={'2012':'year_2012'},
inplace=True)
month = pd.get_dummies(data['month'], drop_first=True)
data = data.merge(month, left_index=True, right_index=True)
data.rename(columns={2:'Feb',
3:... | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
13,212,123 | <sort_values><EOS> | test.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
13,071,149 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<drop_column> | !pip install timm | Cassava Leaf Disease Classification |
13,071,149 | dropFeatures = ['casual',"count","datetime","date","registered","season","weather","year","weekday","month","hour","temp","holiday"]
dataTrain = dataTrain.drop(dropFeatures,axis=1)
dataTest = dataTest.drop(dropFeatures,axis=1 )<drop_column> | set_seed(314 ) | Cassava Leaf Disease Classification |
13,071,149 |
<choose_model_class> | class CutMix(MixUp):
def __init__(self, alpha=1.) : self.distrib = Beta(tensor(alpha), tensor(alpha))
def before_batch(self):
lam = self.distrib.sample().squeeze().to(self.x.device)
shuffle = torch.randperm(self.y.size(0)).to(self.x.device)
self.yb1 = tuple(L(self.yb ).itemgot(shuffle))
nx_dims = len(self.x.size())
... | Cassava Leaf Disease Classification |
13,071,149 | lrmodel = LinearRegression()
lrmodel.fit(dataTrain, yLabelsLog)
r_sq = lrmodel.score(dataTrain, yLabelsLog)
print('coefficient of determination(r_square)= ', r_sq)
print('intercept = ', lrmodel.intercept_)
print('slope = ', lrmodel.coef_)
<train_model> | df = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
df['image_id'] = df['image_id'].apply(lambda x: f'train_images/{x}')
df.head()
idx2label = json.load(open('.. /input/cassava-leaf-disease-classification/label_num_to_disease_map.json'))
df.label = df.label.map(str ).map(idx2label)
idxs = L.r... | Cassava Leaf Disease Classification |
13,071,149 | dataTrain_ols = sm.add_constant(dataTrain)
olsmodel = sm.OLS(yLabelsLog, dataTrain_ols ).fit()
print(olsmodel.summary() )<compute_train_metric> | dls = ImageDataLoaders.from_df(df, path='.. /input/cassava-leaf-disease-classification/', bs=64,
item_tfms=Resize(320),
valid_col='valid',
batch_tfms=aug_transforms(size=300, mult=2, max_zoom=2.))
dls.show_batch() | Cassava Leaf Disease Classification |
13,071,149 | transformer = PolynomialFeatures(degree=2, include_bias=False)
dataTrain_poly = transformer.fit_transform(dataTrain)
prmodel = LinearRegression().fit(dataTrain_poly, yLabelsLog)
r_sq = prmodel.score(dataTrain_poly, yLabelsLog)
print('coefficient of determination(r_square)= ', r_sq)
print('intercept = ', prmodel.in... | model = timm.create_model('tf_efficientnet_b3_ns', pretrained=False ) | Cassava Leaf Disease Classification |
13,071,149 | predsTest = lrmodel.predict(X= dataTest)
submission = pd.DataFrame({
"datetime": datetimecol,
"count": [max(0, x)for x in np.exp(predsTest)]
})
submission.to_csv('bike_predictions_LR.csv', index=False )<save_to_csv> | model.load_state_dict(torch.load('.. /input/timm-pretrained-efficientnet/efficientnet/tf_efficientnet_b3_ns-9d44bf68.pth')) | Cassava Leaf Disease Classification |
13,071,149 | dataTest_poly = transformer.fit_transform(dataTest)
predsTest_poly = prmodel.predict(X= dataTest_poly)
submission = pd.DataFrame({
"datetime": datetimecol,
"count": [max(0, x)for x in np.exp(predsTest_poly)]
})
submission.to_csv('bike_predictions_PR.csv', index=False )<load_from_csv> | model.classifier = nn.Linear(model.classifier.in_features, len(dls.vocab))
learn = Learner(dls, model, loss_func=LabelSmoothingCrossEntropy() , splitter=methodcaller('parameters'), metrics=accuracy, model_dir='/kaggle/working/models')
learn.to_fp16()
learn.freeze() | Cassava Leaf Disease Classification |
13,071,149 | train = pd.read_csv(".. /input/train.csv")
<load_from_csv> | learn.lr_find() | Cassava Leaf Disease Classification |
13,071,149 | test = pd.read_csv(".. /input/test.csv" )<load_from_csv> | learn.fine_tune(16, base_lr=8.3e-4, cbs=[ShowGraphCallback() , CutMix() ] ) | Cassava Leaf Disease Classification |
13,071,149 | test = pd.read_csv(".. /input/test.csv", parse_dates = ["datetime"])
train = pd.read_csv(".. /input/train.csv", parse_dates = ["datetime"] )<feature_engineering> | dl = dls.valid
a1, target = learn.tta(dl=dl, n=16)
pred_1 = a1.argmax(dim=1)
(pred_1==target ).to(float ).mean() | Cassava Leaf Disease Classification |
13,071,149 | train["year"] = train["datetime"].dt.year
train["hour"] = train["datetime"].dt.hour
train["dayofweek"] = train["datetime"].dt.dayofweek
test["year"] = test["datetime"].dt.year
test["hour"] = test["datetime"].dt.hour
test["dayofweek"] = test["datetime"].dt.dayofweek
<prepare_x_and_y> | sample_df = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
sample_df.head()
sample_copy = sample_df.copy()
sample_copy['image_id'] = sample_copy['image_id'].apply(lambda x: f'test_images/{x}')
test_dl = learn.dls.test_dl(sample_copy)
test_dl.show_batch() | Cassava Leaf Disease Classification |
13,071,149 | y_train = train["count"]
y_train = np.log1p(y_train )<drop_column> | a, _ = learn.tta(dl=test_dl, n=16)
pred = a.argmax(dim=1 ).numpy()
sample_df['label'] = pred | Cassava Leaf Disease Classification |
13,071,149 | <import_modules><EOS> | sample_df.to_csv('submission.csv',index=False ) | Cassava Leaf Disease Classification |
13,030,363 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<import_modules> | Cassava Leaf Disease Classification | |
13,030,363 | from sklearn.ensemble import RandomForestRegressor<choose_model_class> | !pip install.. /input/ramki-cassava-weights/vision_transformer_pytorch-1.0.2-py2.py3-none-any.whl | Cassava Leaf Disease Classification |
13,030,363 | rf = RandomForestRegressor(n_estimators=100 )<train_model> | TRAINING = False
WEIGHT_FILE = '.. /input/ramki-cassava-weights/fold-4-weight-at-epoch-4-acc-0.95957.pth' | Cassava Leaf Disease Classification |
13,030,363 | rf.fit(train,y_train )<predict_on_test> | import numpy as np
import pandas as pd
import os
from PIL import Image, ImageFilter
import cv2
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from torch.optim import *
from sklearn.metrics import roc_auc_score
from s... | Cassava Leaf Disease Classification |
13,030,363 | preds = rf.predict(test )<load_from_csv> | from albumentations.pytorch import ToTensorV2
from albumentations import Rotate
import albumentations as A
| Cassava Leaf Disease Classification |
13,030,363 | submission=pd.read_csv(".. /input/sampleSubmission.csv" )<prepare_output> | device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
device | Cassava Leaf Disease Classification |
13,030,363 | submission["count"] = np.expm1(preds )<save_to_csv> | if torch.cuda.is_available() :
print(torch.cuda.device_count() ) | Cassava Leaf Disease Classification |
13,030,363 | submission.to_csv("allrf.csv", index=False )<import_modules> | logs='logs/all-vti-tta-fold-' | Cassava Leaf Disease Classification |
13,030,363 | import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns<load_from_csv> | SEED = 2286
N_FOLDS = 5
N_EPOCHS = 10
BATCH_SIZE = 16
IMG_SIZE = 384
LR = 1e-4
NUM_CLASSES = 5
OPTM_STEP = 1
TTA=5
EVAL_TTA_EVERY=5
| Cassava Leaf Disease Classification |
13,030,363 | sample=pd.read_csv('.. /input/sampleSubmission.csv')
train_df=pd.read_csv('.. /input/train.csv')
test_df=pd.read_csv('.. /input/test.csv' )<count_unique_values> | def seed_everything(seed):
random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available() :
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = True
seed_everything(SEED ) | Cassava Leaf Disease Classification |
13,030,363 | train_df.nunique()<count_unique_values> | base_path = '.. /input/cassava-leaf-disease-classification/'
| Cassava Leaf Disease Classification |
13,030,363 | test_df.nunique()<count_missing_values> | train_path =base_path + 'train_images/'
test_path = base_path + 'test_images/'
train_csv = pd.read_csv(base_path + 'train.csv')
sample = pd.read_csv(base_path + 'sample_submission.csv' ) | Cassava Leaf Disease Classification |
13,030,363 | train_df.isnull().sum()<groupby> | train_csv_disease = train_csv.label.map({0:"Cassava Bacterial Blight(CBB)",
1:"Cassava Brown Streak Disease(CBSD)",
2:"Cassava Green Mottle(CGM)",
3:"Cassava Mosaic Disease(CMD)",
4:"Healthy"})
diseases = train_csv_disease.value_counts() | Cassava Leaf Disease Classification |
13,030,363 | season_df=train_df.groupby('season' )<define_variables> | class CasavaDataset(Dataset):
def __init__(self, dataframe, transforms=None, test=False):
self.df = dataframe
self.transforms = transforms
self.test = test
def __len__(self):
return len(self.df)
def __getitem__(self, idx):
label = self.df.iloc[idx].label
p = self.df.iloc[idx].image_id
if self.test == False:
p_path = t... | Cassava Leaf Disease Classification |
13,030,363 | cat_feat=['season','weather','holiday','workingday']
cont_feat=['temp','atemp','humidity','windspeed']
count_feats=['casual','registered','count']<feature_engineering> | folds = StratifiedKFold(n_splits=N_FOLDS, shuffle=True, random_state=SEED)
| Cassava Leaf Disease Classification |
13,030,363 | hour=[]
day=[]
month=[]
year=[]
for row in train_df['datetime']:
date_hour=row.split()
date=date_hour[0]
hour_row=date_hour[1]
hour.append(hour_row.split(':')[0])
date=date.split('-')
day.append(date[2])
month.append(date[1])
year.append(date[0] )<feature_engineering> | class CassvaModel(nn.Module):
def __init__(self, model_arch='tf_efficientnet_b7_ns', n_class=5, pretrained=False):
super().__init__()
self.model = timm.create_model(model_arch, pretrained=pretrained)
in_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(in_features, n_class)
def forward(se... | Cassava Leaf Disease Classification |
13,030,363 | train_df['hour']=hour
train_df['day']=day
train_df['month']=month
train_df['year']=year<feature_engineering> | def build_model() :
if TRAINING:
model = VisionTransformer.from_pretrained('ViT-B_16', num_classes=5)
print('model created with imagenet weights')
else:
model = VisionTransformer.from_name('ViT-B_16', num_classes=5)
print('model loaded from random weight')
return model.to(device ) | Cassava Leaf Disease Classification |
13,030,363 | hour=[]
day=[]
month=[]
year=[]
for row in test_df['datetime']:
date_hour=row.split()
date=date_hour[0]
hour_row=date_hour[1]
hour.append(hour_row.split(':')[0])
date=date.split('-')
day.append(date[2])
month.append(date[1])
year.append(date[0])
test_df['hour']=hour
test_df['day']=day
test_df['month']=month
test_d... | testset = CasavaDataset(sample, transforms=valid_transforms, test=True)
test_loader = DataLoader(testset, batch_size=BATCH_SIZE, shuffle=False, num_workers=1 ) | Cassava Leaf Disease Classification |
13,030,363 | datetime=['hour','day','month','year']
for time in datetime:
train_df[time]=train_df[time].astype(int)
test_df[time]=test_df[time].astype(int )<create_dataframe> | class AverageMeter:
def __init__(self):
self.reset()
def reset(self):
self.val = 0
self.avg = 0
self.sum = 0
self.count = 0
def update(self, val, n=1):
self.val = val
self.sum += val * n
self.count += n
self.avg = self.sum / self.count | Cassava Leaf Disease Classification |
13,030,363 | train_df=pd.DataFrame(train_df )<rename_columns> | def train_model(model, epoch, dataloader_train, criterion, optimizer):
model.train()
losses = AverageMeter()
accs = AverageMeter()
tk = tqdm(dataloader_train, total=len(dataloader_train), position=0, leave=True)
optimizer.zero_grad()
for idx,(img, labels)in enumerate(tk):
images, labels = img.to(device), labels.to(dev... | Cassava Leaf Disease Classification |
13,030,363 | train_df.set_index('datetime',inplace=True )<rename_columns> | def tta_model(model, dataloader_tta):
model.eval()
losses = AverageMeter()
accs = AverageMeter()
pred = []
all_labels = []
with torch.no_grad() :
for tta_idx in tqdm(range(TTA)) :
avg_preds = []
for idx,(images, labels)in enumerate(dataloader_tta):
if tta_idx==0:
all_labels.extend(labels.tolist())
images, labels = ima... | Cassava Leaf Disease Classification |
13,030,363 | test_df.set_index('datetime',inplace=True )<drop_column> | X = train_csv.iloc[:,:-1]
y = train_csv.iloc[:,-1:] | Cassava Leaf Disease Classification |
13,030,363 | train_df.drop(columns=['casual','registered'],axis=1,inplace=True )<categorify> | if TRAINING:
for i_fold,(train_idx, valid_idx)in enumerate(folds.split(X,y)) :
print("Fold {}/{}".format(i_fold + 1, N_FOLDS))
train = train_csv.iloc[train_idx]
train.reset_index(drop=True, inplace=True)
valid = train_csv.iloc[valid_idx]
valid.reset_index(drop=True, inplace=True)
unique_labels, nSamples = np.unique(t... | Cassava Leaf Disease Classification |
13,030,363 | weather_df=pd.get_dummies(train_df['weather'],prefix='weather')
yr_df=pd.get_dummies(train_df['year'],prefix='year')
month_df=pd.get_dummies(train_df['month'],prefix='month')
hour_df=pd.get_dummies(train_df['hour'],prefix='hour')
season_df=pd.get_dummies(train_df['season'],prefix='season')
train_df=train_df.join(w... | model = build_model()
model.load_state_dict(torch.load(WEIGHT_FILE, map_location='cuda:0'))
model = model.to(device ) | Cassava Leaf Disease Classification |
13,030,363 | train_df.drop(columns=['season','hour','month','year','weather'],axis=1,inplace=True)
test_df.drop(columns=['season','hour','month','year','weather'],axis=1,inplace=True )<compute_test_metric> | test_pred = []
model.eval()
tta_acc, pred = tta_model(model, test_loader)
pred = pred.argmax(1 ).astype('int')
test_pred.extend(pred)
sample.label = test_pred
sample.to_csv('submission.csv',index=False ) | Cassava Leaf Disease Classification |
13,030,363 | <prepare_x_and_y><EOS> | !cat submission.csv | Cassava Leaf Disease Classification |
13,066,608 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<train_model> | InteractiveShell.ast_node_interactivity = "all"
train = False | Cassava Leaf Disease Classification |
13,066,608 | xgr=xgb.XGBRegressor(learning_rate =0.1, n_estimators=1000, max_depth=9,
min_child_weight=4, gamma=0.125, subsample=1, colsample_bytree=0.8)
xgr.fit(train_df.drop(columns='count',axis=1),train_df['count'])
y_predict=xgr.predict(test_df )<feature_engineering> | fastai.__version__ | Cassava Leaf Disease Classification |
13,066,608 | test_df['count']=np.exp(y_predict )<create_dataframe> | labels = pd.read_csv(path / 'train.csv')
labels["image_id"] = labels["image_id"].apply(
lambda x: f'train_images/{x}')
labels.head() | Cassava Leaf Disease Classification |
13,066,608 | result=pd.DataFrame()<feature_engineering> | dls = ImageDataLoaders.from_df(
labels,
path='.. /input/cassava-leaf-disease-classification/',
bs=64,
fn_col=0,
label_col=1,
seed=42,
valid_pct=0.2,
item_tfms=RandomResizedCrop(512, min_scale=0.75, ratio=(1.,1.)),
batch_tfms=aug_transforms() ,
num_workers=0)
dls.valid_ds.items[:3] | Cassava Leaf Disease Classification |
13,066,608 | result['datetime']=test_df['datetime']
result['count']=test_df['count']<save_to_csv> | learn = cnn_learner(dls, resnet50, metrics=[error_rate, accuracy] ).to_native_fp16() | Cassava Leaf Disease Classification |
13,066,608 | result.to_csv('output.csv',index=False )<load_from_csv> | if train:
learn.fine_tune(10, cbs=[MixUp(0.5)] ) | Cassava Leaf Disease Classification |
13,066,608 | train = pd.read_csv('.. /input/labeledTrainData.tsv',delimiter = '\t')
test = pd.read_csv('.. /input/testData.tsv',delimiter = '\t')
train.shape, test.shape<count_values> | model_name = "resnet50-fine_tune-10_resize-512"
if train:
learn.export(Path(f"{Path(os.getcwd() ).parent}/output/cassava-leaf-disease-classification/{model_name}.pkl"))
else:
learn = load_learner(Path(f"{Path(os.getcwd() ).parent}/input/cassava-modelresnet34fine-tune10pkl/{model_name}.pkl"), cpu=False)
learn = learn.t... | Cassava Leaf Disease Classification |
13,066,608 | print("number of rows for sentiment 1: {}".format(len(train[train.sentiment == 1])))
print("number of rows for sentiment 0: {}".format(len(train[train.sentiment == 0])) )<feature_engineering> | if train:
cleaner = ImageClassifierCleaner(learn)
cleaner | Cassava Leaf Disease Classification |
13,066,608 | train['length'] = train['review'].apply(len)
train.head()<filter> | test_labels = pd.read_csv(path / 'sample_submission.csv')
test_labels["image_id"] = test_labels["image_id"].apply(
lambda x: f'test_images/{x}')
test_labels.head() | Cassava Leaf Disease Classification |
13,066,608 | train[train['length'] == 13708]['review'].iloc[0]<string_transform> | test_predictions = []
for i, r in test_labels.iterrows() :
test_predictions.append(int(learn.predict(f'.. /input/cassava-leaf-disease-classification/{r.image_id}')[0]))
test_predictions[0] | Cassava Leaf Disease Classification |
13,066,608 | <feature_engineering><EOS> | submission = pd.read_csv(path / 'sample_submission.csv')
submission['label'] = test_predictions
submission.head()
submission.to_csv('submission.csv',index=False ) | Cassava Leaf Disease Classification |
14,186,202 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<filter> | tez_path = '.. /input/tez-lib'
effnet_path = '.. /input/efficientnet-pytorch/'
sys.path.append(tez_path)
sys.path.append(effnet_path ) | Cassava Leaf Disease Classification |
14,186,202 | print(train[train['length_clean_review'] == 4]['review'].iloc[0])
print('------After Cleaning------')
print(train[train['length_clean_review'] == 4]['clean_review'].iloc[0] )<import_modules> | import os
import albumentations
import pandas as pd
import numpy as np
import tez
from tez.datasets import ImageDataset
import torch
import torch.nn as nn
from torch.nn import functional as F
from efficientnet_pytorch import EfficientNet
from tqdm import tqdm | Cassava Leaf Disease Classification |
14,186,202 | from sklearn.feature_extraction.text import CountVectorizer<feature_engineering> | class LeafModel(nn.Module):
def __init__(self, num_classes):
super().__init__()
self.effnet = EfficientNet.from_name("efficientnet-b4")
self.dropout = nn.Dropout(0.2)
self.out = nn.Linear(1792, num_classes)
self.step_scheduler_after = "epoch"
def forward(self, image, targets=None):
batch_size, _, _, _ = image.shape
... | Cassava Leaf Disease Classification |
14,186,202 | bow_transform = CountVectorizer(analyzer=clean_text ).fit(train['review'])
print(len(bow_transform.vocabulary_))<categorify> | test_aug = albumentations.Compose([
albumentations.RandomResizedCrop(512, 512),
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
),
albumentations.RandomBri... | Cassava Leaf Disease Classification |
14,186,202 | review_bow = bow_transform.transform(train['review'] )<train_model> | 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,186,202 | sparsity =(100.0 * review_bow.nnz /(review_bow.shape[0] * review_bow.shape[1]))
print('sparsity: {}'.format(sparsity))<categorify> | train_dfx = pd.read_csv(".. /input/cassava-leaf-disease-classification/train.csv")
model0 = LeafModel(num_classes=train_dfx.label.nunique())
model0.load(".. /input/single-model/efficentnet_model_fold0.bin", device='cuda' ) | Cassava Leaf Disease Classification |
14,186,202 | tfidf_transformer = TfidfTransformer().fit(review_bow)
tfidf1 = tfidf_transformer.transform(bow1)
print(tfidf1 )<feature_engineering> | model_list = [model0]
def run_inference(model):
final_preds = None
for j in range(20):
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.vstack(( temp_preds, p))
if final_preds is None:
final_preds = temp_preds
el... | Cassava Leaf Disease Classification |
14,186,202 | <categorify><EOS> | dfx.label = run_inference(model_list[0])
dfx.to_csv("submission.csv", index=False ) | Cassava Leaf Disease Classification |
14,165,951 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<split> | ! pip install '.. /input/efficientnet-pytorch/EfficientNet-PyTorch/EfficientNet-PyTorch-master/'
| Cassava Leaf Disease Classification |
14,165,951 | X_train, X_test, y_train, y_test = train_test_split(train['review'], train['sentiment'], test_size=0.22, random_state=101)
len(X_train), len(X_test), len(X_train)+ len(X_test )<compute_test_metric> | import os
import gc
import cv2
import time
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import albumentations as A
from efficientnet_pytorch import EfficientNet | Cassava Leaf Disease Classification |
14,165,951 | def pred(predicted,compare):
cm = pd.crosstab(compare,predicted)
TN = cm.iloc[0,0]
FN = cm.iloc[1,0]
TP = cm.iloc[1,1]
FP = cm.iloc[0,1]
print("CONFUSION MATRIX ------->> ")
print(cm)
print()
print('Classification paradox :------->>')
print('Accuracy :- ', round(((TP+TN)*100)/(TP+TN+FP+FN),2))
print()
print('False ... | device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
effnet_b1=EfficientNet.from_pretrained('efficientnet-b1',
weights_path='.. /input/efficientnet-pytorch/efficientnet-b1-dbc7070a.pth',
include_top=True ) | Cassava Leaf Disease Classification |
14,165,951 | pipeline = Pipeline([
('bow', CountVectorizer(analyzer=clean_text)) ,
('tfidf', TfidfTransformer()),
('classifier', LogisticRegression(random_state=101)) ,
])
pipeline.fit(X_train,y_train)
predictions = pipeline.predict(X_train)
pred(predictions,y_train )<predict_on_test> | CFG = {
"IMG_SIZE": 384,
"BATCH_SIZE": 16,
"IMG_FOLDER": ".. /input/cassava-leaf-disease-classification/train_images",
"EPOCHS": 10,
"NUM_FOLDS": 5,
"device": device
}
print(device ) | Cassava Leaf Disease Classification |
14,165,951 | predictions = pipeline.predict(X_test)
pred(predictions,y_test )<predict_on_test> | class CassavaModel(nn.Module):
def __init__(self, _backbone):
super(CassavaModel, self ).__init__()
self._backbone=_backbone
self._backbone._fc=nn.Linear(in_features=_backbone._fc.in_features,
out_features=5,
bias=True)
def forward(self, x):
x=self._backbone(x)
return x | Cassava Leaf Disease Classification |
14,165,951 | pipeline = Pipeline([
('bow', CountVectorizer(analyzer=clean_text)) ,
('tfidf', TfidfTransformer()),
('classifier', MultinomialNB()),
])
pipeline.fit(X_train,y_train)
predictions = pipeline.predict(X_train)
pred(predictions,y_train )<predict_on_test> | models=[]
for model_name in os.listdir('.. /input/enesemble'):
model_path=os.path.join('.. /input/enesemble', model_name)
model=CassavaModel(effnet_b1)
model.load_state_dict(torch.load(model_path))
model=model.to(device)
models.append(model ) | Cassava Leaf Disease Classification |
14,165,951 | predictions = pipeline.predict(X_test)
pred(predictions,y_test )<train_model> | test_folder=".. /input/cassava-leaf-disease-classification/test_images"
class TestDataset(torch.utils.data.Dataset):
def __init__(self, augmentation):
self.test_images=os.listdir(test_folder)
self.augmentation=augmentation
def __len__(self):
return len(self.test_images)
def __getitem__(self, idx):
image_id=self.test_... | Cassava Leaf Disease Classification |
14,165,951 | pipeline = Pipeline([
('bow', CountVectorizer(analyzer=clean_text)) ,
('tfidf', TfidfTransformer()),
('classifier', RandomForestClassifier(n_estimators = 500)) ,
])
pipeline.fit(X_train,y_train)
predictions = pipeline.predict(X_train)
pred(predictions,y_train )<predict_on_test> | val_transform=val_augmentation()
pred=nn.Softmax(dim=1)
test_dataset=TestDataset(val_transform)
test_dataloader=torch.utils.data.DataLoader(test_dataset,
shuffle=False,
pin_memory=True,
batch_size=16,
num_workers=4)
submission_data=[]
with torch.no_grad() :
for(image_id,img)in test_dataloader:
img=img.to(device)
yo... | Cassava Leaf Disease Classification |
14,165,951 | <predict_on_test><EOS> | submission_df=pd.DataFrame.from_dict(submission_data)
submission_df.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
14,038,024 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<save_to_csv> | ! pip install.. /input/tta-torch | Cassava Leaf Disease Classification |
14,038,024 | output.to_csv("output.csv", index=False, quoting=3 )<define_variables> | ! pip install.. /input/timm-package/timm-0.1.26-py3-none-any.whl | Cassava Leaf Disease Classification |
14,038,024 | data = pd.read_csv('/kaggle/input/train_labels.csv')
train_path = '/kaggle/input/train/'
test_path = '/kaggle/input/test/'
data['label'].value_counts()<split> | import torch
import torchvision
import skimage.io as io
import os
import numpy as np
from PIL import Image
import torch.nn as nn
import pandas as pd
import pickle
import pytorch_lightning as pl
import timm
import ttach as tta | Cassava Leaf Disease Classification |
14,038,024 | def readImage(path):
bgr_img = cv2.imread(path)
b,g,r = cv2.split(bgr_img)
rgb_img = cv2.merge([r,g,b])
return rgb_img<define_variables> | class CassavaNet(nn.Module):
def __init__(self):
super().__init__()
backbone = timm.create_model(TIMM_MODEL, pretrained=True)
n_features = backbone.fc.in_features
self.backbone = nn.Sequential(*backbone.children())[:-2]
self.classifier = nn.Linear(n_features, 5)
self.pool = nn.AdaptiveAvgPool2d(( 1, 1))
def forward_f... | Cassava Leaf Disease Classification |
14,038,024 | ORIGINAL_SIZE = 96
CROP_SIZE = 90
RANDOM_ROTATION = 3
RANDOM_SHIFT = 2
RANDOM_BRIGHTNESS = 7
RANDOM_CONTRAST = 5
RANDOM_90_DEG_TURN = 1
def readCroppedImage(path, augmentations = True):
bgr_img = cv2.imread(path)
b,g,r = cv2.split(bgr_img)
rgb_img = cv2.merge([r,g,b])
if(not augmentations):
return rgb_img / 255
rota... | model_0 = load_checkpoint('.. /input/cassavamodels2/ckpt_resnet50-512-0.pth')
model_0 = model_0.cuda()
model_1 = load_checkpoint('.. /input/cassavamodels2/ckpt_resnet50-512-0-snap.pth')
model_1 = model_1.cuda()
model_2 = load_checkpoint('.. /input/cassavamodels2/ckpt_resnet50-512-0.pth')
model_2 = model_2.cuda() | Cassava Leaf Disease Classification |
14,038,024 | train_df = data.set_index('id')
train_names = train_df.index.values
train_labels = np.asarray(train_df['label'].values)
tr_n, tr_idx, val_n, val_idx = train_test_split(train_names, range(len(train_names)) , test_size=0.1, stratify=train_labels, random_state=123 )<define_variables> | tta_transforms = tta.Compose(
[
tta.HorizontalFlip() ,
tta.Rotate90(angles=[0, 180]),
tta.Multiply(factors=[0.95, 1, 1.05])
]
)
merge_mode = 'mean'
tta_model_0 = tta.ClassificationTTAWrapper(model_0, tta_transforms, merge_mode = merge_mode)
tta_model_1 = tta.ClassificationTTAWrapper(model_1, tta_transforms, merge_... | Cassava Leaf Disease Classification |
14,038,024 | arch = densenet169
BATCH_SIZE = 128
sz = CROP_SIZE
MODEL_PATH = str(arch ).split() [1]<create_dataframe> | database_base_path = '.. /input/cassava-leaf-disease-classification/'
n_classes = 5
files_path = f'{database_base_path}test_images/'
test_size = len(os.listdir(files_path))
test_preds = np.zeros(( test_size, n_classes))
loader = torchvision.transforms.Compose([
torchvision.transforms.Resize(512),
torchvision.transforms... | Cassava Leaf Disease Classification |
14,038,024 | train_dict = {'name': train_path + train_names, 'label': train_labels}
df = pd.DataFrame(data=train_dict)
test_names = []
for f in os.listdir(test_path):
test_names.append(test_path + f)
df_test = pd.DataFrame(np.asarray(test_names), columns=['name'] )<data_type_conversions> | test_preds = ensembled_prediction(tta_model_0, tta_model_1, tta_model_2, files_path)
test_preds | Cassava Leaf Disease Classification |
14,038,024 | <categorify><EOS> | submission = pd.DataFrame({'image_id': image_names, 'label': test_preds})
submission.to_csv('submission.csv', index=False)
display(submission.head() ) | Cassava Leaf Disease Classification |
14,309,110 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<choose_model_class> | package_path = '.. /input/vision-transformer-pytorch/VisionTransformer-Pytorch'
sys.path.append(package_path)
| Cassava Leaf Disease Classification |
14,309,110 | def getLearner() :
return create_cnn(imgDataBunch, arch, pretrained=True, path='.', metrics=accuracy, ps=0.5, callback_fns=ShowGraph)
learner = getLearner()<choose_model_class> | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
sys.path.append(package_path ) | Cassava Leaf Disease Classification |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.