PixelCNN_Cifar10_New.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m   Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n",
      "######################################################################### 100.0%\n",
      "\u001b[32m\u001b[1m  Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1mNo Changes\u001b[22m\u001b[39m to `/scratch/users/ashah20/.julia/environments/v1.5/Project.toml`\n",
      "\u001b[32m\u001b[1mNo Changes\u001b[22m\u001b[39m to `/scratch/users/ashah20/.julia/environments/v1.5/Manifest.toml`\n",
      "\u001b[32m\u001b[1m  Resolving\u001b[22m\u001b[39m package versions...\n",
      "\u001b[32m\u001b[1mNo Changes\u001b[22m\u001b[39m to `/scratch/users/ashah20/.julia/environments/v1.5/Project.toml`\n",
      "\u001b[32m\u001b[1mNo Changes\u001b[22m\u001b[39m to `/scratch/users/ashah20/.julia/environments/v1.5/Manifest.toml`\n"
     ]
    }
   ],
   "source": [
    "import Pkg; Pkg.add(\"MLDatasets\")\n",
    "Pkg.add(\"CUDA\")\n",
    "using Printf, Random, Test, Statistics\n",
    "using MLDatasets\n",
    "using Knet\n",
    "import Base: length, size, iterate, eltype, IteratorSize, IteratorEltype, haslength, @propagate_inbounds, repeat, rand, tail\n",
    "import .Iterators: cycle, Cycle, take\n",
    "import CUDA # functional\n",
    "array_type=(CUDA.functional() ? KnetArray{Float32} : Array{Float32})\n",
    "using Knet: Knet, dir, accuracy, progress, sgd, gc, Param, KnetArray, Data, minibatch, nll, relu, training, dropout, sigm # param, param0, xavier_uniform\n",
    "#using IterTools: ncycle, takenth\n",
    "#using Base.Iterators: flatten\n",
    "using JLD2, FileIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((32, 32, 3, 50000), (50000,), (32, 32, 3, 10000), (10000,))"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load full training set\n",
    "train_x, train_y = CIFAR10.traindata()\n",
    "\n",
    "# load full test set\n",
    "test_x,  test_y  = CIFAR10.testdata()\n",
    "\n",
    "size(train_x), size(train_y), size(test_x), size(test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Effective GPU memory usage: 0.95% (308.750 MiB/31.749 GiB)\n",
      "CUDA allocator usage: 0 bytes\n",
      "binned usage: 0 bytes (0 bytes allocated, 0 bytes cached)\n"
     ]
    }
   ],
   "source": [
    "CUDA.reclaim()\n",
    "CUDA.memory_status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "discretize (generic function with 1 method)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    occlude(image, n_rows)\n",
    "\n",
    "Creates occluded image by assigning zeros to image rows - n_rows\n",
    "\"\"\"\n",
    "function occlude(image, n_rows)\n",
    "    i_size = size(image)\n",
    "    zero = zeros(i_size[1]-n_rows, i_size[2], i_size[3])\n",
    "    occluded = vcat(image[1:n_rows,:,:], zero)\n",
    "    return occluded\n",
    "end\n",
    "\n",
    "function occlude_data(data, n_rows)\n",
    "    i_size = size(data)\n",
    "    zero = zeros(i_size[1]-n_rows, i_size[2], i_size[3])\n",
    "    occluded_data = vcat(data[1:n_rows,:,:], zero)\n",
    "    return occluded_data\n",
    "end\n",
    "\n",
    "function discretize(data)\n",
    "    data = data .* 255\n",
    "    data = ceil.(data)\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ConvA"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "struct ConvA\n",
    "    w\n",
    "    b\n",
    "    f\n",
    "    p \n",
    "end\n",
    "\n",
    "function (c::ConvA)(x)\n",
    "    return c.f.(conv4(c.w, dropout(x,c.p), padding = 0) .+ c.b)\n",
    "end\n",
    "\n",
    "function ConvA(w1::Int,w2::Int,cx::Int,cy::Int,f=relu;pdrop=0)\n",
    "    atype=KnetArray{Float32}\n",
    "    w = (atype(ones(w1,w2,cx,cy)))\n",
    "    w[5:7,:,:,:] .= 0\n",
    "    w[4,4:7,:,:] .= 0\n",
    "    w = Param(w)\n",
    "    return ConvA(w, param0(1,1,cy,1, atype=KnetArray{Float32}), f, pdrop)\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ConvB"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define a convolutional layer:\n",
    "\n",
    "struct ConvB\n",
    "    w\n",
    "    b\n",
    "    f\n",
    "    p\n",
    "    pad\n",
    "end\n",
    "\n",
    "function (c::ConvB)(x)\n",
    "    return c.f.(conv4(c.w, dropout(x,c.p), padding = c.pad) .+ c.b)\n",
    "end\n",
    "\n",
    "function ConvB(w1::Int,w2::Int,cx::Int,cy::Int,f=relu;pdrop=0, pad=1)\n",
    "    return ConvB(param(w1,w2,cx,cy, atype=KnetArray{Float32}), param0(1,1,cy,1, atype=KnetArray{Float32}), f, pdrop, pad)\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "struct ResBlock\n",
    "    convlayers\n",
    "    ResBlock(convlayers...) = new(convlayers)\n",
    "end\n",
    "\n",
    "function (res::ResBlock)(x)\n",
    "    xres = copy(x)\n",
    "    \n",
    "    for l in res.convlayers\n",
    "        x = l(x)\n",
    "    end\n",
    "   \n",
    "    return x .+ xres\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's define a chain of layers\n",
    "struct Chain\n",
    "    layers\n",
    "    Chain(layers...) = new(layers)\n",
    "end\n",
    "(c::Chain)(x) = (for l in c.layers; x = l(x); end; x)\n",
    "(c::Chain)(x,y) = nll(c(x),y)\n",
    "(c::Chain)(d::Data) = mean(c(x,y) for (x,y) in d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pad (generic function with 3 methods)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function padImage(image, padding=1, constant=0)\n",
    "    row, col, chnl = size(image)\n",
    "    pad1 = ones(padding, col, chnl) .* constant\n",
    "    pad2 = ones(padding*2+row, padding, chnl) .* constant\n",
    "    padded = vcat(pad1, image, pad1)\n",
    "    padded = hcat(pad2, padded, pad2)\n",
    "    return padded\n",
    "end\n",
    "\n",
    "function pad(data, padding=1, constant=0)\n",
    "    row, col, chnl, dsize = size(data)\n",
    "    padded = zeros(row+padding*2, col+padding*2, chnl, dsize)\n",
    "    for i in 1:dsize\n",
    "        padded[:,:,:,i] .= padImage(data[:,:,:,i], padding, constant)\n",
    "    end\n",
    "    return padded\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "atype=KnetArray{Float32}\n",
    "small_data = train_x[:,:,:,1:50000];\n",
    "disc_data = discretize(small_data)\n",
    "small_data = pad(small_data, 3, 0.01)\n",
    "small_data = atype(small_data);\n",
    "\n",
    "lbls = reshape(disc_data[:,:,:,1:50000], (3072,50000));\n",
    "lbls = Int64.(lbls);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(38, 38, 3, 50000)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(small_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "lossfunc (generic function with 1 method)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function lossfunc(model, images, lbls)\n",
    "    loss = 0.0\n",
    "    score = model(images)\n",
    "    #println(sum.(score))\n",
    "    scores = reshape(score, (3072,256, :));\n",
    "    #println(score)\n",
    "\n",
    "    for i in 1:50\n",
    "        loss += nll(scores[:,:,i], lbls[:,i], dims=2)\n",
    "    end\n",
    "\n",
    "    return loss /= 50\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "trainmodel (generic function with 1 method)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function trainmodel(model, images, lbls)\n",
    "    L = @diff lossfunc(model, images, lbls)\n",
    "    \n",
    "    for p in params(model)\n",
    "        g = grad(L, p)\n",
    "        update!(value(p), g, p.opt)\n",
    "    end\n",
    "    #println(value(L))\n",
    "    return value(L)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "Random.seed!(1)\n",
    "\n",
    "d = 128\n",
    "\n",
    "residual = ResBlock(ConvB(1,1,256,128, pad=0),\n",
    "                    ConvB(1,1,128,128, pad=0),\n",
    "                    ConvB(1,1,128,256, pad=0))\n",
    "\n",
    "\n",
    "model_rand =   Chain(residual,\n",
    "                ConvB(1,1,256,d, pad=0),\n",
    "                ConvB(1,1,d,256*3, pad=0))\n",
    "\n",
    "\n",
    "atype=KnetArray{Float32}\n",
    "w = randn(7,7,3,256)\n",
    "w[5:7,:,:,:] .= 0\n",
    "w[4,4:7,:,:] .= 0\n",
    "w = atype(w);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.995827369689941\n",
      "4.815089569091797\n",
      "4.701465392112732\n",
      "4.614110507965088\n",
      "4.556533675193787\n",
      "4.512005624771118\n",
      "4.472695188522339\n",
      "4.442428603172302\n",
      "4.409692540168762\n",
      "4.381155681610108\n",
      "4.357384762763977\n",
      "4.330796771049499\n",
      "4.311597943305969\n",
      "4.297767415046692\n",
      "4.285689067840576\n",
      "4.274761624336243\n",
      "4.260611038208008\n",
      "4.251335849761963\n",
      "4.242707185745239\n",
      "4.23476749420166\n",
      "4.226480565071106\n",
      "4.218574290275574\n",
      "4.212095146179199\n",
      "4.206090435981751\n",
      "4.200169939994812\n",
      "4.194990229606629\n",
      "4.188476486206055\n",
      "4.183289675712586\n",
      "4.178310842514038\n",
      "4.173879523277282\n",
      "4.16938437461853\n",
      "4.165261840820312\n",
      "4.161410584449768\n",
      "4.156686763763428\n",
      "4.150882077217102\n",
      "4.147193694114685\n",
      "4.141731071472168\n",
      "4.138269920349121\n",
      "4.134956769943237\n",
      "4.131841034889221\n",
      "4.128732213973999\n",
      "4.125838809013366\n",
      "4.123077101707459\n",
      "4.120409803390503\n",
      "4.117861776351929\n",
      "4.115471148490906\n",
      "4.112006640434265\n",
      "4.109522671699524\n",
      "4.107081680297852\n",
      "4.103103303909302\n",
      "4.1007937240600585\n",
      "4.098772296905517\n",
      "4.096733956336975\n",
      "4.0947759294509884\n",
      "4.092955646514892\n",
      "4.091193218231201\n",
      "4.08933837890625\n",
      "4.087615447044373\n",
      "4.085964822769165\n",
      "4.0844873476028445\n",
      "4.081146507263184\n",
      "4.079176864624023\n",
      "4.077591795921325\n",
      "4.0743729829788204\n",
      "4.072808437347412\n",
      "4.0711878967285156\n",
      "4.069714913368225\n",
      "4.0682341718673705\n",
      "4.064915747642517\n",
      "4.063183727264405\n",
      "4.056738080978394\n",
      "4.055187849998474\n",
      "4.051035184860229\n",
      "4.049381375312805\n",
      "4.047931852340699\n",
      "4.046571655273437\n",
      "4.045547337532043\n",
      "4.044021520614624\n",
      "4.039950790405274\n",
      "4.038963255882263\n",
      "4.037595872879028\n",
      "4.036325101852417\n",
      "4.034356880187988\n",
      "4.0331393814086915\n",
      "4.028682641983032\n",
      "4.025572819709778\n",
      "4.024311861991882\n",
      "4.022694458961487\n",
      "4.021489496231079\n",
      "4.019296708106995\n",
      "4.018054823875428\n",
      "4.016956954002381\n",
      "4.015827984809875\n",
      "4.014846501350402\n",
      "4.0120993423461915\n",
      "4.009764156341553\n",
      "4.008508648872375\n",
      "4.0074451589584354\n",
      "4.003585834503173\n"
     ]
    }
   ],
   "source": [
    "losses = zeros(1, 100)\n",
    "batchsize = 50\n",
    "\n",
    "\n",
    "for p in params(model_rand)\n",
    "    p.opt = Adagrad(lr=0.01, gclip=0.01)\n",
    "end\n",
    "\n",
    "batchloss = 0\n",
    "\n",
    "for epochs in 1:100\n",
    "    for batch in 1:1000\n",
    "        batch_data = small_data[:,:,:,((batch-1)*batchsize+1):batch*batchsize]\n",
    "        batch_data = conv4(w, batch_data)\n",
    "        batchloss = trainmodel(model_rand, batch_data, lbls[:,((batch-1)*batchsize+1):batch*batchsize])\n",
    "        #println(batchloss)\n",
    "    end\n",
    "    losses[epochs] = batchloss\n",
    "    println(losses[epochs])\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "params(model_rand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@save \"modelCNN3.jld2\" model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@save \"modelCNN_Cifar.jld2\" model_rand w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@load \"modelCNN_Cifar.jld2\" model_rand w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tst_data = small_data[:,:,:,1:10]\n",
    "tst_data = conv4(w, tst_data)\n",
    "score = model(tst_data);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = reshape(score, (3072,256, 10))\n",
    "predicted = argmax(scores[:,:,1], dims=2)\n",
    "pred_image = zeros(3072,1)\n",
    "for i in 1:3072\n",
    "    pred_image[i] = predicted[i][2]\n",
    "end\n",
    "\n",
    "image = reshape(pred_image, (32,32,3));\n",
    "sample = image ./ 256;\n",
    "B = Array{Float32}(sample);\n",
    "#subplot(1,3,2)\n",
    "matshow(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 480x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.image.AxesImage object at 0x2b294f441220>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matshow(train_x[:,:,:,2292])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 480x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "an_image = train_x[:,:,:,2292]\n",
    "n_rows = 16\n",
    "#an_image = occlude(an_image, n_rows)\n",
    "matshow(an_image)\n",
    "#test_image = reshape(test_image, (32,32,3,1))\n",
    "#test_image = pad(test_image, 3, 1)\n",
    "#test_image = atype(test_image);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 480x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.image.AxesImage object at 0x2b2a9ed627f0>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#orig_image = copy(test_x[:,:,:,42])\n",
    "new_image = zeros(size(an_image))\n",
    "orig_image = copy(an_image)\n",
    "orig_image = reshape(orig_image, (32,32,3,1))\n",
    "for j in n_rows+1:32\n",
    "    for k in 1:32\n",
    "        test_image = pad(orig_image, 3, 0.1)\n",
    "        test_image = atype(test_image);\n",
    "        test_image = conv4(w, test_image)\n",
    "        score = model_rand(test_image)\n",
    "        scores = reshape(score, (3072,256, 1));\n",
    "        predicted = argmax(scores, dims=2)\n",
    "        pred_image = zeros(3072,1)\n",
    "        for i in 1:3072\n",
    "            pred_image[i] = predicted[i][2]\n",
    "        end\n",
    "        image = reshape(pred_image, (32,32,3));\n",
    "        sample = image ./ 256;\n",
    "        B = KnetArray{Float32}(sample);\n",
    "        #println(B[j,k,:])\n",
    "        orig_image[j,k,:,:] .= B[j,k,:]\n",
    "        new_image[j,k,:,:] .= B[j,k,:]\n",
    "        \n",
    "    end\n",
    "end\n",
    "image = reshape(orig_image, (32,32,3));\n",
    "matshow(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 480x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.image.AxesImage object at 0x2b2a9e766400>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matshow(new_image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matshow(test_x[:,:,:,42])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.5.3",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}