#!/usr/bin/env python
# coding: utf-8

# In[2]:


get_ipython().run_line_magic('reload_ext', 'autoreload')
get_ipython().run_line_magic('autoreload', '')
get_ipython().run_line_magic('matplotlib', 'inline')


# In[3]:


from fastai.vision import *


# ## Data Preprocessing

# In[33]:


get_ipython().system('pwd')


# In[11]:


PATH = Path('PlantVillage/')


# In[19]:


Path.ls_ = lambda x: list(x.iterdir())


# In[35]:


(PATH/'train').ls_()


# In[37]:


bs = 64
size = 32


# In[38]:


src = ImageItemList.from_folder(PATH).split_by_folder()


# In[39]:


def get_data(size, bs, padding_mode='reflection'):
    return(src.label_from_folder()
          .transform(get_transforms(), size=size, padding_mode=padding_mode)
          .databunch(bs=bs)
          .normalize(imagenet_stats))


# In[49]:


# data = (ImageItemList.from_folder(PATH)
#         .split_by_folder()
#         .label_from_folder()
#         .transform(get_transforms(), size=size, padding_mode='reflection')
#         .databunch(bs=bs).normalize(imagenet_stats))


# In[41]:


data = get_data(size=32, bs=64)


# In[46]:


data.c


# In[45]:


data.classes


# In[57]:


data.show_batch(rows=3, figsize=(11, 10))


# In[54]:


data.train_ds


# In[53]:


data.valid_ds


# ## Training : resnet-34

# In[66]:


data.train_ds[0][0].shape


# In[58]:


learn = create_cnn(data, models.resnet34, metrics=error_rate)


# In[59]:


learn.fit_one_cycle(4)


# In[60]:


learn.fit_one_cycle(4)


# In[61]:


learn.fit_one_cycle(3)


# In[62]:


learn.save('stage-1_11-cycles')


# In[63]:


learn.fit_one_cycle(2)


# In[64]:


learn.save('stage-1_13-cycles')


# In[65]:


learn.fit_one_cycle(3)


# In[67]:


learn.save('stage-1_16-cycles')


# In[68]:


interp = ClassificationInterpretation.from_learner(learn)


# In[72]:


interp.plot_top_losses(9, figsize=(20,20))


# ## Unfreezing, Finetuning, Learning Rates

# In[ ]:


learn.load('stage-1_16-cycles')


# In[75]:


learn.unfreeze()


# In[76]:


learn.lr_find()
learn.recorder.plot()


# In[77]:


learn.fit_one_cycle(2, max_lr=slice(1e-5, 3e-4))


# In[91]:


learn.fit_one_cycle(2, max_lr=slice(1e-5, 3e-4))


# In[96]:


learn.save('stage-2-resnet34')


# In[93]:


interp = ClassificationInterpretation.from_learner(learn)


# In[ ]:


interp.plot_confusion_matrix()


# In[95]:


interp.plot_top_losses(4, figsize=(11,10))


# ## Training : resnet50

# In[97]:


learn = create_cnn(data, models.resnet50, metrics=error_rate)


# In[98]:


learn.fit_one_cycle(9, max_lr=slice(1e-3))


# In[99]:


learn.save('stage-1-50')


# In[100]:


learn.unfreeze()


# In[101]:


learn.lr_find()
learn.recorder.plot()


# In[102]:


learn.fit_one_cycle(5, max_lr=slice(5e-6, 5e-5))


# ### resnet-34 was better with an error_rate of `0.038986` , so will switch back

# ## Progressive Resizing. (image size : 32 => 64 => 128 => 256 ) [resnet34]

# #### (32, 32)

# In[108]:


data = get_data(32, bs=bs)


# In[109]:


learn = create_cnn(data, models.resnet34, metrics=error_rate)


# In[125]:


learn.load('stage-1_16-cycles')
learn.data = data
data.train_ds[0][0].shape


# In[126]:


learn.freeze()


# In[127]:


learn.lr_find()
learn.recorder.plot()


# In[128]:


lr = 1e-3/2
learn.fit_one_cycle(4, slice(lr))


# In[129]:


learn.save('stage-1_34-32p')


# In[130]:


learn.unfreeze()
learn.fit_one_cycle(5, slice(1e-6, lr/5))


# In[131]:


learn.save('stage-2_34-32p')


# #### (64, 64)

# In[132]:


data = get_data(64, bs)
learn.data = data


# In[144]:


data.train_ds[0][0].shape


# In[134]:


learn.freeze()
learn.lr_find()
learn.recorder.plot()


# In[135]:


lr = 1e-2
learn.fit_one_cycle(5, slice(lr))


# In[136]:


learn.save('stage-1_34-64p')


# In[142]:


learn.unfreeze()
learn.fit_one_cycle(5,slice(1e-6,lr/10))


# In[143]:


learn.save('stage-2_34-64p')


# #### (128, 128)

# In[ ]:


learn.load('stage-2_34-64p')


# In[150]:


data = get_data(128, bs)
learn.data = data
data.train_ds[0][0].shape


# In[151]:


learn.freeze()
learn.lr_find()
learn.recorder.plot()


# In[152]:


lr = 1e-2/2
learn.fit_one_cycle(5, slice(lr))


# In[153]:


learn.save('stage-1_34-128p')


# In[154]:


learn.unfreeze()
learn.fit_one_cycle(5, slice(1e-6, lr/5))


# In[155]:


learn.save('stage-2_34-128p')


# #### (256, 256) original image size

# In[ ]:


learn.load('stage-2_34-128p')


# In[162]:


data = get_data(256, bs)
learn.data = data
data.train_ds[0][0].shape


# In[169]:


data.show_batch(rows=3, figsize=(11, 10))


# In[163]:


learn.freeze()
learn.lr_find()
learn.recorder.plot()


# In[164]:


lr = 1e-2/2
learn.fit_one_cycle(5, slice(lr))


# In[165]:


learn.save('stage-1_34-256p')


# In[166]:


learn.unfreeze()
learn.fit_one_cycle(5, slice(1e-6, lr/5))


# In[167]:


learn.save('stage-2_34-256p')


# #### ended up with a `resnet-34` model with an accuracy of `99.7365` on PlantVillage dataset in a time of  ~= 1.6 hr

# In[168]:


learn.load('stage-2_34-256p')


# In[ ]: