!pip install jovian --upgrade --quiet

# Uncomment and run the appropriate command for your operating system, if required
# No installation is reqiured on Google Colab / Kaggle notebooks

# Linux / Binder / Windows (No GPU)
# !pip install numpy matplotlib torch==1.7.0+cpu torchvision==0.8.1+cpu torchaudio==0.7.0 -f https://download.pytorch.org/whl/torch_stable.html

# Linux / Windows (GPU)
# pip install torch==1.7.1+cu110 torchvision==0.8.2+cu110 torchaudio==0.7.2 -f https://download.pytorch.org/whl/torch_stable.html
 
# MacOS (NO GPU)
# !pip install numpy matplotlib torch torchvision torchaudio

!pip install opendatasets --upgrade --quiet

import opendatasets as od

import os
import torch
import torchvision
import tarfile
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from torchvision.datasets.utils import download_url
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader
import torchvision.transforms as tt
from torch.utils.data import random_split
from torchvision.utils import make_grid
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline

matplotlib.rcParams['figure.facecolor'] = '#ffffff'

from PIL import Image
from pathlib import Path
import pandas as pd
import math
import cv2
from scipy import signal

import keras
from keras.models import Sequential
from keras.layers import Dense,Conv2D,MaxPool2D,Dropout,BatchNormalization,Flatten,Activation
from keras.preprocessing import image 
from keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
from keras.utils import plot_model
import seaborn as sns

project_name='Bird-Species-Classification'

jovian.commit(project=project_name, environment=None)

from torchvision.datasets.utils import download_url

# Download the 250 Birds Species dataset
dataset_url = 'https://www.kaggle.com/gpiosenka/100-bird-species/download'
od.download(dataset_url)
 

print(os.listdir('.'))

# Look into the 250 Birds Species data directory
data_dir = './100-bird-species'
print(os.listdir(data_dir))

classes = os.listdir(data_dir + "/train")
print(len(classes))
print(classes)

SORA_files = os.listdir(data_dir + "/train/SORA")
print('No. of training examples for Bobolink:', len(SORA_files))
print(SORA_files[:10])

baldEagle_test_files = os.listdir(data_dir + "/test/BALD EAGLE")
print("No. of test examples for ship:", len(baldEagle_test_files))
print(baldEagle_test_files[:5])

for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

for cls in classes:
  train_images = os.listdir(data_dir + '/train/' + cls)
  img_count = len(train_images)
  print("Number of images belonging to {} is {}".format(cls, img_count))

data_dir = './100-bird-species'
train_directory= data_dir + '/train'
test_directory= data_dir + '/test'
val_directory= data_dir + '/valid'

train_datagen=ImageDataGenerator(rescale=1/255)
val_datagen=ImageDataGenerator(rescale=1/255)
test_datagen=ImageDataGenerator(rescale=1/255)

train_generator=train_datagen.flow_from_directory(train_directory,
                                                 target_size=(224,224),
                                                 color_mode='rgb',
                                                  batch_size=256,
                                                 class_mode='sparse')
val_generator=val_datagen.flow_from_directory(val_directory,
                                                 target_size=(224,224),
                                                 batch_size=256,
                                                 color_mode='rgb',
                                                 class_mode='sparse')
test_generator=test_datagen.flow_from_directory(test_directory,
                                                batch_size=256,
                                                 target_size=(224,224),
                                                 color_mode='rgb',
                                                 class_mode='sparse')

num_classes=(len(train_generator.class_indices))
print(num_classes)

train_generator.class_indices

breeds=list(train_generator.class_indices.keys())

x=list(train_generator.classes)

label=[]
for i in range (0, num_classes):
    label.append(x.count(i))

fig_dims = (15, 4)
fig, ax = plt.subplots(figsize=fig_dims)
sns.barplot(x=breeds[:60],y=label[:60])
plt.xticks(rotation=90)
plt.show()

fig_dims = (15, 4)
fig, ax = plt.subplots(figsize=fig_dims)
sns.barplot(x=breeds[61:120],y=label[61:120])
plt.xticks(rotation=90)
plt.show()

fig_dims = (17, 5)
fig, ax = plt.subplots(figsize=fig_dims)
sns.barplot(x=breeds[121:200],y=label[121:200])
plt.xticks(rotation=90)
plt.show()

fig_dims = (10, 4)
fig, ax = plt.subplots(figsize=fig_dims)
sns.barplot(x=breeds[201:],y=label[201:])
plt.xticks(rotation=90)
plt.show()

image1 = np.array(Image.open('./100-bird-species/train/BALD EAGLE/122.jpg'))
plt.imshow(image1, cmap='gray')

image2 = np.array(Image.open('./100-bird-species/train/AFRICAN FIREFINCH/007.jpg'))
plt.imshow(image2, cmap='gray')

image3 = np.array(Image.open('./100-bird-species/train/FLAMINGO/003.jpg'))
plt.imshow(image3, cmap='gray')

np.array(image2).shape

image2_1 = np.array(Image.open('./100-bird-species/train/AFRICAN FIREFINCH/007.jpg'))  
image2_1 = cv2.Canny(image2_1,224,224)
plt.imshow(image2_1)

image_size = 32 # 32

import PIL.Image

# Data transforms (normalization & data augmentation) # tt.RandomCrop(64, padding=4, padding_mode='reflect')
stats = ((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
randomrotate = 10 # 0.175 rad
train_tfms = tt.Compose([tt.Resize((image_size, image_size)),
                         tt.RandomCrop(image_size, padding=4, padding_mode='reflect'),
                         #tt.Resize(image_size),
                         #tt.CenterCrop(image_size), 
                         tt.RandomHorizontalFlip(), 
                         ## tt.RandomRotation(randomrotate, resample=PIL.Image.NEAREST, expand=False, center=None, fill=None), ##
                         # tt.RandomResizedCrop(256, scale=(0.5,0.9), ratio=(1, 1)), 
                         ## tt.ColorJitter(brightness=0.1, contrast=0.1, saturation=0.1, hue=0.1), ##
                         tt.ToTensor(), 
                         tt.Normalize(*stats,inplace=True)])
valid_tfms = tt.Compose([tt.Resize((image_size, image_size)), tt.ToTensor(), tt.Normalize(*stats)])

test_tfms = tt.Compose([tt.Resize((image_size, image_size)), tt.ToTensor(), tt.Normalize(*stats)])

# PyTorch Training & Validation & Test Datasets
train_ds = ImageFolder(data_dir+'/train', train_tfms)
valid_ds = ImageFolder(data_dir+'/valid', valid_tfms)
test_ds = ImageFolder(data_dir+'/test', test_tfms)

batch_size = 256 # 256

# PyTorch Training & Validation & Test Data Loaders
train_dl = DataLoader(train_ds, batch_size, shuffle=True, num_workers=3, pin_memory=True)
valid_dl = DataLoader(valid_ds, batch_size*2, num_workers=3, pin_memory=True)
test_dl = DataLoader(test_ds, batch_size*2, num_workers=3, pin_memory=True)

def denormalize(images, means, stds):
    means = torch.tensor(means).reshape(1, 3, 1, 1)
    stds = torch.tensor(stds).reshape(1, 3, 1, 1)
    return images * stds + means

def show_batch(dl):
    for images, labels in dl:
        fig, ax = plt.subplots(figsize=(12, 12))
        ax.set_xticks([]); ax.set_yticks([])
        denorm_images = denormalize(images, *stats)
        ax.imshow(make_grid(denorm_images[:64], nrow=8).permute(1, 2, 0).clamp(0,1))
        break

show_batch(train_dl)