kernel_id int64 24.2k 23.3M | prompt stringlengths 8 1.85M | completetion stringlengths 1 182k | comp_name stringlengths 5 57 |
|---|---|---|---|
14,035,136 | train_withoutliers = train[np.abs(train['count']-train['count'].mean())<=(3*train['count'].std())]<concatenate> | 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 = 0
seed_everything(seed)
warnings.filterwarnings('ignore' ) | Cassava Leaf Disease Classification |
14,035,136 | data = pd.concat([train_withoutliers,test],ignore_index=True)
data.shape<data_type_conversions> | try:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
print(f'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.distr... | Cassava Leaf Disease Classification |
14,035,136 | data['datetime'] = pd.to_datetime(data['datetime'],errors='coerce')
data['year'] = data['datetime'].apply(lambda x: x.year )<data_type_conversions> | BATCH_SIZE = 8 * REPLICAS
HEIGHT = 512
WIDTH = 512
CHANNELS = 3
N_CLASSES = 5
TTA_STEPS = 8 | Cassava Leaf Disease Classification |
14,035,136 | data['hour'] = data['datetime'].apply(lambda x: x.hour ).astype('int' )<feature_engineering> | def data_augment(image, label):
p_spatial = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_rotate = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_pixel_1 = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_pixel_2 = tf.random.uniform([], 0, 1.0, dtype=tf.float32)
p_pixel_3 = tf.random.uniform([], 0, 1.0, dty... | Cassava Leaf Disease Classification |
14,035,136 | data['weekday'] = data['datetime'].apply(lambda x: x.weekday())
data['date'] = data['datetime'].apply(lambda x: x.date())
data[["date","weekday"]].head()
data['month'] = data['datetime'].apply(lambda x: x.month )<groupby> | def get_name(file_path):
parts = tf.strings.split(file_path, os.path.sep)
name = parts[-1]
return name
def decode_image(image_data):
image = tf.image.decode_jpeg(image_data, channels=3)
image = tf.cast(image, tf.float32)/ 255.0
return image
def center_crop(image):
image = tf.reshape(image, [600, 800, CHANNELS])
h, w... | Cassava Leaf Disease Classification |
14,035,136 | workingday_df=data[data['workingday']==1]
nworkingday_df=data[data['workingday']==0]
workingday_df = workingday_df.groupby(['hour'], as_index=True ).agg({'casual':'mean',
'registered':'mean',
'count':'mean'})
nworkingday_df = nworkingday_df.groupby(['hour'], as_index=True ).agg({'casual':'mean',
'registered':'mean',
'... | model_path_list = glob.glob('/kaggle/input/cassava-leaf-disease-training-with-tpu-v2-pods/*.h5')
model_path_list.sort()
print('Models to predict:')
print(*model_path_list, sep='
' ) | Cassava Leaf Disease Classification |
14,035,136 | df1=data[data['windspeed']>40]
df2=df1[df1["count"]>170]<groupby> | def model_fn(input_shape, N_CLASSES):
inputs = L.Input(shape=input_shape, name='input_image')
base_model = efn.EfficientNetB4(input_tensor=inputs,
include_top=False,
weights=None,
pooling='avg')
x = L.Dropout (.5 )(base_model.output)
output = L.Dense(N_CLASSES, activation='softmax', name='output' )(x)
model = Model... | Cassava Leaf Disease Classification |
14,035,136 | data[data['count'].notnull() ].groupby(['season','year'])[['casual','registered']].sum()<categorify> | files_path = f'{database_base_path}test_images/'
test_size = len(os.listdir(files_path))
test_preds = np.zeros(( test_size, N_CLASSES))
for model_path in model_path_list:
print(model_path)
K.clear_session()
model.load_weights(model_path)
if TTA_STEPS > 0:
test_ds = get_dataset(files_path, tta=True ).repeat()
ct_steps... | Cassava Leaf Disease Classification |
14,035,136 | <concatenate><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 |
13,953,114 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<prepare_x_and_y> | Cassava_dir = ".. /input/cassava-leaf-disease-classification/" | Cassava Leaf Disease Classification |
13,953,114 | dataTrain = data[pd.notnull(data['count'])]
dataTest= data[~pd.notnull(data['count'])].sort_values(by=['datetime'])
datetimecol = dataTest['datetime']
yLabels = dataTrain['count']
yLabels_log = np.log(yLabels+1)
<drop_column> | model = keras.models.load_model('.. /input/cassava-baseline-weights/best_weights.h5' ) | Cassava Leaf Disease Classification |
13,953,114 | dropFeatures = ['casual' , 'count' , 'datetime' , 'registered' , 'date' ,
'windspeed' , 'atemp' ,'season','weather','month','year']
dataTrain = dataTrain.drop(dropFeatures,axis=1)
dataTest = dataTest.drop(dropFeatures,axis=1 )<import_modules> | sub = pd.DataFrame(columns=['image_id','label'] ) | Cassava Leaf Disease Classification |
13,953,114 | from sklearn.model_selection import train_test_split<import_modules> | def predict_on_batch(test_list, wpath=Cassava_dir, target_size=(380,380)) :
input_batch=[]
for IMAGE_ID in test_list:
image = tf.keras.preprocessing.image.load_img(os.path.join(wpath, "test_images",IMAGE_ID),
grayscale=False,
color_mode="rgb",
target_size=target_size,
interpolation="nearest")
input_arr = keras.preproc... | Cassava Leaf Disease Classification |
13,953,114 | from sklearn.model_selection import train_test_split<split> | TEST_DIR = '.. /input/cassava-leaf-disease-classification/test_images/'
test_images = os.listdir(TEST_DIR)
N = len(test_images)
if N == 1:
BATCH_SIZE = 1
else:
BATCH_SIZE = 16 | Cassava Leaf Disease Classification |
13,953,114 | X_train, X_valid, y_train, y_valid = train_test_split(dataTrain,
yLabels_log, test_size=0.1, random_state=42)
<import_modules> | for batch_index in range(math.ceil(N/BATCH_SIZE)) :
if batch_index*BATCH_SIZE+BATCH_SIZE < N:
test_X = predict_on_batch(test_images[batch_index*BATCH_SIZE:batch_index*BATCH_SIZE+BATCH_SIZE])
predictions = model.predict(test_X ).argmax(axis = 1)
sub_batch = pd.DataFrame({'image_id':test_images[batch_index*BATCH_SIZE:b... | Cassava Leaf Disease Classification |
13,953,114 | from sklearn.ensemble import RandomForestRegressor<import_modules> | sub['label'] = sub['label'].astype('int64')
sub | Cassava Leaf Disease Classification |
13,953,114 | <save_to_csv><EOS> | sub.to_csv('submission.csv', index = False ) | Cassava Leaf Disease Classification |
13,953,970 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<create_dataframe> | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
| Cassava Leaf Disease Classification |
13,953,970 | rf_dict={'count':rfModel.feature_importances_.round(3)}
pd.DataFrame(rf_dict,X_train.columns )<import_modules> | 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,953,970 | import pandas as pd
import seaborn as sns
import numpy as np
import datetime
from sklearn.ensemble import RandomForestRegressor
from sklearn import preprocessing<load_from_csv> | CFG = {
'fold_num': 5,
'seed': 719,
'model_arch': 'tf_efficientnet_b4_ns',
'img_size': 512,
'epochs': 10,
'train_bs': 32,
'valid_bs': 32,
'lr': 1e-4,
'num_workers': 4,
'accum_iter': 1,
'verbose_step': 1,
'device': 'cuda:0',
'tta': 3,
'used_epochs': [6,7,8,9],
'weights': [1,1,1,1]
} | Cassava Leaf Disease Classification |
13,953,970 | train = pd.read_csv('/kaggle/input/bike-sharing-demand/train.csv')
test = pd.read_csv('/kaggle/input/bike-sharing-demand/test.csv')
data = train.append(test, sort=False )<feature_engineering> | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head() | Cassava Leaf Disease Classification |
13,953,970 | data['datetime'] = data['datetime'].astype('datetime64[ns]')
data['Day'] = pd.DatetimeIndex(data['datetime'] ).day
data['Month'] = pd.DatetimeIndex(data['datetime'] ).month
data['Year'] = pd.DatetimeIndex(data['datetime'] ).year
data['Hour'] = pd.DatetimeIndex(data['datetime'] ).hour
data['weekday'] = pd.DatetimeIndex... | train.label.value_counts() | Cassava Leaf Disease Classification |
13,953,970 | df=data.drop(['registered','casual','atemp','Day','season'],axis=1 )<normalization> | submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
submission.head() | Cassava Leaf Disease Classification |
13,953,970 | lb = preprocessing.LabelBinarizer()
df.Year = lb.fit_transform(df.Year)
cont=['temp','humidity','windspeed']
feat=df[cont]
minmax_scale = preprocessing.MinMaxScaler().fit(feat.values)
df[cont] = minmax_scale.transform(feat.values )<categorify> | 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,953,970 | categ=['holiday','weather','Month','Year','Hour','weekday','workingday']
for var in categ:
df[var] = df[var].astype("category")
df = pd.get_dummies(data=df, columns=['holiday','weather','workingday','Year'])
df.head()<sort_values> | 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,953,970 | df_train = df[pd.notnull(df['count'])].sort_values(by=['datetime'])
df_test = df[~pd.notnull(df['count'])].sort_values(by=['datetime'] )<drop_column> | 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,953,970 | df_train=df_train.drop(['datetime'],axis=1)
test=df_test.drop(['datetime','count'],axis=1 )<feature_engineering> | 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,953,970 | df_train['count'] = np.log1p(df_train['count'] )<prepare_x_and_y> | test['label'] = np.argmax(tst_preds, axis=1)
test.head() | Cassava Leaf Disease Classification |
13,953,970 | <split><EOS> | test.to_csv('submission.csv', index=False ) | Cassava Leaf Disease Classification |
13,837,878 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<compute_test_metric> | import numpy as np
import pandas as pd
import os
from fastai.vision.all import *
| Cassava Leaf Disease Classification |
13,837,878 | print('RMSLE:', np.sqrt(metrics.mean_squared_log_error(np.expm1(y_test), np.expm1(pred))))<compute_train_metric> | cassavaPath = '.. /input/cassava-leaf-disease-classification/'
cassavaOutputPath = './'
cassavaModelPath = '.. /input/cassavleafdiseaseclassificationpretrained/'
df = pd.read_csv(cassavaPath+'train.csv')
df['label'] = df['label'].astype(str)
df.head() | Cassava Leaf Disease Classification |
13,837,878 | gbm = GradientBoostingRegressor(n_estimators=2000,alpha=0.01)
gbm.fit(X_train,y_train)
preds = gbm.predict(X_test)
print('RMSLE:', np.sqrt(metrics.mean_squared_log_error(np.expm1(y_test), np.expm1(preds))))<compute_test_metric> | df['label'].value_counts() | Cassava Leaf Disease Classification |
13,837,878 | algo_gbm = gbm.predict(X_test)
algo_rf = rfr.predict(X_test)
algo_mean =np.expm1(algo_gbm)*0.9 + np.expm1(algo_rf)*0.1
print('RMSLE:', np.sqrt(metrics.mean_squared_log_error(np.expm1(y_test), algo_mean)) )<predict_on_test> | dls = dblock.dataloaders(df ) | Cassava Leaf Disease Classification |
13,837,878 | algo_gbm_tst = gbm.predict(test)
algo_rf_tst = rfr.predict(test)
algo_mean_tst =np.expm1(algo_gbm_tst)*0.9 + np.expm1(algo_rf_tst)*0.1<prepare_output> | dls.show_batch(nrows=3, ncols=3 ) | Cassava Leaf Disease Classification |
13,837,878 | submission = pd.DataFrame({'datetime':df_test['datetime'],'count':algo_mean_tst})
submission.head()<save_to_csv> | Cassava Leaf Disease Classification | |
13,837,878 | submission.to_csv('Submission.csv',index=False )<load_from_csv> | Cassava Leaf Disease Classification | |
13,837,878 | train=pd.read_csv("/kaggle/input/bike-sharing-demand/train.csv")
train.head(10 )<load_from_csv> | learn = load_learner(cassavaModelPath+'CassavaDiseaseModelResnet34.pkl')
learn.export(cassavaOutputPath+'CassavaDiseaseModelResnet34.pkl')
learn = load_learner(cassavaOutputPath+'CassavaDiseaseModelResnet34.pkl' ) | Cassava Leaf Disease Classification |
13,837,878 | test=pd.read_csv("/kaggle/input/bike-sharing-demand/test.csv")
test.head(10 )<data_type_conversions> | print('Computing predictions...')
test_files = get_image_files(cassavaPath+'test_images')
predictions_ResultArray = [None for tempX in range(len(test_files)) ]
predictions_InputArray = [None for tempX in range(len(test_files)) ]
for test_idx in range(0,len(test_files)) :
predictions = learn.predict(test_files[test_id... | Cassava Leaf Disease Classification |
13,837,878 | <feature_engineering><EOS> | df_sample_submission = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')
df_exact_submission = pd.read_csv(cassavaOutputPath+'submission.csv')
print(df_sample_submission.compare(df_exact_submission))
print(df_sample_submission.equals(df_exact_submission))
| Cassava Leaf Disease Classification |
13,602,318 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<prepare_x_and_y> | path = Path('.. /input/cassava-leaf-disease-classification' ) | Cassava Leaf Disease Classification |
13,602,318 | y=np.log(train["count"])
y.head()<drop_column> | train_df = pd.read_csv(path/'train.csv')
train_df = train_df[~train_df['image_id'].isin(['1562043567.jpg', '3551135685.jpg', '2252529694.jpg'])]
train_df.head() | Cassava Leaf Disease Classification |
13,602,318 | train=train.drop(["datetime","casual","registered","count"],1)
train.head()<drop_column> | item_tfms = RandomResizedCrop(460, min_scale=0.75, ratio=(1.,1.))
batch_tfms = [*aug_transforms(size=384, max_warp=0), Normalize.from_stats(*imagenet_stats)]
bs=16 | Cassava Leaf Disease Classification |
13,602,318 | test=test.drop(["datetime"],1)
test.head()<train_model> | def get_x(r):
return path/'train_images'/r['image_id']
def get_y(r):
return r['label'] | Cassava Leaf Disease Classification |
13,602,318 | lgb=LGBMRegressor()
lgb.fit(train,y )<load_from_csv> | pets = DataBlock(blocks=(ImageBlock, CategoryBlock),
get_x=get_x,
get_y=get_y,
splitter=RandomSplitter(0.2, seed=42),
item_tfms=item_tfms,
batch_tfms=batch_tfms)
dataloader = pets.dataloaders(train_df, bs=bs ) | Cassava Leaf Disease Classification |
13,602,318 | sub=pd.read_csv("/kaggle/input/bike-sharing-demand/sampleSubmission.csv")
sub.head()<predict_on_test> | dataloader.show_batch() | Cassava Leaf Disease Classification |
13,602,318 | sub["count"]=np.exp(lgb.predict(test))
sub.head()<save_to_csv> | learn = cnn_learner(dataloader, resnet50,
loss_func = LabelSmoothingCrossEntropy() ,
cbs=[MixUp() ],
metrics=[error_rate,accuracy])
learn.fine_tune(8,freeze_epochs = 2,base_lr=1e-2 ) | Cassava Leaf Disease Classification |
13,602,318 | sub.to_csv("20190921.csv",index=False )<set_options> | learn = learn.to_native_fp32() | Cassava Leaf Disease Classification |
13,602,318 | %matplotlib inline
mpl.rcParams['axes.unicode_minus']=False
warnings.filterwarnings('ignore' )<load_from_csv> | sample_df = pd.read_csv(path/'sample_submission.csv')
sample_df.head() | Cassava Leaf Disease Classification |
13,602,318 | train=pd.read_csv(".. /input/bike-sharing-demand/train.csv", parse_dates=["datetime"])
train.shape
<load_from_csv> | test_data_path = sample_df['image_id'].apply(lambda x: path/'test_images'/x)
tst_dl = learn.dls.test_dl(test_data_path)
predictions = learn.tta(dl = tst_dl, n=10)
| Cassava Leaf Disease Classification |
13,602,318 | test=pd.read_csv(".. /input/bike-sharing-demand/test.csv", parse_dates=["datetime"])
test.shape<feature_engineering> | sample_df['label'] = np.argmax(predictions[0],axis=1)
sample_df | Cassava Leaf Disease Classification |
13,602,318 | <feature_engineering><EOS> | sample_df.to_csv('submission.csv',index=False ) | Cassava Leaf Disease Classification |
13,435,582 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<feature_engineering> | !pip install.. /input/faiss-163/faiss_cpu-1.6.3-cp37-cp37m-manylinux2010_x86_64.whl | Cassava Leaf Disease Classification |
13,435,582 |
<predict_on_test> | try:
!cd.. /input; python -m cassavacodes.Cassava.retrieval.extract.run --config-file./configs/extract_r50_gq_infer.py --load-path.. /input/wwwwww/weight_epoch_13.pth --log-dir /kaggle/working/log -device 0
except:
pass | Cassava Leaf Disease Classification |
13,435,582 | def predict_windspeed(data):
dataWind0 = data.loc[data['windspeed'] == 0]
dataWindNot0 = data.loc[data['windspeed'] != 0]
wCol = ["season", "weather", "humidity", "month", "temp", "year", "atemp"]
dataWindNot0["windspeed"] = dataWindNot0["windspeed"].astype("str")
rfModel_wind = RandomForestClassifier()
rfModel_wind.f... | np.load('/kaggle/working/features/extract_r50_gq_infer/gallery_targets.npy' ) | Cassava Leaf Disease Classification |
13,435,582 | categorical_feature_names = ["season","holiday","workingday","weather",
"dayofweek","month","year","hour"]
for var in categorical_feature_names:
train[var] = train[var].astype("category")
test[var] = test[var].astype("category" )<define_variables> | gallery_features = np.load('.. /input/gallery/gallery_features.npy')
gallery_targets = np.load('.. /input/gallery/gallery_targets.npy')
query_features = np.load('/kaggle/working/features/extract_r50_gq_infer/gallery_features.npy')
query_names = np.load('/kaggle/working/features/extract_r50_gq_infer/gallery_names.npy... | Cassava Leaf Disease Classification |
13,435,582 | feature_names = ["season", "weather", "temp", "atemp", "humidity", "windspeed",
"year", "hour", "dayofweek", "holiday", "workingday"]
feature_names<compute_test_metric> | index = faiss.IndexFlatL2(gallery_features.shape[1])
index.add(gallery_features)
k=3
D, I = index.search(gallery_features, k)
print(gallery_targets[I[-10:]])
outliers = []
for i, indices in enumerate(I):
if gallery_targets[indices[0]] != gallery_targets[indices[1]]:
outliers.append(i)
print(gallery_features.shape)... | Cassava Leaf Disease Classification |
13,435,582 | def rmsle(predicted_values, actual_values):
predicted_values = np.array(predicted_values)
actual_values = np.array(actual_values)
log_predict = np.log(predicted_values + 1)
log_actual = np.log(actual_values + 1)
difference = log_predict - log_actual
difference = np.square(difference)
mean_difference = difference.m... | index = faiss.IndexFlatL2(gallery_features.shape[1])
index.add(gallery_features)
k=1
D, I = index.search(query_features, k)
f = open('submission.csv', 'w')
f.write('image_id,label
')
for fn, i in zip(query_names, I):
fn = fn.split('/')[-1]
pred = gallery_targets[i][0]
f.write(fn + ',' + str(pred)+ '
')
f.close() | Cassava Leaf Disease Classification |
13,435,582 | <choose_model_class><EOS> | f = open('submission.csv', 'r')
print(f.readlines())
f.close() | Cassava Leaf Disease Classification |
13,468,551 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<compute_train_metric> | package_paths = [
'.. /input/pytorch-image-models/pytorch-image-models-master',
'.. /input/image-fmix/FMix-master'
]
for pth in package_paths:
sys.path.append(pth)
| Cassava Leaf Disease Classification |
13,468,551 | %time score = cross_val_score(model, X_train, y_train, cv=k_fold, scoring=rmsle_scorer)
score = score.mean()
print("Score= {0:.5f}".format(score))<train_model> | 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,468,551 | model.fit(X_train, y_train )<predict_on_test> | CFG = {
'fold_num': 5,
'seed': 719,
'model_arch': 'tf_efficientnet_b4_ns',
'img_size': 512,
'epochs': 10,
'train_bs': 16,
'valid_bs': 32,
'T_0': 10,
'lr': 1e-4,
'min_lr': 1e-6,
'weight_decay':1e-6,
'num_workers': 4,
'accum_iter': 2,
'verbose_step': 1,
'device': 'cuda:0'
} | Cassava Leaf Disease Classification |
13,468,551 | predictions = model.predict(X_test)
print(predictions.shape)
predictions[0:10]<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,468,551 | submission = pd.read_csv(".. /input/bike-sharing-demand/sampleSubmission.csv")
submission
submission["count"] = predictions
print(submission.shape)
submission.head()<save_to_csv> | class test_dataset(Dataset):
def __init__(self,transforms=None):
self.transforms = transforms
self.image_name = pd.read_csv('.. /input/cassava-leaf-disease-classification/sample_submission.csv')['image_id']
def __len__(self):
return len(self.image_name)
def __getitem__(self,index):
img_name = self.image_name[index]
im... | Cassava Leaf Disease Classification |
13,468,551 | submission.to_csv("Score_{0:.5f}_sampleSubmission.csv".format(score), index=False )<load_from_csv> | 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,468,551 | train=data=pd.read_csv('/kaggle/input/bike-sharing-demand/train.csv')
test=pd.read_csv('/kaggle/input/bike-sharing-demand/test.csv')
submission=pd.read_csv('/kaggle/input/bike-sharing-demand/sampleSubmission.csv')
print(train.shape, test.shape, submission.shape )<count_missing_values> | if __name__ == '__main__':
test_transforms = get_valid_transforms()
test_ds = test_dataset(test_transforms)
test_dataloader = torch.utils.data.DataLoader(
test_ds,
batch_size=1,
num_workers=0,
shuffle=False,
pin_memory=False,
)
device = torch.device('cuda:0')
model = CassvaImgClassifier(model_arch=CFG['model_arch'... | Cassava Leaf Disease Classification |
13,329,699 | all_data.isnull().sum()<feature_engineering> | import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import plotly.express as px
import os
import cv2
from PIL import Image
import keras
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import tensorflow as tf
from tensorflow.keras import models, layer... | Cassava Leaf Disease Classification |
13,329,699 | 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']=all_data['datetime'].dt.day
all_data['hour']=all_data['datetime'].dt.hour
all_data['dayofweek']=all_data['datetime'].dt.dayofweek
all_data=all_data.dro... | input_dir = ".. /input/cassava-leaf-disease-classification"
train_images_path = os.path.join(input_dir,"train_images")
test_images_path = os.path.join(input_dir,'test_images' ) | Cassava Leaf Disease Classification |
13,329,699 | all_data=all_data.drop(columns=['month', 'day'] )<feature_engineering> | train = pd.read_csv('.. /input/cassava-leaf-disease-classification/train.csv')
train.head(10 ) | Cassava Leaf Disease Classification |
13,329,699 | all_data['weekend']=(all_data['dayofweek']==5)|(all_data['dayofweek']==6 )<categorify> | image_list = train['image_id'].to_list()
label_list = train['label'].to_list() | Cassava Leaf Disease Classification |
13,329,699 | season_encoded=pd.get_dummies(all_data['season'], prefix='season_')
all_data=pd.concat(( all_data, season_encoded), axis=1)
all_data=all_data.drop(columns='season' )<categorify> | with open(".. /input/cassava-leaf-disease-classification/label_num_to_disease_map.json")as f:
class_mapping = json.load(f)
class_mapping2 ={int(k):v for k,v in class_mapping.items() }
class_mapping2 | Cassava Leaf Disease Classification |
13,329,699 | weather_encoded=pd.get_dummies(all_data['weather'], prefix='weather_')
all_data=pd.concat(( all_data, weather_encoded), axis=1)
all_data=all_data.drop(columns='weather' )<import_modules> | BATCH_SIZE =8
STEPS_PER_EPOCH = len(train)*0.8 / BATCH_SIZE
VALIDATION_STEPS = len(train)*0.2 / BATCH_SIZE
EPOCHS = 20
TARGET_SIZE = 350 | Cassava Leaf Disease Classification |
13,329,699 | from sklearn.decomposition import PCA<train_model> | train.label = train.label.astype('str')
train_datagen = ImageDataGenerator(validation_split = 0.2,
rotation_range = 45,
zoom_range = 0.3,
horizontal_flip = True,
vertical_flip = True,
fill_mode = 'nearest',
shear_range = 0.1,
height_shift_range = 0.1,
width_shift_range = 0.1,
featurewise_center = True,
featurewise_std... | Cassava Leaf Disease Classification |
13,329,699 | pca=PCA(n_components=1)
pca.fit(all_data[['temp', 'atemp']])
print(f" Variance explained after PCA : {pca.explained_variance_ratio_}" )<drop_column> | img_path = os.path.join('.. /input/cassava-leaf-disease-classification/train_images/1003442061.jpg')
img = image.load_img(img_path, target_size =(TARGET_SIZE, TARGET_SIZE))
img_tensor = image.img_to_array(img)
img_tensor = np.expand_dims(img_tensor, axis = 0)
img_tensor /= 255.
plt.imshow(img_tensor[0])
plt.show() | Cassava Leaf Disease Classification |
13,329,699 | all_data=all_data.drop(columns=['temp', 'atemp'] )<feature_engineering> | generator = train_datagen.flow_from_dataframe(train.iloc[17:18],
directory = os.path.join('.. /input/cassava-leaf-disease-classification/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... | Cassava Leaf Disease Classification |
13,329,699 | all_data.loc[all_data['windspeed']==0, 'windspeed']=all_data['windspeed'].mean()<train_model> | def create_model() :
conv_base = Xception(include_top=False, input_tensor=None,
pooling=None, input_shape=(TARGET_SIZE, TARGET_SIZE, 3), classifier_activation='softmax')
model = conv_base.output
model = layers.GlobalAveragePooling2D()(model)
model = layers.Dense(5, activation = "softmax" )(model)
model = models.Mode... | Cassava Leaf Disease Classification |
13,329,699 | Xtrain=all_data[:len(train)]
Xtest=all_data[len(train):]
Ytrain=np.log(Ytrain+1)
print(Xtrain.shape, Ytrain.shape, Xtest.shape )<import_modules> | model = keras.models.load_model('.. /input/xception-best-weights/Xception_best_weights.h5' ) | Cassava Leaf Disease Classification |
13,329,699 | from lightgbm import LGBMRegressor
from sklearn.model_selection import cross_val_score<choose_model_class> | submission_file = pd.read_csv(os.path.join('.. /input/cassava-leaf-disease-classification/sample_submission.csv'))
submission_file | Cassava Leaf Disease Classification |
13,329,699 | model=LGBMRegressor(boosting_type='gbdt', class_weight=None,
colsample_bytree=0.6746393485503049, importance_type='split',
learning_rate=0.03158974434726661, max_bin=55, max_depth=-1,
min_child_samples=159, min_child_weight=0.001, min_split_gain=0.0,
n_estimators=1458, n_jobs=-1, num_leaves=196, objective=None,
random_... | preds = []
for image_id in submission_file.image_id:
image = Image.open(os.path.join(f'.. /input/cassava-leaf-disease-classification/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)))
submission_file['label'... | Cassava Leaf Disease Classification |
13,329,699 | <load_from_csv><EOS> | submission_file.to_csv('submission.csv', index = False ) | Cassava Leaf Disease Classification |
13,439,440 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<rename_columns> | warnings.simplefilter("ignore")
| Cassava Leaf Disease Classification |
13,439,440 | df.rename(columns={'count':'rentals'},inplace=True )<concatenate> | print('Train images: %d' %len(os.listdir(
os.path.join(WORK_DIR, "train_images")))) | Cassava Leaf Disease Classification |
13,439,440 | df = df.append(test, sort=False )<feature_engineering> | 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,439,440 | for col in ['rentals','registered','casual']:
df[col] = np.log(df[col]+1 )<feature_engineering> | train_labels = pd.read_csv(os.path.join(WORK_DIR, "train.csv"))
train_labels.head() | Cassava Leaf Disease Classification |
13,439,440 | df['year'] = df.datetime.dt.year
df['month'] = df.datetime.dt.month
df['day'] = df.datetime.dt.day
df['dayofweek'] = df.datetime.dt.dayofweek
df['hour'] = df['datetime'].dt.hour<rename_columns> | BATCH_SIZE = 8
STEPS_PER_EPOCH = len(train_labels)*0.7 / BATCH_SIZE
VALIDATION_STEPS = len(train_labels)*0.3 / BATCH_SIZE
EPOCHS = 20
TARGET_SIZE = 512 | Cassava Leaf Disease Classification |
13,439,440 | df.set_index('datetime', inplace=True )<sort_values> | train_labels.label = train_labels.label.astype('str')
train_datagen = ImageDataGenerator(featurewise_center=True,
featurewise_std_normalization=True,
validation_split = 0.3,
preprocessing_function = None,
rotation_range = 45,
zoom_range = 0.3,
horizontal_flip = True,
vertical_flip = True,
fill_mode = 'nearest',
shear_... | Cassava Leaf Disease Classification |
13,439,440 | df.sort_index(inplace=True )<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,439,440 | df['rolling_temp'] = df['temp'].rolling(4, min_periods=1 ).mean()<split> | Cassava Leaf Disease Classification | |
13,439,440 | test = df[df['rentals'].isnull() ]
df = df[~df['rentals'].isnull() ]<define_variables> | def create_model() :
conv_base = EfficientNetB0(include_top = False, weights = None,
input_shape =(TARGET_SIZE, TARGET_SIZE, 3))
model = conv_base.output
model = layers.GlobalAveragePooling2D()(model)
model = layers.Dense(5, activation = "softmax" )(model)
model = models.Model(conv_base.input, model)
model.compile(o... | Cassava Leaf Disease Classification |
13,439,440 | removed_cols = ['rentals', 'casual','registered','datetime']
feats = [c for c in df.columns if c not in removed_cols]<split> | print('Our EfficientNet CNN has %d layers' %len(model.layers)) | Cassava Leaf Disease Classification |
13,439,440 | train, valid = train_test_split(df, random_state=42 )<choose_model_class> | model.load_weights('.. /input/cassava-leaf-disease-models/basic_EfNetB0_imagenet_512.h5' ) | Cassava Leaf Disease Classification |
13,439,440 | rf = RandomForestRegressor(random_state=42, n_estimators=100,n_jobs=-1 )<train_model> | model_save = ModelCheckpoint('./EffNetB0_512_8_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 = Reduc... | Cassava Leaf Disease Classification |
13,439,440 | rf.fit(train[feats],train['rentals'] )<predict_on_test> | model.save('./EffNetB0_512_8.h5' ) | Cassava Leaf Disease Classification |
13,439,440 | preds = rf.predict(valid[feats] )<compute_test_metric> | def all_activations_vis(img, layers = 10):
layer_outputs = [layer.output for layer in model.layers[:layers]]
activation_model = models.Model(inputs = model.input, outputs = layer_outputs)
activations = activation_model.predict(img)
layer_names = []
for layer in model.layers[:layers]:
layer_names.append(layer.name)
i... | Cassava Leaf Disease Classification |
13,439,440 | mean_squared_error(valid['rentals'],preds)**(1/2 )<predict_on_test> | ss = pd.read_csv(os.path.join(WORK_DIR, "sample_submission.csv"))
ss | Cassava Leaf Disease Classification |
13,439,440 | preds_test = rf.predict(test[feats] )<prepare_output> | 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,439,440 | <save_to_csv><EOS> | ss.to_csv('submission.csv', index = False ) | Cassava Leaf Disease Classification |
13,284,813 | <SOS> metric: CategorizationAccuracy Kaggle data source: cassava-leaf-disease-classification<filter> | package_path = '.. /input/vision-transformer-pytorch/VisionTransformer-Pytorch'
sys.path.append(package_path)
| Cassava Leaf Disease Classification |
13,284,813 | train, valid = df[df['day'] <= 15], df.query('day > 15' )<choose_model_class> | package_path = '.. /input/pytorch-image-models/pytorch-image-models-master'
sys.path.append(package_path ) | Cassava Leaf Disease Classification |
13,284,813 | rf = RandomForestRegressor(random_state=42, n_estimators=100,n_jobs=-1 )<train_model> | 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,284,813 | rf.fit(train[feats],train['rentals'] )<predict_on_test> | CFG = {
'fold_num': 10,
'seed': 719,
'model_arch': 'tf_efficientnet_b3_ns',
'img_size': 384,
'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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.