Wafer_problem.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PyTorch Version:  1.13.0+cu117\n",
      "Torchvision Version:  0.14.0+cu117\n",
      "Is CUDA supported by this system?True\n",
      "CUDA version: 11.7\n",
      "ID of current CUDA device:0\n",
      "Name of current CUDA device:NVIDIA GeForce RTX 2060\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "import torchvision\n",
    "from torchvision.models import vgg16, VGG16_Weights\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from typing import Dict, Final, List, Tuple, NamedTuple, Type\n",
    "from tqdm.auto import tqdm, trange\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sns\n",
    "\n",
    "import cv2\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "import skimage.transform\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "FAIL = 2  # failing die\n",
    "PASS = 1  # passing die\n",
    "NO_DIE = 0  # no die\n",
    "\n",
    "Loss: Type = float\n",
    "Accuracy: Type = float\n",
    "\n",
    "class LossAcc(NamedTuple):\n",
    "    loss: Loss\n",
    "    accuracy: Accuracy\n",
    "\n",
    "class TrainValLossAcc(NamedTuple):\n",
    "    train: List[List[LossAcc]]\n",
    "    val: List[LossAcc]\n",
    "\n",
    "\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "print(\"PyTorch Version: \", torch.__version__)\n",
    "print(\"Torchvision Version: \", torchvision.__version__)\n",
    "print(f\"Is CUDA supported by this system?{torch.cuda.is_available()}\")\n",
    "print(f\"CUDA version: {torch.version.cuda}\")\n",
    "\n",
    "# Storing ID of current CUDA device\n",
    "cuda_id = torch.cuda.current_device()\n",
    "print(f\"ID of current CUDA device:{torch.cuda.current_device()}\")\n",
    "\n",
    "print(f\"Name of current CUDA device:{torch.cuda.get_device_name(cuda_id)}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train: pd.DataFrame = pd.DataFrame.from_records(np.load('wafermap_HW3_train.npy', allow_pickle=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of classes:  5\n",
      "Number of epochs:  20\n",
      "Batch size:  16\n",
      "Test set size: 30.00%\n",
      "Test set sample count:  540\n"
     ]
    }
   ],
   "source": [
    "classes: Final[List[str]] = df_train.failureType.unique()\n",
    "\n",
    "num_classes: Final[int] = len(classes)\n",
    "\n",
    "num_epochs: Final[int] = 20\n",
    "\n",
    "batch_size: Final[int] = 16\n",
    "\n",
    "test_set_size: Final[float] = 0.30\n",
    "\n",
    "test_set_sample_count: Final[int] = int(test_set_size * len(df_train))\n",
    "\n",
    "test_set_actual_size: Final[float] = test_set_sample_count / len(df_train)\n",
    "\n",
    "\n",
    "NO_DIE: Final[int] = 0\n",
    "PASS_DIE: Final[int] = 1\n",
    "FAIL_DIE: Final[int] = 2\n",
    "NUM_DIE_STATES: Final[int] = 3\n",
    "\n",
    "\n",
    "print(\"Number of classes: \", num_classes)\n",
    "print(\"Number of epochs: \", num_epochs)\n",
    "print(\"Batch size: \", batch_size)\n",
    "print(\"Test set size: {:.2f}%\".format(test_set_actual_size * 100))\n",
    "print(\"Test set sample count: \", test_set_sample_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_failure_type(failure_type: str) -> int:\n",
    "    # Create dictionary for converting string to numeric number\n",
    "    string2int: Final[Dict[str, int]] = {'Edge-Loc':0, 'Scratch':1, 'Donut':2, 'Center':3, 'Near-full':4}\n",
    "\n",
    "    return string2int[failure_type]\n",
    "\n",
    "\n",
    "def resize_wafer_map(wafer_map: np.ndarray, output_shape: tuple = (64, 64)) -> np.ndarray:\n",
    "    # Final shape should be (3, 64, 64) for VGG16.\n",
    "    resized = cv2.resize(wafer_map, output_shape, interpolation=cv2.INTER_NEAREST)\n",
    "    ret = np.eye(NUM_DIE_STATES)[resized]\n",
    "    ret = ret.transpose(2, 1, 0)\n",
    "    return ret\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WaferDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, df: pd.DataFrame):\n",
    "        self.df = df\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.df)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        if torch.is_tensor(idx):\n",
    "            idx = idx.tolist()\n",
    "        img = self.df.loc[idx, 'waferMap']\n",
    "        img = resize_wafer_map(img) \n",
    "        img = img.astype('float32')\n",
    "        img = torch.from_numpy(img)\n",
    "        label = self.df.loc[idx, 'failureType']\n",
    "        label = convert_failure_type(label)\n",
    "        label = torch.tensor(label)\n",
    "        return img, label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_dataset = WaferDataset(df_train)\n",
    "train_set_sample_count = len(df_train) - test_set_sample_count\n",
    "train_dataset, val_dataset = random_split(all_dataset, [\n",
    "                                          train_set_sample_count, test_set_sample_count], generator=torch.Generator().manual_seed(9))\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_labels = pd.DataFrame(\n",
    "    Counter(l.item() for _, l in train_dataset).items(),\n",
    "    columns=['failureType', 'count']\n",
    ")\n",
    "val_labels = pd.DataFrame(\n",
    "    Counter(l.item() for _, l in val_dataset).items(),\n",
    "    columns=['failureType', 'count']\n",
    ")\n",
    "train_labels['train'] = True\n",
    "train_labels['ratio'] = train_labels['count'] / (train_labels['count'].sum())\n",
    "val_labels['train'] = False\n",
    "val_labels['ratio'] = val_labels['count'] / (val_labels['count'].sum())\n",
    "labels = pd.concat([train_labels, val_labels])\n",
    "\n",
    "plt.bar(labels[labels['train']]['failureType'],\n",
    "        labels[labels['train']]['ratio'], label='train', alpha=0.7, width=0.25, align='edge')\n",
    "plt.bar(labels[~labels['train']]['failureType'],\n",
    "        labels[~labels['train']]['ratio'], label='val', alpha=0.7, width=0.25)\n",
    "plt.legend()\n",
    "plt.xlabel('failureType')\n",
    "plt.ylabel('Proportion of samples in set')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate(model: nn.Module, val_data: DataLoader) -> LossAcc:\n",
    "    \"\"\"\n",
    "    Returns the loss and accuracy of the model on the validation data.\n",
    "    \"\"\"\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        total_correct = 0.0\n",
    "        totalLoss = 0.0\n",
    "        total = 0\n",
    "        # Iterate through the batches of validation data\n",
    "        for i, batch in enumerate(val_data):\n",
    "            # Get the data and labels from the batch\n",
    "            data, labels = batch\n",
    "            # Get the model's predictions for the data\n",
    "            outputs = model(data)\n",
    "            # Calculate the loss\n",
    "            loss = nn.functional.cross_entropy(outputs, labels)\n",
    "            \n",
    "            # Calculate the accuracy\n",
    "            predicted = outputs.argmax(dim=1)\n",
    "            total += labels.size(0)\n",
    "            total_correct += (predicted == labels).sum().item()\n",
    "            \n",
    "            # Add the loss to the total loss\n",
    "            totalLoss += loss.item()\n",
    "            \n",
    "        # Return the average loss and accuracy over all batches.\n",
    "        return LossAcc(totalLoss/len(val_data), total_correct/total)\n",
    "    \n",
    "def train_batch(model: nn.Module, optimizer: optim.Optimizer,\n",
    "                inputs: torch.Tensor, labels: torch.Tensor) -> LossAcc:\n",
    "    \"\"\"\n",
    "    Trains the model on a single batch of data.\n",
    "    Returns the loss and accuracy of the model on the batch.\n",
    "    \"\"\"\n",
    "    # Set model to training mode\n",
    "    model.train()\n",
    "    # Zero the gradients\n",
    "    optimizer.zero_grad()\n",
    "    # Get the model's predictions for the data\n",
    "    y_pred = model(inputs)\n",
    "    # Calculate the loss\n",
    "    loss = nn.functional.cross_entropy(y_pred, labels)\n",
    "    # Backpropagate the loss\n",
    "    loss.backward()\n",
    "    # Update the model's weights\n",
    "    optimizer.step()\n",
    "    with torch.no_grad():\n",
    "        # Calculate the accuracy\n",
    "        predicted = y_pred.argmax(dim=1)\n",
    "        total = labels.size(0)\n",
    "        total_correct = (predicted == labels).sum().item()\n",
    "        # Return the loss and accuracy\n",
    "        return LossAcc(loss.item(), total_correct/total)\n",
    "\n",
    "def train_epoch(model: nn.Module, optimizer: optim.Optimizer,\n",
    "                train_data: DataLoader) -> List[LossAcc]:\n",
    "    \"\"\"\n",
    "    Trains the model on a single epoch of data.\n",
    "    Returns a list of the loss and accuracy of the model on each batch.\n",
    "    \"\"\"\n",
    "    LossAccList = []\n",
    "    # Iterate through the batches of training data\n",
    "    for batch in train_data:\n",
    "        # Get the data and labels from the batch\n",
    "        data, labels = batch\n",
    "        # Train the model on the batch with `train_batch`\n",
    "        batch_loss_acc = train_batch(model, optimizer, data, labels)\n",
    "        # Add the loss and accuracy to the list\n",
    "        LossAccList.append(batch_loss_acc)\n",
    "    # Return the list of loss and accuracy\n",
    "    return LossAccList\n",
    "\n",
    "def train_loop(model: nn.Module, optimizer: optim.Optimizer,\n",
    "               train_data: DataLoader, val_data: DataLoader,\n",
    "               num_epochs: int = 10) -> TrainValLossAcc:\n",
    "    \"\"\"\n",
    "    Trains the model on the training data for `num_epochs` epochs.\n",
    "    Returns the loss and accuracy of the model on the training and validation data,\n",
    "    taken per-batch in training and per-epoch in validation.\n",
    "    \"\"\"\n",
    "    train_losses = []\n",
    "    val_losses = []\n",
    "    # Iterate through the epochs\n",
    "    for epoch in range(num_epochs):\n",
    "        # Train the model on the epoch with `train_epoch`\n",
    "        train_loss_acc = train_epoch(model, optimizer,train_data)\n",
    "        # Validate the model on the validation data\n",
    "        val_loss_acc = validate(model, val_data)\n",
    "        # Add the loss and accuracy to the list\n",
    "        train_losses.append(train_loss_acc)\n",
    "        val_losses.append(val_loss_acc)\n",
    "    # Return the lists of loss and accuracy\n",
    "    return TrainValLossAcc(train_losses, val_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Optional augmentation module\n",
    "augmentation = nn.Sequential(\n",
    "    torchvision.transforms.RandomHorizontalFlip(p=0.5), # Flips images left-right randomly with 50% probability\n",
    "    torchvision.transforms.RandomVerticalFlip(p=0.5), # Flips images up-down randomly with 50% probability\n",
    "    torchvision.transforms.RandomRotation(90), # Turns images on their sides randomly\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature out shape:  torch.Size([1, 16, 7, 7])  =  784\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Sequential(\n",
       "    (0): RandomHorizontalFlip(p=0.5)\n",
       "    (1): RandomVerticalFlip(p=0.5)\n",
       "    (2): RandomRotation(degrees=[-90.0, 90.0], interpolation=nearest, expand=False, fill=0)\n",
       "  )\n",
       "  (1): Sequential(\n",
       "    (0): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (5): ReLU(inplace=True)\n",
       "    (6): Conv2d(32, 16, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (8): ReLU(inplace=True)\n",
       "  )\n",
       "  (2): Sequential(\n",
       "    (0): Flatten(start_dim=1, end_dim=-1)\n",
       "    (1): Linear(in_features=784, out_features=512, bias=True)\n",
       "    (2): ReLU(inplace=True)\n",
       "    (3): Dropout(p=0.3, inplace=False)\n",
       "    (4): Linear(in_features=512, out_features=5, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_classes = 5\n",
    "\n",
    "features = nn.Sequential(\n",
    "    nn.Conv2d(3, 16, kernel_size=3, padding=1),\n",
    "    nn.MaxPool2d(2),\n",
    "    nn.ReLU(inplace=True),\n",
    "    nn.Conv2d(16, 32, kernel_size=3, padding=1),\n",
    "    nn.MaxPool2d(2),\n",
    "    nn.ReLU(inplace=True),\n",
    "    nn.Conv2d(32, 16, kernel_size=3),\n",
    "    nn.MaxPool2d(2),\n",
    "    nn.ReLU(inplace=True)\n",
    ")\n",
    "\n",
    "num_out_features: int = int(np.prod(features(torch.rand(1, 3, 64, 64)).shape[1:]))\n",
    "print(\"Feature out shape: \", features(torch.rand(1, 3, 64, 64)).shape, \\\n",
    "    ' = ', np.prod(features(torch.rand(1,3,64,64)).shape))\n",
    "\n",
    "classifier = nn.Sequential(\n",
    "    nn.Flatten(),\n",
    "    nn.Linear(in_features=num_out_features, out_features=512),\n",
    "    nn.ReLU(inplace=True),\n",
    "    nn.Dropout(p=0.3, inplace=False),\n",
    "    nn.Linear(in_features=512, out_features=5)\n",
    ")\n",
    "\n",
    "# Instantiate a neural network model\n",
    "model = nn.Sequential(\n",
    "    augmentation,\n",
    "    features,\n",
    "    classifier\n",
    ")\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make the optimizer and call your training functions\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.03, momentum=0.9)\n",
    "history: TrainValLossAcc = train_loop(\n",
    "    model, optimizer, train_dataloader, val_dataloader)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x24d3b1dfd00>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize your training and validation loss\n",
    "training_history = pd.DataFrame.from_records(\n",
    "    [loss for batch_losses in history.train for loss in batch_losses],\n",
    "    columns=LossAcc._fields)\n",
    "training_history['epoch'] = training_history.index / len(train_dataloader)\n",
    "validation_history = pd.DataFrame.from_records(\n",
    "    history.val, columns=LossAcc._fields)\n",
    "validation_history['epoch'] = validation_history.index\n",
    "\n",
    "fig, ax = plt.subplots(1, 2, figsize=(12, 4))\n",
    "ax[0].plot(training_history['epoch'],\n",
    "           training_history['loss'], label='Training')\n",
    "ax[0].plot(validation_history['epoch'],\n",
    "           validation_history['loss'], label='Validation')\n",
    "ax[0].set_xlabel('Epoch')\n",
    "ax[0].set_ylabel('Loss')\n",
    "ax[0].legend()\n",
    "ax[1].plot(training_history['epoch'],\n",
    "           training_history['accuracy'], label='Training')\n",
    "ax[1].plot(validation_history['epoch'],\n",
    "           validation_history['accuracy'], label='Validation')\n",
    "ax[1].set_xlabel('Epoch')\n",
    "ax[1].set_ylabel('Accuracy')\n",
    "ax[1].legend()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load your test data\n",
    "df_test: pd.DataFrame = pd.DataFrame.from_records(\n",
    "    np.load('wafermap_HW3_test.npy', allow_pickle=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LossAcc(loss=0.19325745019684487, accuracy=0.9357142857142857)\n",
      "LossAcc(loss=0.23785010232206652, accuracy=0.9203703703703704)\n"
     ]
    }
   ],
   "source": [
    "# Build a test dataset and dataloader\n",
    "df_test['failureType'] = 'Donut'\n",
    "test_dataset = WaferDataset(df_test)\n",
    "test_dataloader = DataLoader(\n",
    "    test_dataset, batch_size=batch_size)\n",
    "\n",
    "traindata = validate(model, train_dataloader)\n",
    "print(traindata)\n",
    "testdata = validate(model, val_dataloader)\n",
    "print(testdata)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = []\n",
    "\n",
    "def predict(model: nn.Module, val_data: DataLoader) -> list:\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        predictions = []\n",
    "        for i, batch in enumerate(val_data):\n",
    "            # Get the data and labels from the batch\n",
    "            data, labels = batch\n",
    "            # Get the model's predictions for the data\n",
    "            outputs = model(data)\n",
    "            predicted = outputs.argmax(dim=1)\n",
    "            predictions.extend(predicted.numpy())\n",
    "        \n",
    "        # Return the average loss and accuracy over all batches.\n",
    "        return predictions\n",
    "    \n",
    "\n",
    "def getLabels(model: nn.Module, val_data: DataLoader) -> list:\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        label = []\n",
    "        for i, batch in enumerate(val_data):\n",
    "            # Get the data and labels from the batch\n",
    "            data, labels = batch\n",
    "            # Get the model's predictions for the data\n",
    "            label.extend(labels.numpy())\n",
    "\n",
    "        # Return the average loss and accuracy over all batches.\n",
    "        return label\n",
    "    \n",
    "output = predict(model, test_dataloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Get failure types string sorted by their numerical value\n",
    "tick_labels = [\"Edge-Loc\", \"Scratch\", \"Donut\", \"Center\", \"Near-full\"]\n",
    "\n",
    "all_dataset = WaferDataset(df_train)\n",
    "all_dataloader = DataLoader(all_dataset, batch_size=batch_size)\n",
    "\n",
    "\n",
    "pred_test = predict(model, all_dataloader)\n",
    "y_test = getLabels(model, all_dataloader)\n",
    "cm = confusion_matrix(y_test, pred_test, labels=[0, 1, 2, 3, 4])\n",
    "\n",
    "# plot confusion matrix using heatmap\n",
    "sns.heatmap(cm, annot=True, fmt='d',\n",
    "            xticklabels=tick_labels,\n",
    "            yticklabels=tick_labels,\n",
    "            cmap='Blues')\n",
    "\n",
    "plt.xlabel('actual value')\n",
    "plt.ylabel('prediction')\n",
    "\n",
    "# show plot\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 64-bit (microsoft store)",
   "language": "python",
   "name": "python3"
  },
  "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "441e02f58b6596cec3053ac76cf8196f03831bc98b46ddb6028f58f29d6a2768"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}