pytorch attempt.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = pd.read_csv('./data/test.csv')\n",
    "train = pd.read_csv('./data/train.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_label = train['label'].copy()\n",
    "train.drop(columns='label', inplace= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(42000, 784)\n",
      "(28000, 784)\n"
     ]
    }
   ],
   "source": [
    "print(train.shape)\n",
    "print(test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = train.values.reshape((42000,28,28))\n",
    "test = test.values.reshape((28000,28,28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(42000, 28, 28)\n",
      "(28000, 28, 28)\n",
      "0 255\n",
      "0 255\n"
     ]
    }
   ],
   "source": [
    "print(train.shape)\n",
    "print(test.shape)\n",
    "print(np.min(train), np.max(train))\n",
    "print(np.min(test), np.max(test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = train/255\n",
    "test = test/255"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fda9272e048>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img_num=100\n",
    "plt.imshow(train[img_num], cmap='gray')\n",
    "print(train_label[img_num])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fda9268fcf8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(train_label,bins=10)\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#from https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class Net(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        # 1 input image channel, 6 output channels, 5x5 square convolution\n",
    "        # kernel\n",
    "        self.conv1 = nn.Conv2d(1, 6, 5)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        # an affine operation: y = Wx + b\n",
    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Max pooling over a (2, 2) window\n",
    "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
    "        # If the size is a square you can only specify a single number\n",
    "        x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
    "        x = x.view(-1, self.num_flat_features(x))\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "    def num_flat_features(self, x):\n",
    "        size = x.size()[1:]  # all dimensions except the batch dimension\n",
    "        num_features = 1\n",
    "        for s in size:\n",
    "            num_features *= s\n",
    "        return num_features\n",
    "\n",
    "\n",
    "net = Net()\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = np.pad(train, pad_width=((0,0),(2,2),(2,2)), mode ='constant')\n",
    "test = np.pad(test, pad_width=((0,0),(2,2),(2,2)), mode ='constant')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = torch.from_numpy(train)\n",
    "test = torch.from_numpy(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(train.shape)\n",
    "print(test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input=train[0].unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "net(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = net(input)\n",
    "target = torch.arange(1, 11)  # a dummy target, for example\n",
    "target = target.view(1, -1)  # make it the same shape as output\n",
    "criterion = nn.MSELoss()\n",
    "\n",
    "loss = criterion(output, target)\n",
    "print(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "# create your optimizer\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.01)\n",
    "\n",
    "# in your training loop:\n",
    "optimizer.zero_grad()   # zero the gradient buffers\n",
    "output = net(input)\n",
    "loss = criterion(output, target)\n",
    "loss.backward()\n",
    "optimizer.step()    # Does the update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train1 = torch.utils.data.TensorDataset(train, train_labels.view(-1))\n",
    "train_loader = torch.utils.data.DataLoader(train1, batch_size=64, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for epoch in range(2):  # loop over the dataset multiple times\n",
    "\n",
    "    running_loss = 0.0\n",
    "    i=0\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "        # get the inputs\n",
    "        inputs, labels = data\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # print statistics\n",
    "        running_loss += loss.item()\n",
    "        if i % 2000 == 1999:    # print every 2000 mini-batches\n",
    "            print('[%d, %5d] loss: %.3f' %\n",
    "                  (epoch + 1, i + 1, running_loss / 2000))\n",
    "            running_loss = 0.0\n",
    "\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}