{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A simple example of a fully connected deep neural network (FCN)\n",
    "# The FCN trains on images from ten classes, then takes an image\n",
    "# and estimates which class it represents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import matplotlib to display digit images\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Import PyTorch data used in example program\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision.datasets as dsets\n",
    "import torchvision.transforms as xforms\n",
    "from torch.autograd import Variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_size = 3072  # The image size = 32x32x3 = \n",
    "hidden_size = 500  # Number of nodes in the hidden layer\n",
    "num_classes = 10  # Number of output classes (0..9)\n",
    "num_epochs = 5  # Number of times DNN is trained on training dataset\n",
    "batch_size = 100  # The size of input data for one iteration\n",
    "learning_rate = 0.001  # The speed of convergence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "# Read om training and test datasets, these are included as part of\n",
    "# PyTorch's dataset repository\n",
    "\n",
    "train_dataset = dsets.CIFAR10( root ='./data', train=True, transform=xforms.ToTensor(), download=True )\n",
    "test_dataset = dsets.CIFAR10( root='./data', train=False, transform=xforms.ToTensor() )\n",
    "\n",
    "classes = [ 'plane','car','bird','cat','deer','dog','frog','horse','ship','truck' ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "frog deer dog car\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x250 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's look at four of the images in the training dataset, and the\n",
    "# corresponding label (which defines the object the image represents)\n",
    "\n",
    "# Grab the first four images and corresponding objects they represent\n",
    "# from the training set\n",
    "\n",
    "img = []\n",
    "val = []\n",
    "\n",
    "for i in range( 4 ):\n",
    "    im, v = train_dataset[ 20 * i ]\n",
    "    img.append( im )\n",
    "    val.append( v )\n",
    "    \n",
    "    img[ i ] = img[ i ] / 2 + 0.5\n",
    "    img[ i ] = img[ i ].numpy()\n",
    "    img[ i ] = img[ i ].transpose( 1, 2, 0 )\n",
    "    \n",
    "# Print out what objects the four images are meant to represent\n",
    "    \n",
    "print( ' '.join( classes[ val[ i ] ] for i in range( 4 ) ) )\n",
    "    \n",
    "# Create a single row of four images\n",
    "    \n",
    "fig, axes = plt.subplots( 1, 4, figsize=( 12, 2.5 ) )\n",
    "for i in range( 4 ):\n",
    "    axes[ i ].imshow( img[ i ] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create training and test dataloaders, these will load and cache data of batch_size during\n",
    "# looping, training data is shuffled randomly, test data is not\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader( dataset=train_dataset, batch_size=batch_size, shuffle=True )\n",
    "test_loader = torch.utils.data.DataLoader( dataset=test_dataset, batch_size=batch_size, shuffle=False )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = nn.Sequential(\n",
    "  nn.Linear( input_size, hidden_size ),  # fully connected layer, 784 (input data) -> 500 (hidden layer)\n",
    "  nn.ReLU(),  # Rectified liner unit filter, max( 0, x )\n",
    "  nn.Linear( hidden_size, num_classes )  # output layer, 500 (hidden layer) -> 10 (output classes)\n",
    ")\n",
    "\n",
    "#net.cuda()  # Uncomment to enable GPU computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choose a cross-entropy loss function to use during evaluation of DNN performance, and an\n",
    "# Adam optimizer (Adam, see https://arxiv.org/abs/1412.6980) to update DNN weights\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam( net.parameters(), lr=learning_rate )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/1], Step [100/500], Loss: 1.8654\n",
      "Epoch [1/1], Step [200/500], Loss: 1.9808\n",
      "Epoch [1/1], Step [300/500], Loss: 2.0175\n",
      "Epoch [1/1], Step [400/500], Loss: 1.6879\n",
      "Epoch [1/1], Step [500/500], Loss: 1.8563\n"
     ]
    }
   ],
   "source": [
    "# Train the DNN\n",
    "\n",
    "for epoch in range( 0, num_epochs ):  # For each of the five epochs\n",
    "    \n",
    "    for i, (images, labels) in enumerate( train_loader ):  # For each of the 100-image batches\n",
    "        \n",
    "        images = Variable( images.view( -1, 32 * 32 * 3 ))  # Convert torch tensor to Variable, from 784-pix image to 28x28 matrix\n",
    "        labels = Variable( labels )  # Grab pre-assigned labels for each of the 100 images\n",
    "        \n",
    "        optimizer.zero_grad()  # Zero gradients for current pass\n",
    "        outputs = net( images )  # Forward pass, compute output class for given image\n",
    "        loss = criterion( outputs, labels )  # Compute loss, difference between estimated label and actual label\n",
    "        loss.backward()  # Backpropegation, compute improved weights\n",
    "        optimizer.step()  # Update weights of hidden nodes\n",
    "        \n",
    "        if ( i + 1 ) % 100 == 0:  # Log message\n",
    "            print( 'Epoch [%d/%d], Step [%d/%d], Loss: %.4f' % ( epoch + 1, num_epochs, i + 1, len( train_dataset ) // batch_size, loss.data ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on 10K test images: 38 %\n"
     ]
    }
   ],
   "source": [
    "# Test performance on test images\n",
    "\n",
    "correct = 0\n",
    "total = 0\n",
    "\n",
    "for images, labels in test_loader:  # For each image the the test dataset\n",
    "    \n",
    "    images = Variable( images.view( -1, 32 * 32 * 3 ) )  # Convert torch tensor to Variable, from 784-pix image to 28x28 matrix\n",
    "    outputs = net( images )  # Get correct lables for each image\n",
    "    \n",
    "    _, predicted = torch.max( outputs.data, 1 )  # Choose best class from DNN output\n",
    "    total += labels.size( 0 )  # Increment total count\n",
    "    correct += ( predicted == labels ).sum()  # Increment correct prediction count\n",
    "    \n",
    "# Print overall accuracy of labeling\n",
    "    \n",
    "print( 'Accuracy on 10K test images: %d %%' % ( 100 * correct / total ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plane: (517 of 1000), 51.7%\n",
      "car: (432 of 1000), 43.2%\n",
      "bird: (134 of 1000), 13.4%\n",
      "cat: (278 of 1000), 27.8%\n",
      "deer: (135 of 1000), 13.5%\n",
      "dog: (330 of 1000), 33.0%\n",
      "frog: (435 of 1000), 43.5%\n",
      "horse: (676 of 1000), 67.6%\n",
      "ship: (462 of 1000), 46.2%\n",
      "truck: (462 of 1000), 46.2%\n"
     ]
    }
   ],
   "source": [
    "# Test performance on test images\n",
    "\n",
    "correct = [0] * len( classes )\n",
    "total = [0] * len( classes )\n",
    "\n",
    "for images, labels in test_loader:  # For each image the the test dataset    \n",
    "    images = Variable( images.view( -1, 32 * 32 * 3 ) )  # Convert torch tensor to Variable, from 784-pix image to 28x28 matrix\n",
    "    outputs = net( images )  # Get correct lables for each image\n",
    "    _, predicted = torch.max( outputs.data, 1 )  # Choose best class from DNN output\n",
    "\n",
    "    for i in range( 0, torch.numel( predicted ) ):\n",
    "        lbl = int( labels[ i ] )\n",
    "        pred = int( predicted[ i ] )\n",
    "\n",
    "        total[ lbl ] += 1\n",
    "        correct[ lbl ] += ( pred == lbl )\n",
    "    \n",
    "    # Print overall accuracy of labeling per class\n",
    "\n",
    "for i in range( 0, len( correct ) ):\n",
    "    pct = correct[ i ] / total[ i ] * 100.0\n",
    "    print( f'{classes[i]}: ({correct[i]} of {total[i]}), {pct:.1f}%' )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base-ex",
   "language": "python",
   "name": "base-ex"
  },
  "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}