Load MNIST.ipynb

{
 "metadata": {
  "language": "lua",
  "name": "",
  "signature": "sha256:204bdc6dbdd55fc933ed31c56d3fe2159119cde95a79727d411b6989a3255722"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = torch.Tensor({1,2,3,4,5})\n",
      "a:mul(3)\n",
      "print(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 3,
       "text": [
        "  3\n",
        "  6\n",
        "  9\n",
        " 12\n",
        " 15\n",
        "[torch.DoubleTensor of dimension 5]\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "require 'torch'\n",
      "require 'paths'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mnist = {}\n",
      "\n",
      "mnist.path_remote = 'https://s3.amazonaws.com/torch7/data/mnist.t7.tgz'\n",
      "mnist.path_dataset = 'mnist.t7'\n",
      "mnist.path_trainset = paths.concat(mnist.path_dataset, 'train_32x32.t7')\n",
      "mnist.path_testset = paths.concat(mnist.path_dataset, 'test_32x32.t7')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "function mnist.download()\n",
      "   if not paths.filep(mnist.path_trainset) or not paths.filep(mnist.path_testset) then\n",
      "      local remote = mnist.path_remote\n",
      "      local tar = paths.basename(remote)\n",
      "      os.execute('wget ' .. remote .. '; ' .. 'tar xvf ' .. tar .. '; rm ' .. tar)\n",
      "   end\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "function mnist.loadTrainSet(maxLoad, geometry)\n",
      "   return mnist.loadDataset(mnist.path_trainset, maxLoad, geometry)\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "function mnist.loadTestSet(maxLoad, geometry)\n",
      "   return mnist.loadDataset(mnist.path_testset, maxLoad, geometry)\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "function mnist.loadDataset(fileName, maxLoad)\n",
      "   mnist.download()\n",
      "\n",
      "   local f = torch.load(fileName, 'ascii')\n",
      "   local data = f.data:type(torch.getdefaulttensortype())\n",
      "   local labels = f.labels\n",
      "\n",
      "   local nExample = f.data:size(1)\n",
      "   if maxLoad and maxLoad > 0 and maxLoad < nExample then\n",
      "      nExample = maxLoad\n",
      "      print('<mnist> loading only ' .. nExample .. ' examples')\n",
      "   end\n",
      "   data = data[{{1,nExample},{},{},{}}]\n",
      "   labels = labels[{{1,nExample}}]\n",
      "   print('<mnist> done')\n",
      "\n",
      "   local dataset = {}\n",
      "   dataset.data = data\n",
      "   dataset.labels = labels\n",
      "\n",
      "   function dataset:normalize(mean_, std_)\n",
      "      local mean = mean or data:view(data:size(1), -1):mean(1)\n",
      "      local std = std_ or data:view(data:size(1), -1):std(1, true)\n",
      "      for i=1,data:size(1) do\n",
      "         data[i]:add(-mean[1][i])\n",
      "         if std[1][i] > 0 then\n",
      "            tensor:select(2, i):mul(1/std[1][i])\n",
      "         end\n",
      "      end\n",
      "      return mean, std\n",
      "   end\n",
      "\n",
      "   function dataset:normalizeGlobal(mean_, std_)\n",
      "      local std = std_ or data:std()\n",
      "      local mean = mean_ or data:mean()\n",
      "      data:add(-mean)\n",
      "      data:mul(1/std)\n",
      "      return mean, std\n",
      "   end\n",
      "\n",
      "   function dataset:size()\n",
      "      return nExample\n",
      "   end\n",
      "\n",
      "   local labelvector = torch.zeros(10)\n",
      "\n",
      "   setmetatable(dataset, {__index = function(self, index)\n",
      "                 local input = self.data[index]\n",
      "                 local class = self.labels[index]\n",
      "                 local label = labelvector:zero()\n",
      "                 label[class] = 1\n",
      "                 local example = {input, label}\n",
      "                                       return example\n",
      "   end})\n",
      "\n",
      "   return dataset\n",
      "end"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "nbTrainingPatches = 60000\n",
      "nbTestingPatches = 10000\n",
      "geometry = {32,32}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "-- create training set and normalize\n",
      "trainData = mnist.loadTrainSet(nbTrainingPatches, geometry)\n",
      "trainData:normalizeGlobal(mean, std)\n",
      "\n",
      "-- create test set and normalize\n",
      "testData = mnist.loadTestSet(nbTestingPatches, geometry)\n",
      "testData:normalizeGlobal(mean, std)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "<mnist> done\t\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "<mnist> done\t\n"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(testData.data:size())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 18,
       "text": [
        "\n",
        " 10000\n",
        "     1\n",
        "    32\n",
        "    32\n",
        "[torch.LongStorage of size 4]\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(trainData.data:size())"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 19,
       "text": [
        "\n",
        " 60000\n",
        "     1\n",
        "    32\n",
        "    32\n",
        "[torch.LongStorage of size 4]\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 19
    }
   ],
   "metadata": {}
  }
 ]
}