{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Weather Classification for Disaster Risk Reduction with DenseNet-161\n", "[![Open In Studio Lab](https://studiolab.sagemaker.aws/studiolab.svg)](https://studiolab.sagemaker.aws/import/github/aws/studio-lab-examples/blob/main/computer-vision/weather-data/weather-image-classification-pytorch.ipynb)", "\n", "\n Today we are going to work with weather image dataset and build an image classification model with Pytorch. We hope this can be useful in responding to natural disasters. \n", "\n", "## Train an image classification model with PyTorch \n", "\n", "PyTorch is an open source machine learning library based on the Torch library, used for applications such as computer vision and natural language processing. Image classification is a fundamental task that attempts to label an entire picture as part of a class. To learn more about image classification, see a course on computer vision from [MLU[(https://github.com/aws-samples/aws-machine-learning-university-accelerated-cv).\n", "\n", "In our case, we'll be training an ML model to classifiy visual weather data into types of weather.\n", "- \n", "\n", "To train a custom image classification, you may train from scratch or fine tune a pre-trained model. Fine tuning is especially common to make your training more efficient and get better result in a shorter time. The model we will work herewith is DenseNet-161. The densenet-161 model is one of the DenseNet group of models designed to perform image classification. If you are intersted in the model, read the [arxiv paper](https://arxiv.org/abs/1608.06993) to learn more about it.\n", "\n", "## The MWD Dataset\n", "The Multi-class Weather Dataset(MWD) for Image Classification is a valuable dataset used in the research paper entitled “Multi-class weather recognition from the still image using heterogeneous ensemble method” published by Ajayi, Gbeminiyi from University of South Africa - Science Campus. It cotains 4 classes of images: Sunrise, Shine, Rain, Cloudy. Each class has 200-350 pictures.\n", " \n", "## Steps in this notebook\n", "In this notebook, we will go through a few steps, they are:\n", "1. install packages\n", "2. prepare dataset\n", "3. dataset normalization\n", "4. load the DenseNet-161\n", "5. train(fine-tune) a model \n", "6. test a model \n", "7. show predictions graphs and confusion matrix\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Install packages" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we'll install python packages for later use\n", "\n", "- **torch**: [PyTorch](https://pytorch.org/) is a Python package that provides two high-level features: (1) Tensor computation (like NumPy) with strong GPU acceleration (2) Deep neural networks built on a tape-based autograd system\n", "\n", "- **torchvision**: The torchvision package consists of popular datasets, model architectures, and common image transformations for computer vision.\n", "\n", "- **matplotlib**: Matplotlib is a plotting library for the Python programming language and its numerical mathematics extension NumPy." ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "tags": [] }, "outputs": [], "source": [ "%pip install torch \n", "%pip install torchvision\n", "%pip install matplotlib\n", "%pip install sklearn" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torchvision" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'cuda:0'" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Use is_available() to determine if your system supports CUDA.\n", "if torch.cuda.is_available(): \n", " device = \"cuda:0\" \n", "else: \n", " device = \"cpu\" \n", "device" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Prepare dataset\n", "\n", "Next, you will need to download a Kaggle dataset manually from their [dataset download page](https://www.kaggle.com/pratik2901/multiclass-weather-dataset). Once you've done that, create a new folder here called \"dataset\", and upload those files into that directory. \n", "\n", "Please make sure your files looks like this once you are done.\n", "```\n", " -- root\n", " -- notebook\n", " -- dataset\n", " -- cloudy\n", " -- rainy\n", " -- shine\n", " -- sunrise\n", "```" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "tags": [] }, "outputs": [], "source": [ "!unzip \"archive.zip\"" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "!mv \"Multi-class Weather Dataset\" dataset" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.1 Reading Image Data" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "def GetImagesFromFolder(PATH, Class_Folder, ext):\n", " \"\"\"\n", " This module can be used to import image data. \n", " It also takes care of resizing the images to 240x240 Pixels.\n", " So that the images can be used for DenseNet-161 model fine-tuning.\n", " \"\"\"\n", " images = [Image.open(file).convert('RGB').resize((240,240),resample=Image.LANCZOS) for e in ext for file in glob.glob(PATH+Class_Folder+'/*.' + e)] \n", " print(f\"Found {len(images)} in folder {Class_Folder}\")\n", " np.random.shuffle(images)\n", " return images,np.array([Class_Folder for i in range(len(images))])" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Cloudy', 'Rain', 'Shine', 'Sunrise']\n", "Found 300 in folder Cloudy\n", "Found 215 in folder Rain\n", "Found 253 in folder Shine\n", "Found 357 in folder Sunrise\n", "LabelEncoder()\n", "{'Cloudy': 0, 'Rain': 1, 'Shine': 2, 'Sunrise': 3}\n" ] } ], "source": [ "\"\"\"\n", "Read the image from given path.\n", "1. use LabelEncoder from sklearn to encode the folder names and the class number.\n", "2. for each folder, add image and labels to ALL_IMAGES and ALL_LABEL.\n", "\"\"\"\n", "import os\n", "import datetime\n", "import glob\n", "from PIL import Image\n", "import numpy as np\n", "from sklearn.preprocessing import LabelEncoder\n", "\n", "DATA_PATH = './dataset/'\n", "FOLDERS = os.listdir(DATA_PATH)\n", "print(FOLDERS)\n", "\n", "### if you found the folder contains other subfolder than the iamge classes, \n", "### remove them before calling the label encoder\n", "#if os.path.exists(\"./dataset/.ipynb_checkpoints/\"):\n", "# os.rmdir(\"./dataset/.ipynb_checkpoints/\")\n", "\n", "ALL_IMAGES,ALL_LABELS = [],[]\n", "images_population ={}\n", "ext = ['jpg','jpeg']\n", "\n", "for Class_Folder in FOLDERS:\n", " IMAGES,LABELS = GetImagesFromFolder(DATA_PATH,Class_Folder,ext)\n", " images_population[Class_Folder] = LABELS.shape[0]\n", " ALL_IMAGES.extend(IMAGES)\n", " ALL_LABELS.extend(LABELS)\n", " \n", "le = LabelEncoder().fit(FOLDERS)\n", "print(le)\n", "le_name_mapping = dict(zip(le.classes_, le.transform(le.classes_)))\n", "print(le_name_mapping)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.2 Splitting Dataset to different splits for Training, Testing & Validation:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "TRAIN_IMAGES, X_val_test, TRAIN_LABELS, y_val_test = train_test_split(ALL_IMAGES, ALL_LABELS, test_size=0.20, random_state=42,stratify=ALL_LABELS)\n", "VAL_IMAGES, TEST_IMAGES, VAL_LABELS, TEST_LABELS = train_test_split(X_val_test, y_val_test, test_size=0.50, random_state=42,stratify=y_val_test)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2.3 Create WeatherDataset class:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "from torch.utils.data import DataLoader,Dataset\n", "\n", "class WeatherDataset(Dataset):\n", " def __init__(self, ImageData, Target, transform=None):\n", " self.ImageData = ImageData\n", " self.Target = torch.LongTensor(le.transform(Target))\n", " self.transform = transform\n", "\n", " def __getitem__(self, index):\n", " x = self.ImageData[index]\n", " y = self.Target[index]\n", " if self.transform:\n", " x = Image.fromarray(np.uint8(np.array(self.ImageData[index]))) # Memory Efficient way\n", " x = self.transform(x)\n", " return x, y\n", " def __len__(self):\n", " return len(self.ImageData)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Dataset Normalization\n", "This is a utility function to find out MEAN & STD for Normalizing Training Data" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data loader has:\n", "*\tmean= [0.4626341462135315, 0.45685869455337524, 0.44986945390701294]\n", "*\tstd= [0.26855456829071045, 0.24882826209068298, 0.2918025255203247]\n" ] } ], "source": [ "# SOURCE: https://youtu.be/y6IEcEBRZks\n", "from torchvision import transforms\n", "def get_mean_std(loader):\n", " # VAR[X] = E[X**2] - E[X]**2\n", " channels_sum, channels_squared_sum, num_batches = 0,0,0\n", " \n", " for data,_ in loader:\n", " channels_sum +=torch.mean(data,dim=[0,2,3])\n", " channels_squared_sum += torch.mean(data**2, dim=[0,2,3])\n", " num_batches += 1\n", " \n", " mean = channels_sum/num_batches\n", " std = (channels_squared_sum/num_batches - mean**2)**0.5\n", " return mean,std\n", "\n", "batch_size = 4\n", "transform = transforms.Compose([transforms.Resize((230,230)),transforms.ToTensor()])\n", "dataset = WeatherDataset(TRAIN_IMAGES, TRAIN_LABELS, transform=transform)\n", "loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, num_workers=4)\n", "mean,std = get_mean_std(loader)\n", "print(f\"Data loader has:\\n*\\tmean= {mean.tolist()}\\n*\\tstd= {std.tolist()}\")" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Size for Dataset:\n", "\t* Train: 900\n", "\t* Valid: 112\n", "\t* Test: 113\n" ] } ], "source": [ "transform = {'train':transforms.Compose([transforms.ColorJitter(),\n", " transforms.RandomRotation(30),\n", " transforms.Resize((240,240)),\n", " transforms.RandomResizedCrop(230),\n", " transforms.RandomHorizontalFlip(),\n", " transforms.ToTensor(),\n", " transforms.Normalize(mean=mean,std=std),#transforms.RandomErasing()\n", " ]),\n", " 'val':transforms.Compose([transforms.Resize((230,230)),\n", " transforms.ToTensor()]),\n", " \n", " 'test':transforms.Compose([transforms.Resize((230,230)),\n", " transforms.ToTensor()])}\n", "\n", "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", "\n", "\n", "batch_size = {'train':8, 'val':8,'test':8}\n", "\n", "dataset_classes = ['Cloudy','Rain','Shine','Sunrise']\n", "\n", "\n", "image_datasets = {'train': WeatherDataset(TRAIN_IMAGES, TRAIN_LABELS, transform=transform['train']),\n", " 'val': WeatherDataset(VAL_IMAGES, VAL_LABELS, transform=transform['val']),\n", " 'test': WeatherDataset(TEST_IMAGES, TEST_LABELS, transform=transform['test'])\n", "}\n", "\n", "\n", "dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val','test']}\n", "\n", "dataloaders = {indx: torch.utils.data.DataLoader(image_datasets[indx], batch_size=batch_size[indx], num_workers=4, pin_memory=True, shuffle=True)\n", " for indx in batch_size.keys()}\n", "\n", "print(\"Size for Dataset:\\n\\t* Train: %d\\n\\t* Valid: %d\\n\\t* Test: %d\"%(dataset_sizes['train'],dataset_sizes['val'],dataset_sizes['test']))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Load the DenseNet-161" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "import gc\n", "def train_model(model, criterion, optimizer, model_checkpoint=0, early_stop = 10, num_epochs=5):\n", " start_time = datetime.datetime.now().replace(microsecond=0)\n", " model = model.to(device)\n", "\n", " # number of epochs to train the model\n", " valid_loss_min = np.Inf # track change in validation loss\n", " early_stop_cnt = 0\n", " last_epoch_loss = np.Inf\n", " globaliter = 0\n", "\n", " final_loss = np.Inf\n", "\n", " for epoch in range(1, num_epochs+1):\n", " globaliter+=1\n", " # keep track of training and validation loss\n", " train_loss = 0.0\n", " valid_loss = 0.0\n", "\n", "\n", " ###################\n", " # train the model #\n", " ###################\n", " model.train()\n", " train_corrects = 0\n", "\n", " for data, target in dataloaders['train']:\n", " data, target = data.to(device), target.to(device)\n", " # clear the gradients of all optimized variables\n", " optimizer.zero_grad()\n", " # forward pass: compute predicted outputs by passing inputs to the model\n", " output = model(data)\n", " _, preds = torch.max(output, 1)\n", " # calculate the batch loss\n", " loss = criterion(output, target)\n", " # backward pass: compute gradient of the loss with respect to model parameters\n", " loss.backward()\n", " # perform a single optimization step (parameter update)\n", " optimizer.step()\n", " # update training loss\n", " train_loss += loss.item()*data.size(0)\n", " train_corrects += torch.sum(preds == target.data)\n", "\n", " train_loss = train_loss/len(dataloaders['train'].dataset)\n", " train_acc = (train_corrects.double()*100)/len(dataloaders['train'].dataset)\n", "\n", " ###################### \n", " # validate the model #\n", " ######################\n", " model.eval()\n", " val_corrects = 0\n", " for data, target in dataloaders['val']:\n", " data, target = data.to(device), target.to(device)\n", " # forward pass: compute predicted outputs by passing inputs to the model\n", " output = model(data)\n", " _, preds = torch.max(output, 1)\n", " # calculate the batch loss\n", " loss = criterion(output, target)\n", " # update average validation loss\n", " valid_loss += loss.item()*data.size(0)\n", " val_corrects += torch.sum(preds == target.data)\n", "\n", " # calculate average losses\n", " valid_loss = valid_loss/len(dataloaders['val'].dataset)\n", " valid_acc = (val_corrects.double()*100)/len(dataloaders['val'].dataset)\n", "\n", " # print training/validation statistics \n", " print('Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}'.format(epoch, train_loss, valid_loss))\n", " print('\\t\\tTraining Acc: {:.3f} \\t\\tValidation Acc: {:.3f}'.format(train_acc, valid_acc))\n", "\n", " # save model if validation loss has decreased\n", " if valid_loss <= valid_loss_min:\n", " print('\\t\\tValidation loss decreased ({:.6f} --> {:.6f}).'.format(valid_loss_min,valid_loss))\n", " if model_checkpoint != 0:\n", " torch.save(model.state_dict(), '/kaggle/working/model.pt'.format(train_acc, valid_acc))\n", " print('Model Saved: /kaggle/working/model.pt'.format(train_acc, valid_acc))\n", " valid_loss_min = valid_loss\n", " elif valid_loss == np.nan:\n", " print(\"Model Loss: NAN\")\n", "\n", " if (last_epoch_loss < valid_loss) and last_epoch_loss != np.Inf:\n", " early_stop_cnt +=1\n", " if early_stop_cnt == early_stop:\n", " print('-'*50+\"\\nEarly Stopping Hit\\n\"+'-'*50)\n", " break\n", " else:\n", " print('-'*50+f\"\\n\\t\\tEarly Stopping Step: {early_stop_cnt}/{early_stop}\\n\"+'-'*50)\n", " else:\n", " early_stop_cnt = 0\n", " last_epoch_loss = valid_loss\n", "\n", " print(f\"Training Completed with best model having loss of {round(valid_loss_min,6)}\")\n", " del data,target\n", " gc.collect()\n", " end_time = datetime.datetime.now().replace(microsecond=0)\n", " print(f'Time Taken: {end_time-start_time}')\n", " return model" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Downloading: \"https://download.pytorch.org/models/densenet161-8d451a50.pth\" to /home/studio-lab-user/.cache/torch/hub/checkpoints/densenet161-8d451a50.pth\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "86bb95182df048398c5e1ef9cd8d980a", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0.00/110M [00:00 0.638324).\n", "Training Completed with best model having loss of 0.638324\n", "Time Taken: 0:00:08\n" ] } ], "source": [ "print('Training of Model:')\n", "model_ft = train_model(model_ft, criterion, optimizer_ft,model_checkpoint=0,num_epochs=epochs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 6. test a model\n", "Visualize the predict label and the truth label" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from sklearn.metrics import confusion_matrix\n", "import itertools\n", "\n", "def visualize_model(model, num_images=6):\n", " was_training = model.training\n", " model.eval()\n", " images_so_far = 0\n", " fig = plt.figure(figsize = (num_images,num_images))\n", "\n", " with torch.no_grad():\n", " for i, (inputs, labels) in enumerate(dataloaders['test']):\n", " inputs = inputs.to(device)\n", " labels = labels.to(device)\n", "\n", " outputs = model(inputs)\n", " _, preds = torch.max(outputs, 1)\n", "\n", " for j in range(inputs.size()[0]):\n", " images_so_far += 1\n", " ax = plt.subplot(num_images//2, 2, images_so_far)\n", " ax.axis('off')\n", " ax.set_title(f'Predicted: {dataset_classes[preds[j]]} | Actual: {dataset_classes[labels[j]]}')\n", " imshow(inputs.cpu().data[j])\n", "\n", " if images_so_far == num_images:\n", " model.train(mode=was_training)\n", " return\n", " model.train(mode=was_training)\n", " if device.type == 'cuda':\n", " inputs = inputs.cpu()\n", " labels = labels.cpu()\n", " gc.collect()" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "def imshow(img):\n", " # Convert from tensor image\n", " plt.imshow(np.transpose(img, (1,2,0)))\n", " \n", "visualize_model(model_ft, num_images=14)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 7. Show predictions graphs and confusion matrix\n", "- [Confusion matrix](https://en.wikipedia.org/wiki/Confusion_matrix): In the field of machine learning and specifically the problem of statistical classification, a confusion matrix, also known as an error matrix, is a specific table layout that allows visualization of the performance of an algorithm, typically a supervised learning one." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues):\n", " if normalize:\n", " cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n", " print(\"Normalized confusion matrix\")\n", " else:\n", " print('Confusion matrix, without normalization')\n", "\n", " print(cm)\n", " size = len(classes)*2\n", " plt.figure(figsize = (size,size))\n", " plt.imshow(cm, interpolation='nearest', cmap=cmap)\n", " plt.title(title,fontsize=20)\n", " tick_marks = np.arange(len(classes))\n", " plt.xticks(tick_marks, classes,fontsize=12)\n", " plt.yticks(tick_marks, classes,fontsize=12)\n", "\n", " fmt = '.2f' if normalize else 'd'\n", " thresh = cm.max() / 2.\n", " for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n", " plt.text(j, i, format(cm[i, j], fmt), horizontalalignment=\"center\", color=\"white\" if cm[i, j] > thresh else \"black\")\n", "\n", " plt.tight_layout()\n", " plt.ylabel('True label',fontsize=16)\n", " plt.xlabel('Predicted label',fontsize=16)\n", "\n", "def model_verification(loader,batch_size,model,n_classes=5):\n", " classes = list(le.inverse_transform([i for i in range(n_classes)]))\n", " prediction_list,label_list = [],[]\n", " with torch.no_grad():\n", " for inputs, labels in loader:\n", " inputs = inputs.to(device)\n", " labels = labels.to(device)\n", " outputs = model(inputs)\n", " predicted = outputs.argmax(dim=1).detach()\n", " prediction_list.extend(predicted.tolist())\n", " label_list.extend(labels.tolist())\n", " \n", " cm = confusion_matrix(prediction_list,label_list)\n", " plot_confusion_matrix(cm, classes)\n", " if device.type == 'cuda':\n", " inputs = inputs.cpu()\n", " labels = labels.cpu()\n", " gc.collect()" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Confusion matrix, without normalization\n", "[[ 7 0 0 0]\n", " [ 0 19 0 0]\n", " [21 2 24 0]\n", " [ 2 1 1 35]]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "model_verification(dataloaders['val'],batch_size['val'],model_ft,n_classes=4)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "instance_type": "ml.g4dn.xlarge", "kernelspec": { "display_name": ".conda-default:Python", "language": "python", "name": "conda-env-.conda-default-py" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7" } }, "nbformat": 4, "nbformat_minor": 4 }