prepare_flickr30k_speed.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare model for Flickr30k\n",
    "\n",
    "Here we will prepare model to run caption generation for the paper \"Show Attend and Tell\". \n",
    "\n",
    "This is for the Flickr8k dataset. \n",
    "\n",
    "### Prerequisite \n",
    " - The data is available from \n",
    "     - Images http://nlp.cs.illinois.edu/HockenmaierGroup/Framing_Image_Description/Flickr8k_Dataset.zip\n",
    "     - Texts http://nlp.cs.illinois.edu/HockenmaierGroup/Framing_Image_Description/Flickr8k_text.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load and Preprocess images\n",
    "\n",
    "Download data and downsize so that large side is 256.  And center crop by 224 by 224.  \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Initial Environment setup \n",
    "\n",
    "originalImagesPath = './data/flickr30k/flickr30k-images'\n",
    "preprocessedImagesPath = './data/flickr30k/processedImages'\n",
    "fileList = './data/flickr30k/imageList.txt'\n",
    "\n",
    "numTrain = 25000\n",
    "numTest = 2500\n",
    "\n",
    "caffe_root = '/home/intuinno/codegit/caffe/'\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "import sys\n",
    "sys.path.insert(0, caffe_root + 'python')\n",
    "\n",
    "import caffe\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (10, 10)\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "import os\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "imageFiles = open(fileList)\n",
    "imageList = [i.rstrip() for i in imageFiles]\n",
    "shuffle(imageList)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "import sys\n",
    "sys.path.insert(0, caffe_root + 'python')\n",
    "\n",
    "import caffe\n",
    "\n",
    "plt.rcParams['figure.figsize'] = (10, 10)\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "import os\n",
    "# if not os.path.isfile(caffe_root + 'models/bvlc_reference_caffenet/bvlc_reference_caffenet.caffemodel'):\n",
    "#     print(\"Downloading pre-trained CaffeNet model...\")\n",
    "#     !../scripts/download_model_binary.py ../models/bvlc_reference_caffenet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set caffe to use GPU.  And we will use vgg_il"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "caffe.set_device(1)\n",
    "caffe.set_mode_gpu()\n",
    "\n",
    "net = caffe.Net(caffe_root + 'models/vgg_ilsvrc_19/VGG_ILSVRC_19_layers_deploy.prototxt',\n",
    "                caffe_root + 'models/vgg_ilsvrc_19/VGG_ILSVRC_19_layers.caffemodel',\n",
    "                caffe.TEST)\n",
    "\n",
    "# input preprocessing: 'data' is the name of the input blob == net.inputs[0]\n",
    "transformer = caffe.io.Transformer({'data': net.blobs['data'].data.shape})\n",
    "transformer.set_transpose('data', (2,0,1))\n",
    "# transformer.set_mean('data', np.load(caffe_root + 'python/caffe/imagenet/ilsvrc_2012_mean.npy').mean(1).mean(1)) # mean pixel\n",
    "# transformer.set_raw_scale('data', 255)  # the reference model operates on images in [0,255] range instead of [0,1]\n",
    "# transformer.set_channel_swap('data', (2,1,0))  # the reference model has channels in BGR order instead of RGB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with a simple classification. We'll set a batch of 50 to demonstrate batch processing, even though we'll only be classifying one image. (Note that the batch size can also be changed on-the-fly.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dev\n",
      "1000(1000, 100352)\n",
      "test\n",
      "1000(1000, 100352)\n",
      "train\n",
      "6000(6000, 100352)\n"
     ]
    }
   ],
   "source": [
    "# set net to batch size of 50\n",
    "# net.blobs['data'].reshape(5,3,224,224)\n",
    "\n",
    "# resultingFeatures = \n",
    "\n",
    "# files = ['test', 'train', 'dev']\n",
    "files = [ 'dev','test','train']\n",
    "\n",
    "import pdb\n",
    "from sys import stdout\n",
    "import scipy\n",
    "import  pickle\n",
    "\n",
    "\n",
    "for fname in files:\n",
    "    print fname \n",
    "    f = open('/home/intuinno/project/pointTeach/data/Flicker8k/Flickr_8k.' + fname + 'Images.txt')\n",
    "    counter = 0\n",
    "    \n",
    "    imageList = [i for i in f]\n",
    "    numImage = len(imageList)\n",
    "#     pdb.set_trace()\n",
    "    \n",
    "    result = np.empty((numImage, 100352))\n",
    "\n",
    "    for i in range(numImage):\n",
    "        fn = imageList[i].rstrip()\n",
    "        net.blobs['data'].data[...] = transformer.preprocess('data', caffe.io.load_image( '/home/intuinno/project/pointTeach/data/Flicker8k/preprocessedImages/' +  fn))\n",
    "        out = net.forward()\n",
    "        feat = net.blobs['conv5_4'].data[0]\n",
    "    #     print feat.shape\n",
    "#         pdb.set_trace()\n",
    "        reshapeFeat = np.swapaxes(feat, 0,2)\n",
    "        reshapeFeat2 = np.reshape(reshapeFeat,(1,-1))\n",
    "        \n",
    "        counter += 1\n",
    "        stdout.write(\"\\r%d\" % counter)\n",
    "        stdout.flush()\n",
    "        result[i,:] = reshapeFeat2\n",
    "        \n",
    "    print result.shape\n",
    "    \n",
    "    resultSave = scipy.sparse.csr_matrix(result)\n",
    "    resultSave32 = resultSave.astype('float32')\n",
    "    fileName = open('flicker_8k_feature.' + fname + '.pkl','wb')\n",
    "    pickle.dump(resultSave32, fileName ,-1)\n",
    "    fileName.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "import pickle as pkl\n",
    "print pkl.HIGHEST_PROTOCOL\n",
    "# pkl.dump(resultSave, open('flicker_8k_feature.' + fname + '.pkl','wb'),protocol=pickle.HIGHEST_PROTOCOL)\n",
    "\n",
    "resultSave32 = resultSave.astype('float32')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<1x100352 sparse matrix of type '<type 'numpy.float32'>'\n",
       "\twith 19374 stored elements in Compressed Sparse Row format>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resultSave32[0][0]\n",
    "# pkl.dump(resultSave32, open('flicker_8k_feature.' + fname + '.pkl','wb'),protocol=pickle.HIGHEST_PROTOCOL)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "def show_sizeof(x, level=0):\n",
    "\n",
    "    print \"\\t\" * level, x.__class__, sys.getsizeof(x), x\n",
    "\n",
    "    if hasattr(x, '__iter__'):\n",
    "        if hasattr(x, 'items'):\n",
    "            for xx in x.items():\n",
    "                show_sizeof(xx, level + 1)\n",
    "        else:\n",
    "            for xx in x:\n",
    "                show_sizeof(xx, level + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " <type 'NoneType'> 16 None\n",
      " <type 'int'> 24 3\n",
      " <type 'long'> 36 9223372036854775808\n",
      " <type 'long'> 40 102947298469128649161972364837164\n",
      " <type 'long'> 60 918659326943756134897561304875610348756384756193485761304875613948576297485698417\n"
     ]
    }
   ],
   "source": [
    "show_sizeof(None)\n",
    "show_sizeof(3)\n",
    "show_sizeof(2**63)\n",
    "show_sizeof(102947298469128649161972364837164)\n",
    "show_sizeof(918659326943756134897561304875610348756384756193485761304875613948576297485698417)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "capFile = open('/home/intuinno/project/pointTeach/data/Flicker8k/Flickr8k.token.txt')\n",
    "\n",
    "capDict = {}\n",
    "import re\n",
    "for line in capFile:\n",
    "    match = re.search(r'^([\\w]+\\.jpg)#(\\d)\\s([\\w\\W.\\s-]+)$', line)\n",
    "#     print line\n",
    "    if not match:\n",
    "        print line\n",
    "    else:\n",
    "        if match.group(2) == '0':\n",
    "            capDict[match.group(1)] = [match.group(3)]\n",
    "        else:\n",
    "            capDict[match.group(1)].append(match.group(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import cPickle as pickle\n",
    "files = ['test', 'train', 'dev']\n",
    "\n",
    "for name in files:\n",
    "    counter = 0\n",
    "    feat = pickle.load(open('flicker_8k_feature.' + name +'.pkl','rb'))\n",
    "    filenames = open('/home/intuinno/project/pointTeach/data/Flicker8k/Flickr_8k.' + name + 'Images.txt')\n",
    "    cap = []\n",
    "    for imageFile in filenames:\n",
    "        imageFile = imageFile.rstrip()\n",
    "        for sen in capDict[imageFile]:\n",
    "            cap.append([sen.rstrip(), counter])\n",
    "        counter += 1\n",
    "    saveFile = open('flicker_8k_feature.' + name + '.pkl', 'wb')\n",
    "    pickle.dump(cap, saveFile, protocol=pickle.HIGHEST_PROTOCOL)\n",
    "    pickle.dump(feat, saveFile, protocol=pickle.HIGHEST_PROTOCOL)\n",
    "    saveFile.close()\n",
    "            \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'dictionary' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-32-004dc7fa33f2>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdictionary\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'People'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'dictionary' is not defined"
     ]
    }
   ],
   "source": [
    "dictionary['People']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "dictionary['people']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "saveFile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "description": "Instant recognition with a pre-trained model and a tour of the net interface for visualizing features and parameters layer-by-layer.",
  "example_name": "Image Classification and Filter Visualization",
  "include_in_docs": true,
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  },
  "priority": 1
 },
 "nbformat": 4,
 "nbformat_minor": 0
}