SandBox.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# base imports\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from zipfile import ZipFile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch imports\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset\n",
    "from torchvision import transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Custom Imports\n",
    "from src.CustomUTK import UTKDataset\n",
    "from src.MultNN import TridentNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read in Unzipped file and make into a gzip\n",
    "# DONT NEED TO RUN THIS AGAIN\n",
    "# dataFrame = pd.read_csv('./data/age_gender.csv')\n",
    "# dataFrame.to_csv('./data/age_gender.gz', compression='gzip')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading in Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read in the dataframe\n",
    "dataFrame = pd.read_csv('./data/age_gender.gz', compression='gzip')\n",
    "\n",
    "# Split into training and testing\n",
    "train_dataFrame, test_dataFrame = train_test_split(dataFrame, test_size=0.2)\n",
    "\n",
    "# get the number of unique classes for each group\n",
    "'''\n",
    "class_nums = {'age_num':len(dataFrame['age'].unique()), 'eth_num':len(dataFrame['ethnicity'].unique()),\n",
    "              'gen_num':len(dataFrame['gender'].unique())}\n",
    "'''\n",
    "class_nums = {'age_num':1, 'eth_num':len(dataFrame['ethnicity'].unique()),\n",
    "              'gen_num':len(dataFrame['gender'].unique())}\n",
    "\n",
    "# Define train and test transforms\n",
    "train_transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.49,), (0.23,))\n",
    "])\n",
    "\n",
    "test_transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.49,), (0.23,))\n",
    "])\n",
    "\n",
    "# Construct the custom pytorch datasets\n",
    "train_set = UTKDataset(train_dataFrame, transform=train_transform)\n",
    "test_set = UTKDataset(test_dataFrame, transform=test_transform)\n",
    "\n",
    "# Load the datasets into dataloaders\n",
    "train_loader = DataLoader(train_set, batch_size=64, shuffle=True)\n",
    "test_loader = DataLoader(test_set, batch_size=128, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of training X: torch.Size([64, 1, 48, 48])\n",
      "Shape of y: torch.Size([64, 3])\n"
     ]
    }
   ],
   "source": [
    "# Sanity Check\n",
    "for X, y in train_loader:\n",
    "    print(f'Shape of training X: {X.shape}')\n",
    "    print(f'Shape of y: {y.shape}')\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing the datatypes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing out the shape and datatypes of the labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of age: torch.Size([64, 1])  datatype of age: torch.float32\n",
      "Shape of gen: torch.Size([64])  datatype of age: torch.int64\n",
      "Shape of eth: torch.Size([64])  datatype of age: torch.int64\n"
     ]
    }
   ],
   "source": [
    "for X, y in train_loader:\n",
    "    age, gen, eth = y[:,0].resize_(len(y[:,0]),1).float(), y[:,1], y[:,2]\n",
    "    print(f'Shape of age: {age.shape}  datatype of age: {age.dtype}')\n",
    "    print(f'Shape of gen: {gen.shape}  datatype of age: {gen.dtype}')\n",
    "    print(f'Shape of eth: {eth.shape}  datatype of age: {eth.dtype}')\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Age has to be a float, testing out how to make a tensor of float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(23705,)\n",
      "torch.Size([23705])\n",
      "torch.int64\n",
      "torch.float32\n"
     ]
    }
   ],
   "source": [
    "sample_age = np.array(dataFrame.age[:])\n",
    "sample_age_tensor = torch.tensor(sample_age)\n",
    "print(sample_age.shape)\n",
    "print(sample_age_tensor.shape)\n",
    "print(sample_age_tensor.dtype)\n",
    "sample_age_tensor = sample_age_tensor.float()\n",
    "print(sample_age_tensor.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing out the shape and datatypes of the outputs of the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_nums = {'age_num':1, 'eth_num':len(dataFrame['ethnicity'].unique()),\n",
    "              'gen_num':len(dataFrame['gender'].unique())}\n",
    "\n",
    "tridentNN = TridentNN(class_nums['age_num'], class_nums['gen_num'], class_nums['eth_num'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator = iter(train_loader)\n",
    "x_batch, y_batch = iterator.next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([64, 1, 48, 48])\n",
      "torch.Size([64, 3])\n"
     ]
    }
   ],
   "source": [
    "print(x_batch.shape)\n",
    "print(y_batch.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = tridentNN(x_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of age: torch.Size([64, 1])  datatype of age: torch.float32\n",
      "Shape of gen: torch.Size([64, 2])  datatype of age: torch.float32\n",
      "Shape of eth: torch.Size([64, 5])  datatype of age: torch.float32\n"
     ]
    }
   ],
   "source": [
    "age_pred, gen_pred, eth_pred = pred[0], pred[1], pred[2]\n",
    "print(f'Shape of age: {age_pred.shape}  datatype of age: {age_pred.dtype}')\n",
    "print(f'Shape of gen: {gen_pred.shape}  datatype of age: {gen_pred.dtype}')\n",
    "print(f'Shape of eth: {eth_pred.shape}  datatype of age: {eth_pred.dtype}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.4928, 0.5072], grad_fn=<SoftmaxBackward>)\n"
     ]
    }
   ],
   "source": [
    "print(F.softmax(gen_pred[0], dim=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everything looks good, lets just find a nice way to change the label size for age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([23705])\n",
      "torch.Size([23705, 1])\n",
      "torch.float32\n"
     ]
    }
   ],
   "source": [
    "print(sample_age_tensor.shape)\n",
    "sample_age_tensor.resize_(len(sample_age_tensor),1)\n",
    "print(sample_age_tensor.shape)\n",
    "print(sample_age_tensor.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing out one forward and backward pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define loss functions\n",
    "age_loss = nn.MSELoss()\n",
    "gen_loss = nn.CrossEntropyLoss() # TODO : Explore using Binary Cross Entropy Loss?\n",
    "eth_loss = nn.CrossEntropyLoss()\n",
    "\n",
    "# Define optimizer\n",
    "opt = torch.optim.Adam(tridentNN.parameters(), lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get one sample from train loader and unpack y to get true labels\n",
    "iterator = iter(train_loader)\n",
    "X, y = iterator.next()\n",
    "\n",
    "age, gen, eth = y[:,0].resize_(len(y[:,0]),1).float(), y[:,1], y[:,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Forward Pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get model prediction\n",
    "pred = tridentNN(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(504.9414, grad_fn=<AddBackward0>)\n"
     ]
    }
   ],
   "source": [
    "# Calculate Loss\n",
    "loss = age_loss(pred[0],age) + gen_loss(pred[1],gen) + eth_loss(pred[2],eth)\n",
    "\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Backpropagate\n",
    "# Backpropagation\n",
    "opt.zero_grad()          # Zero the gradient\n",
    "loss.backward()          # Calculate updates\n",
    "\n",
    "# Gradient Descent\n",
    "opt.step()         # Apply updates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(504.9414, grad_fn=<AddBackward0>)\n"
     ]
    }
   ],
   "source": [
    "print(loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find way to vectorize accuarcy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "correct_gen = (pred[1].argmax(1) == gen).type(torch.float).sum().item()\n",
    "correct_eth = (pred[2].argmax(1) == eth).type(torch.float).sum().item()\n",
    "\n",
    "total = len(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n"
     ]
    }
   ],
   "source": [
    "print(total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28.0\n"
     ]
    }
   ],
   "source": [
    "print(correct_gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.0\n"
     ]
    }
   ],
   "source": [
    "print(correct_eth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([64, 2])\n"
     ]
    }
   ],
   "source": [
    "print(pred[1].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4375\n"
     ]
    }
   ],
   "source": [
    "print(correct_gen/total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4741\n"
     ]
    }
   ],
   "source": [
    "print(len(test_loader.dataset))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}