arrange example images, update paths, bring back imagenet_pretrained

diff --git a/examples/imagenet_pretrained.ipynb b/examples/imagenet_pretrained.ipynb
new file mode 100644 (file)
index 0000000..8bf17f6
--- /dev/null
+++ b/examples/imagenet_pretrained.ipynb
@@ -0,0 +1,270 @@
+{
+ "metadata": {
+  "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Running Pretrained ImageNet: the Easy way\n",
+      "=========================================\n",
+      "\n",
+      "For easier use of pretrained models, we provide a wrapper specifically written for the case of ImageNet, so one can take an image and directly compute features or predictions from them. Both Python and Matlab wrappers are provided. We will describe the use of the Python wrapper here, and the Matlab wrapper usage is very similar.\n",
+      "\n",
+      "We assume that you have successfully compiled Caffe and set the correct `PYTHONPATH`. If not, please refer to the [installation instructions](installation.html). You will use our pre-trained imagenet model, which you can download (232.57MB) by running `examples/imagenet/get_caffe_reference_imagenet_model.sh`. Note that this pre-trained model is licensed for academic research / non-commercial use only.\n",
+      "\n",
+      "Ready? Let's start."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "from caffe import imagenet\n",
+      "from matplotlib import pyplot\n",
+      "\n",
+      "# Set the right path to your model file, pretrained model,\n",
+      "# and the image you would like to classify.\n",
+      "MODEL_FILE = 'imagenet/imagenet_deploy.prototxt'\n",
+      "PRETRAINED = 'imagenet/caffe_reference_imagenet_model'\n",
+      "IMAGE_FILE = 'images/lena.png'"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Loading a network is easy. imagenet.ImagenetClassifier wraps everything. In default, the classifier will crop the center and corners of an image, as well as their mirrored versions, thus creating a batch of 10 images. If you look at the provided MODEL_FILE you can actually see that we are defining the input batch size to be 10.\n",
+      "\n",
+      "If you would like to just do the center, you need to specify center_only=1, and also change the batch size from 10 to 1 in the prototxt."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "net = imagenet.ImageNetClassifier(\n",
+      "    MODEL_FILE, PRETRAINED)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "We will set the phase to test since we are doing testing, and will first use CPU for the computation."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "net.caffenet.set_phase_test()\n",
+      "net.caffenet.set_mode_cpu()"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "So now, we can do a prediction. Let's show some output as well:"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "prediction = net.predict(IMAGE_FILE)\n",
+      "print 'prediction shape:', prediction.shape\n",
+      "pyplot.plot(prediction)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "prediction shape: (1000,)\n"
+       ]
+      },
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 4,
+       "text": [
+        "[<matplotlib.lines.Line2D at 0x8faf4d0>]"
+       ]
+      },
+      {
+       "metadata": {},
+       "output_type": "display_data",
+       "png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAHPFJREFUeJzt3W1wE+eBB/D/UuvKnUMhUMfYknvGtrDEix0nsgnNkFES\njGsuKIHkMm44kml9REPHSZtpk37o9YDMFPB0mCuJP9TlIE1DzvjuOhfTjtERh6gQglEJ5JyLycWm\ndpEFJgRwARMwFs992Ei2/LJa2ZJX2v3/ZjzWrp5dPftIfv569s2SEEKAiIgMa5rWFSAiIm0xCIiI\nDI5BQERkcAwCIiKDYxAQERkcg4CIyOCiBoHH44HNZoPVakVtbe2o55uamlBcXIySkhLce++9OHjw\noOpliYhIe5LSdQTBYBCFhYVoaWmB2WxGaWkpGhoaYLfbw2X6+/uRnp4OAPjoo4+wevVqdHZ2qlqW\niIi0pzgi8Pl8KCgoQG5uLkwmE6qqqtDU1BRRJhQCAHDt2jV8/etfV70sERFpTzEIAoEAcnJywtMW\niwWBQGBUubfeegt2ux2VlZV45ZVXYlqWiIi0pRgEkiSpWsljjz2GU6dO4Xe/+x3WrVsH3rWCiCh1\npCk9aTab4ff7w9N+vx8Wi2Xc8suWLcPg4CAuXboEi8WiatmCggKcPn16InUnIjKs/Px8dHZ2xmdl\nQsGtW7dEXl6e6OrqEjdv3hTFxcWivb09okxnZ6e4ffu2EEKIDz74QOTl5ale9ssD1UpVMJSNGzdq\nXYWkwbYYwrYYwrYYEs++U3FEkJaWhrq6OlRUVCAYDKK6uhp2ux319fUAALfbjd/+9rf4zW9+A5PJ\nhDvuuAN79+5VXJaIiJKLYhAAQGVlJSorKyPmud3u8OOXXnoJL730kupliYgoufDK4iTidDq1rkLS\nYFsMYVsMYVskhuIFZVNSAUniWUZERDGKZ9/JEQERkcExCIiIDI5BQERkcAwCIiKDYxAQERkcg4CI\nyOAYBEREBscgICIyOAYBEZHBMQiIiAyOQUBEZHAMAiIig2MQEBEZHIOAiMjgGARERAbHICAiMjgG\nARGRwTEIiIgMjkFARGRwDAIiIoNjEBARGRyDgIjI4BgEREQGxyAgIjI4BgERkcExCIhi8H//Bwih\ndS2I4itqEHg8HthsNlitVtTW1o56/s0330RxcTGKiopw//33o62tLfxcbm4uioqKUFJSgrKysvjW\nnEgDNhtw/LjWtSCKrzSlJ4PBIGpqatDS0gKz2YzS0lK4XC7Y7fZwmby8PBw6dAgzZ86Ex+PBs88+\ni9bWVgCAJEnwer2YPXt2YreCaArduKF1DYjiS3FE4PP5UFBQgNzcXJhMJlRVVaGpqSmizNKlSzFz\n5kwAwJIlS9DT0xPxvOA4mogoqSkGQSAQQE5OTnjaYrEgEAiMW37Xrl1YuXJleFqSJCxfvhwOhwM7\nd+6MQ3WJiCjeFHcNSZKkekXvvvsudu/ejSNHjoTnHTlyBFlZWbhw4QLKy8ths9mwbNmyideWiIji\nTjEIzGYz/H5/eNrv98NisYwq19bWhvXr18Pj8eDOO+8Mz8/KygIAZGRkYPXq1fD5fGMGwaZNm8KP\nnU4nnE5nrNtBRKRrXq8XXq83IeuWhMJO/MHBQRQWFuKdd95BdnY2ysrK0NDQEHGw+MyZM3jooYew\nZ88e3HfffeH5169fRzAYxIwZM9Df348VK1Zg48aNWLFiRWQFJInHEShlSBJw6BDAgS1pLZ59p+KI\nIC0tDXV1daioqEAwGER1dTXsdjvq6+sBAG63Gy+//DIuX76MDRs2AABMJhN8Ph96e3uxZs0aAHKg\nrF27dlQIECWSJMln+Hz1q1rXhCi5KY4IpqQCHBFQgkgS0NcHfHlSW9zWyREBJYN49p28spiIyOAY\nBEREBscgICIyOAYBEZHBMQiIiAyOQUBEZHAMAiIig2MQEBEZHIOAKEa8/pH0hkFARGRwDAKiGMVw\nd3ailMAgICIyOAYBEZHBMQiIiAyOQUBEZHAMAtKl0CmePNWTKDoGARGRwTEISJcSOSLgKIP0hkFA\nRGRwDALSJX5rJ1KPQUC6xkAgio5BQLqUyADgLSZIbxgEpGscERBFxyAgIjI4BgHpEi8oI1KPQUBE\nZHAMAtIlXlBGpB6DgIjI4BgEpEs8RkCkXtQg8Hg8sNlssFqtqK2tHfX8m2++ieLiYhQVFeH+++9H\nW1ub6mWJiEh7ikEQDAZRU1MDj8eD9vZ2NDQ04NSpUxFl8vLycOjQIbS1teGnP/0pnn32WdXLEiVK\nIkcEvKCM9EYxCHw+HwoKCpCbmwuTyYSqqio0NTVFlFm6dClmzpwJAFiyZAl6enpUL0tERNpTDIJA\nIICcnJzwtMViQSAQGLf8rl27sHLlygktSxRPPDZApF6a0pNSDGPgd999F7t378aRI0diXnbTpk3h\nx06nE06nU/WyREoYCKQXXq8XXq83IetWDAKz2Qy/3x+e9vv9sFgso8q1tbVh/fr18Hg8uPPOO2Na\nFogMAqJ4YACQ3oz8krx58+a4rVtx15DD4UBHRwe6u7sxMDCAxsZGuFyuiDJnzpzBmjVrsGfPHhQU\nFMS0LFGi8YIyougURwRpaWmoq6tDRUUFgsEgqqurYbfbUV9fDwBwu914+eWXcfnyZWzYsAEAYDKZ\n4PP5xl2WaCqwsyZSTxJC2z8ZSZKgcRVIh/r7gTvuAAIBIDs7fuuVJOAPfwAeeCB+6ySaiHj2nbyy\nmHSJ3y2I1GMQkK4xEIiiYxAQERkcg4B0ibeYIFKPQUBEZHAMAtIl3oaaSD0GARGRwTEISJc4EiBS\nj0FAusZbTBBFxyAgXWJnTaQeg4B0jYFAFB2DgHSJAUCkHoOAdI0XlBFFxyAgXeKIgEg9BgHpGgOB\nKDoGAekSA4BIPQYB6RoDgSg6BgHpUiIDgOFCesMgIF1jp00UHYOAiMjgGASkS7wNNZF6DAIiIoNj\nEJAu8a6jROoxCEjX2HkTRccgIF1K5IiA4UJ6wyAgXWOnTRQdg4B0iReUEanHICBdi2enzQAgvYoa\nBB6PBzabDVarFbW1taOe/+STT7B06VJMnz4d27dvj3guNzcXRUVFKCkpQVlZWfxqTRQFRwRE6qUp\nPRkMBlFTU4OWlhaYzWaUlpbC5XLBbreHy8yZMwevvvoq3nrrrVHLS5IEr9eL2bNnx7/mRCpwREAU\nneKIwOfzoaCgALm5uTCZTKiqqkJTU1NEmYyMDDgcDphMpjHXIfjXQxrgiIBIPcUgCAQCyMnJCU9b\nLBYEAgHVK5ckCcuXL4fD4cDOnTsnXkuiCeKIgCg6xV1D0iT/OeuRI0eQlZWFCxcuoLy8HDabDcuW\nLRtVbtOmTeHHTqcTTqdzUq9LxBEB6Y3X64XX603IuhWDwGw2w+/3h6f9fj8sFovqlWdlZQGQdx+t\nXr0aPp8vahAQxRNHBKQXI78kb968OW7rVtw15HA40NHRge7ubgwMDKCxsREul2vMsiOPBVy/fh1X\nr14FAPT39+PAgQNYvHhxnKpNpIydNpF6iiOCtLQ01NXVoaKiAsFgENXV1bDb7aivrwcAuN1u9Pb2\norS0FFeuXMG0adOwY8cOtLe347PPPsOaNWsAAIODg1i7di1WrFiR+C0iSjCGDOmNJDQ+rUeSJJ5Z\nRHHX0wPk5AD/+7/AwoXxWefNm8D06cDbbwPLl8dnnUQTFc++k1cWky7xYDGRegwC0jUeLCaKjkFA\nusQRAZF6DALSNY4IiKJjEJAucURApB6DgHSNIwKi6BgEpEvstInUYxCQriXyfxcT6QWDgHSJAUCk\nHoOAdI2BQBQdg4B0iQFApB6DgHSNgUAUHYOAdIkBQKQeg4AoRgwE0hsGAelSqLPmBWVE0TEIiGLE\nQCC9YRCQrrHTJoqOQUC6xIPFROoxCEjXGAhE0TEISJcYAETqMQhI1xgIRNExCEiXGABE6jEISNcY\nCETRMQhIlxgAROoxCEjXGAhE0TEISJcYAPr2y18Cn3+udS30g0FAFCMGgvY2bADefFPrWugHg4BS\nXlvb6HmJuOkckV5FDQKPxwObzQar1Yra2tpRz3/yySdYunQppk+fju3bt8e0LFE8FBcDt28n/nUY\nKqRXikEQDAZRU1MDj8eD9vZ2NDQ04NSpUxFl5syZg1dffRU/+tGPYl6WaLLG65wTOSJgIJDeKAaB\nz+dDQUEBcnNzYTKZUFVVhaampogyGRkZcDgcMJlMMS9LNFmhkQBHBEQTpxgEgUAAOTk54WmLxYJA\nIKBqxZNZlkit8b75c0RApF6a0pOSJE14xbEsu2nTpvBjp9MJp9M54dclY5nKg8IMANKS1+uF1+tN\nyLoVg8BsNsPv94en/X4/LBaLqhXHsuzwICCKRbQg4IiA9GLkl+TNmzfHbd2Ku4YcDgc6OjrQ3d2N\ngYEBNDY2wuVyjVlWjPjriGVZoomKtmsoEa9FpDeKI4K0tDTU1dWhoqICwWAQ1dXVsNvtqK+vBwC4\n3W709vaitLQUV65cwbRp07Bjxw60t7fjjjvuGHNZonjiiIBo8hSDAAAqKytRWVkZMc/tdocfz507\nN2IXULRlieJpKkcERHrFK4sppU3liIDhQnrFIKCUpsWIgIFAesMgoJQWupCMIwKiiWMQUErjiIBo\n8hgElNJCnTJvMUE0cQwCSmm8xQTR5DEIKKXxFhNEk8cgoJTGEQHR5DEIKKXxP5ERTR6DgFLaVI4I\nGDqkVwwCSmnsnIkmj0FAKU2LEQGR3jAIKKVFu7I4ERgIpDcMAkppvOkc0eQxCCil8RYTRJPHIKCU\nFu0WExwREEXHIKCUxhEB0eQxCCil8fRRosljEFBK4wVlRJPHIKCUxs6ZaPIYBJTSOCIwLknSugb6\nwSCglKbFBWVEesMgoJTGW0wYF9+P+GEQUErTYncNOyDSGwYBpTSOCIgmj0FAKW0q/3n9yNck0gsG\nAaU0Lf5VJZHeMAgopWnxz+sZLqQ3UYPA4/HAZrPBarWitrZ2zDLPP/88rFYriouLcfLkyfD83Nxc\nFBUVoaSkBGVlZfGrNdGXOCIgmrw0pSeDwSBqamrQ0tICs9mM0tJSuFwu2O32cJnm5mZ0dnaio6MD\nx44dw4YNG9Da2goAkCQJXq8Xs2fPTuxWkGFxREA0eYojAp/Ph4KCAuTm5sJkMqGqqgpNTU0RZfbt\n24dnnnkGALBkyRL09fXh/Pnz4ecF/2oogca7oIydNpF6ikEQCASQk5MTnrZYLAgEAqrLSJKE5cuX\nw+FwYOfOnfGsNxEAbUYERH/8o9Y1iC/FXUOSypt5jPet/7333kN2djYuXLiA8vJy2Gw2LFu2LPZa\nEo2DF5SRFsrKgGvXgPR0rWsSH4pBYDab4ff7w9N+vx8Wi0WxTE9PD8xmMwAgOzsbAJCRkYHVq1fD\n5/ONGQSbNm0KP3Y6nXA6nTFvCBkTLygjo/B6vfB6vQlZt2IQOBwOdHR0oLu7G9nZ2WhsbERDQ0NE\nGZfLhbq6OlRVVaG1tRWzZs1CZmYmrl+/jmAwiBkzZqC/vx8HDhzAxo0bx3yd4UFAFAuOCGiqaXX8\naeSX5M2bN8dt3YpBkJaWhrq6OlRUVCAYDKK6uhp2ux319fUAALfbjZUrV6K5uRkFBQVIT0/Ha6+9\nBgDo7e3FmjVrAACDg4NYu3YtVqxYEbeKEwE8fZSmnh4/W4pBAACVlZWorKyMmOd2uyOm6+rqRi2X\nl5eHDz/8cJLVI1I2lbeY0GMHkAoeeAD4138F5s+PnK/V/yMIBiN/6wGvLKaUxhGB/h0+LP8ki9CX\njqm8v1WiMQgopfGCMmNIpjZnEBAlGY4IjEur9za0S4hBQJQkpvJfVTJctJNM/5849JnjMQKiJMER\ngTEMfx+1fm+5a4goyfAWE8ajdRBw1xBRktFiRMBA0JbWQcBdQ0RJhiMC40mWIOCIgChJRBsRJPI1\nSRsMgvhjEFBKi3ZlMTtt/dE6CHiMgCjJTOWIQOsOiGRavw88RkCUZKJ1Cuy09SdZgoAjAqIkwQvK\njEfr94G7hoiSDC8oMx6t31vuGiJKMrzpnPFo/T5w1xBRkuGIwBiS6RYT3DVElGR4QZnxaB0EHBEQ\nJRneYsIYht99NFmCgMcIiJKE1p0CTQ3uGkosBgGltKkcESS6A/riC+DKlcSsO1WNdXqw1kHAXUNE\nSWYq/3l9oq1aBeTlaV2L5DLWbphkCQLuGiJKEuNdUJaKt5hobwcuXkzMulNVqLMd3ulq/Y1c69dP\nBAYBpTQ93WJCTx1LvIy1P17rEQGPERAlGT3ddE5PHUu8JPOuIT29XwwCSmnJPiLo7QXOnVNXVk8d\nS7yMtWsoWYJAT8cI0rSuANFkaDEiiIXDAdy4AXz+efSyoQ7m5k3gq1+N/bX0aKxv31oHgR53DTEI\nKKVpMSKIZZ29veq/OYY6lunTtR/JJItkHhHoKQi4a4iSztmzwIkT6somckRw7hxw+fLk1hGqRzAY\nPRD01LHESzIfI9DTrqGoQeDxeGCz2WC1WlFbWztmmeeffx5WqxXFxcU4efJkTMsSjbR2LXDvverK\nJnJEkJ0tn9uv9rWUrFoFOJ3KZYYHgZ46mcngWUNTQzEIgsEgampq4PF40N7ejoaGBpw6dSqiTHNz\nMzo7O9HR0YFf/epX2LBhg+plKZLX69W6Cknh2jUA8Koqm+hO4ezZyS0fqtc77wDvvadcdnjHcvXq\n0OOJfC4GB+XgUWqX//iP5N8FFep0X30V2LJFbovx3vNbt+Srs0c6diz0mVLP65XX/9xzo1/HcLuG\nfD4fCgoKkJubC5PJhKqqKjQ1NUWU2bdvH5555hkAwJIlS9DX14fe3l5Vy1IkBoHs1i1grCC4fRt4\n+eWxbzcw8o8yXgExlbc2GN6JfetbgN8vP57I56K3F/jDH8a/ZcWVK8CTTwKXLsnT164B//3fsXeY\niRZ6Xz//HPjJT8YPgmAQ+Id/AAoLgc8+G5r/pz8B990H/Mu/qN+2S5eABx8E/vxnoK5uqI1G1mn4\nwf2RrlyJHvzJRDEIAoEAcnJywtMWiwWBQEBVmbNnz0ZdlmgsAwNjz//Tn4CNG4HhH6Nf/lL+PV7n\n/PnnwNKlwL59yq8phNxR3LihXAcAePFF4NNPx39ekoA//jGyXsPvnjnST34CdHdHzjt2DHC5xr/S\n+Pr1yOkzZyLr3NMz9LuhATh9OrL8n/8c+fuf/kkOnxkz5AARQl7u4kXgK1+JHBn19QEtLUPTf/mL\nPOL5z/+UD3R///uj6xsIABcujL0tH38sH4tpbR3ahsOHgYMHx95FFmrTS5eAf/xHoLMTSEuTl/H7\ngcxMeUR0+jSQny+X/ed/BiyW0esa6xhQqE1CHfk990Q+P/wYwZYt8jaPtG0bsGzZ2NsbjRa7BRXP\nGpKUPr3DiEl+RaqslDf+9u2h38MfjzXv9m0gI0P+g7h6FZg5EzCZgE8+ARYvBv7mb0LbMFR++M/w\n9Sj9hMqlpwNZWZPazKg+/RQ4fjyxrxEPH3wALFwon+I41u2B1Rr58QotH9qDWF4uv0ZofqhTLCmR\n31+bTe6ALBbg+eeBXbvksv39cmcFAC+8IP9+9NGhdZpMcuf1V381dJrmuXPA//yP/Phb35I7F0Du\noB9+WF7v4cNDdX3iCbn+c+fKn8H0dGDatKFO4u//Hvjbvx0qH/rWeM89cnlJAmbNAu68E9i/H/i3\nfxvdPh9+CNjt8jr/67/kedOmyZ1lezuwaNHQ6x49Kj9fXCyPqEL1r66WQwWQvy3/9V/Ln+NQWz70\nEHD33UPbDsi7lO66S/5mPWuW/PpmM7B8uRwKXV3yZzU7G8jNlR8PPz32lVeAxkb51NnQ+9rcPPR6\nX/mKvA0DA/Lj4d+c582T39f9++XpBx6IbJPdu4fK//u/y+EdOrFg+PUaTufQiCrkL38B/u7v5O0J\nnaLr8ch1AuR2GxwcasvNm+XfZ87IbZSVJX8eQtv61FNyewLyekMkCfjoI/nxI4/I5WfPHv9vZfjj\nK1eA998HVq6U548c/Qgh90nD36+4EAqOHj0qKioqwtNbtmwR27ZtiyjjdrtFQ0NDeLqwsFD09vaq\nWlYIIfLz8wUA/vCHP/zhTww/+fn5St13TBRHBA6HAx0dHeju7kZ2djYaGxvR0NAQUcblcqGurg5V\nVVVobW3FrFmzkJmZiTlz5kRdFgA6Q19diIhIE4pBkJaWhrq6OlRUVCAYDKK6uhp2ux319fUAALfb\njZUrV6K5uRkFBQVIT0/Ha6+9prgsERElF0mIZD+BjIiIEknTK4uNdMGZ3+/Hgw8+iIULF2LRokV4\n5ZVXAACXLl1CeXk55s+fjxUrVqAvdJQTwNatW2G1WmGz2XDgwAGtqp4wwWAQJSUlWPXlVVtGbYu+\nvj488cQTsNvtWLBgAY4dO2bYtti6dSsWLlyIxYsX46mnnsLNmzcN0xbf/e53kZmZicWLF4fnTWTb\nP/jgAyxevBhWqxXfH+sUrrHE7WhDjAYHB0V+fr7o6uoSAwMDori4WLS3t2tVnYQ7d+6cOHnypBBC\niKtXr4r58+eL9vZ28eKLL4ra2lohhBDbtm0TP/7xj4UQQnz88ceiuLhYDAwMiK6uLpGfny+CwaBm\n9U+E7du3i6eeekqsWrVKCCEM2xZPP/202LVrlxBCiFu3bom+vj5DtkVXV5eYN2+euHHjhhBCiCef\nfFL8+te/NkxbHDp0SJw4cUIsWrQoPC+Wbb99+7YQQojS0lJx7NgxIYQQlZWVYv/+/VFfW7MgeP/9\n9yPOKtq6davYunWrVtWZco8++qh4++23w2dZCSGHRWFhoRBi9FlWFRUV4ujRo5rUNRH8fr94+OGH\nxcGDB8UjjzwihBCGbIu+vj4xb968UfON2BYXL14U8+fPF5cuXRK3bt0SjzzyiDhw4ICh2qKrqysi\nCGLd9rNnzwqbzRae39DQINxud9TX1WzXkJqL1fSqu7sbJ0+exJIlS3D+/HlkZmYCADIzM3H+/HkA\nwNmzZ2EZdgWM3trnhRdewM9//nNMmzb0ETRiW3R1dSEjIwPf+c53cM8992D9+vXo7+83ZFvMnj0b\nP/zhD/GNb3wD2dnZmDVrFsrLyw3ZFiGxbvvI+WazWVWbaBYEai9W05tr167h8ccfx44dOzBjxoyI\n5yRJUmwXvbTZ73//e9x1110oKSkZ92JEo7TF4OAgTpw4ge9973s4ceIE0tPTsW3btogyRmmL06dP\n4xe/+AW6u7tx9uxZXLt2DXv27IkoY5S2GEu0bZ8MzYLAbDbDP+zSP7/fH5FkenTr1i08/vjjWLdu\nHR577DEAcsr39vYCAM6dO4e77roLwOj26enpgdlsnvpKJ8D777+Pffv2Yd68efj2t7+NgwcPYt26\ndYZsC4vFAovFgtLSUgDAE088gRMnTmDu3LmGa4vjx4/jm9/8JubMmYO0tDSsWbMGR48eNWRbhMTy\nN2GxWGA2m9ETur8I1LeJZkEw/GK1gYEBNDY2wuVyaVWdhBNCoLq6GgsWLMAPfvCD8HyXy4XXX38d\nAPD666+HA8LlcmHv3r0YGBhAV1cXOjo6UFZWpknd423Lli3w+/3o6urC3r178dBDD+GNN94wZFvM\nnTsXOTk5+PTLmxe1tLRg4cKFWLVqleHawmazobW1FV988QWEEGhpacGCBQsM2RYhsf5NzJ07F1/7\n2tdw7NgxCCHwxhtvhJdRFI8DHBPV3Nws5s+fL/Lz88WWLVu0rErCHT58WEiSJIqLi8Xdd98t7r77\nbrF//35x8eJF8fDDDwur1SrKy8vF5cuXw8v87Gc/E/n5+aKwsFB4PB4Na584Xq83fNaQUdviww8/\nFA6HQxQVFYnVq1eLvr4+w7ZFbW2tWLBggVi0aJF4+umnxcDAgGHaoqqqSmRlZQmTySQsFovYvXv3\nhLb9+PHjYtGiRSI/P18899xzql6bF5QRERkc/1UlEZHBMQiIiAyOQUBEZHAMAiIig2MQEBEZHIOA\niMjgGARERAbHICAiMrj/BwQijf8bq9cnAAAAAElFTkSuQmCC\n",
+       "text": [
+        "<matplotlib.figure.Figure at 0x4739050>"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "You can see that the prediction is 1000-dimensional, and is pretty sparse. Our pretrained model uses the alphabetical order for the synsets, and if you look at the index that maximizes the prediction score, it is \"sombrero\". Reasonable prediction, right?\n",
+      "\n",
+      "Now, why don't we see how long it takes to perform the classification end to end? This result is run from an Intel i5 CPU, so you may observe some performance differences."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "%timeit net.predict(IMAGE_FILE)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "1 loops, best of 3: 194 ms per loop\n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "It may look a little slow, but note that it also includes image loading, cropping, and python interfacing time, and it is running 10 images. As a performance notice, if you really want to make prediction fast, you can optionally write things in C and also pipeline the image loading part. But for most applications, the current speed might be fine I guess?\n",
+      "\n",
+      "OK, so how about GPU? it is actually pretty easy:"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "net.caffenet.set_mode_gpu()"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Voila! Now we are in GPU mode. Let's see if the code gives the same result:"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "prediction = net.predict(IMAGE_FILE)\n",
+      "print 'prediction shape:', prediction.shape\n",
+      "pyplot.plot(prediction)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "prediction shape: (1000,)\n"
+       ]
+      },
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 7,
+       "text": [
+        "[<matplotlib.lines.Line2D at 0xee00e90>]"
+       ]
+      },
+      {
+       "metadata": {},
+       "output_type": "display_data",
+       "png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEACAYAAAC+gnFaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\niIgMjkFARGRwDAIiIoP7f/gBjf8BGVc/AAAAAElFTkSuQmCC\n",
+       "text": [
+        "<matplotlib.figure.Figure at 0x4745bd0>"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Good, everything is the same. And how about time consumption? The following benchmark is obtained on the same machine with a K20 GPU:"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "%timeit net.predict(IMAGE_FILE)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "10 loops, best of 3: 50 ms per loop\n"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Pretty fast right? Not as fast as you expected? Indeed, in this python demo you are seeing only 4 times speedup. But remember - the GPU code is actually very fast, and the data loading, transformation and interfacing actually start to take **more** time than the actual convnet computation itself!\n",
+      "\n",
+      "To fully utilize the power of GPUs, you really want to use one of these ideas:\n",
+      "* Use larger batches, and minimize python call and data transfer overheads.\n",
+      "* Pipeline data load operations, like using a subprocess.\n",
+      "* Code in C++. A little inconvenient, but maybe worth it if your dataset is really, really large."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Parting Words\n",
+      "-------------\n",
+      "\n",
+      "So this is python! We hope the interface is easy enough for one to use. The python wrapper is interfaced with boost::python, and source code can be found at `python/caffe/imagenet`. If you would like to achieve some custom functions, you are more than welcome to look at them!"
+     ]
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file

diff --git a/data/cat.jpg b/examples/images/cat.jpg
similarity index 100%
rename from data/cat.jpg
rename to examples/images/cat.jpg

diff --git a/examples/images/lena.png b/examples/images/lena.png
new file mode 100644 (file)
index 0000000..59ef68a
Binary files /dev/null and b/examples/images/lena.png differ

diff --git a/matlab/caffe/matcaffe_demo.m b/matlab/caffe/matcaffe_demo.m
index c034172f59ed384859453a8a617b644c49199d56..8b13e07a7bba8254483b226895407f48ef238c7a 100644 (file)
--- a/matlab/caffe/matcaffe_demo.m
+++ b/matlab/caffe/matcaffe_demo.m
@@ -16,7 +16,7 @@ function scores = matcaffe_demo(im, use_gpu)
 % Or the equivalent based on where things are installed on your system
 %
 % Usage:
-%  im = imread('../../examples/cat.jpg');
+%  im = imread('../../examples/images/cat.jpg');
 %  scores = matcaffe_demo(im, 1);
 %  [score, class] = max(scores);
 

diff --git a/src/caffe/test/test_images_layer.cpp b/src/caffe/test/test_images_layer.cpp
index 755d47bf1b7d22c8a7a3bab45345ddcf2c6775d9..594a654de4285ae49db421fb96d6e22038777d7d 100644 (file)
--- a/src/caffe/test/test_images_layer.cpp
+++ b/src/caffe/test/test_images_layer.cpp
@@ -36,7 +36,7 @@ class ImagesLayerTest : public ::testing::Test {
     std::ofstream outfile(filename, std::ofstream::out);
     LOG(INFO) << "Using temporary file " << filename;
     for (int i = 0; i < 5; ++i) {
-      outfile << "data/cat.jpg " << i;
+      outfile << "examples/images/cat.jpg " << i;
     }
     outfile.close();
   }