00 Basic solver usage.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pycaffe tutorial\n",
    "\n",
    "This tutorial assumes that you already know how to use Caffe. If you don't,\n",
    "consult the official caffe tutorials at:\n",
    "- http://caffe.berkeleyvision.org/tutorial/\n",
    "- http://caffe.berkeleyvision.org/gathered/examples/mnist.html\n",
    "\n",
    "Also assumed is a basic knowledge of Python. If it is not the case, have a look\n",
    "at the official python tutorials here: https://docs.python.org/2/tutorial/\n",
    "\n",
    "Caffe uses Python 2.7, make sure you use are using the correct version by running\n",
    "\n",
    "`$ python --version`\n",
    "\n",
    "\n",
    "\n",
    "The objective of this tutorial is to present basic and more advanced uses of\n",
    "the pycaffe interface, to use Caffe with Python.\n",
    "\n",
    "In this part of the tutorial, we will learn to start a standard training of\n",
    "Caffe, with Python.  We will be using the data/networks provided in\n",
    "http://caffe.berkeleyvision.org/gathered/examples/mnist.html\n",
    "\n",
    "Set the following variable to your caffe root:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "CAFFE_ROOT=\"/caffe\"\n",
    "\n",
    "import os\n",
    "os.chdir(CAFFE_ROOT) # change the current directory to the caffe root, to help\n",
    "                     # with the relative paths"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step is to import the caffe library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import caffe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we decide whether to use CPU or GPU for the training.\n",
    "\n",
    "Training with a GPU\n",
    "is faster, if the layers provide a GPU implementation. If you don't have a\n",
    "compatible graphics card or your layers are not implemented for GPU, use the\n",
    "CPU mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized caffe\n"
     ]
    }
   ],
   "source": [
    "USE_GPU = True\n",
    "\n",
    "if USE_GPU:\n",
    "    caffe.set_device(0) # Or the index of the GPU you want to use\n",
    "    caffe.set_mode_gpu()\n",
    "    # Multi-GPU training is not available from Python, see\n",
    "    # https://github.com/BVLC/caffe/issues/2936\n",
    "else:\n",
    "    caffe.set_mode_cpu()\n",
    "\n",
    "print(\"Initialized caffe\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, as we have a solver file, we will load it (paths are relative to the caffe root)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "solver_file = \"examples/mnist/lenet_solver.prototxt\"\n",
    "\n",
    "solver = caffe.SGDSolver(solver_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, just run the training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "solver.solve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Your network is now trained, and ready to go! The output is in `examples/mnist/lenet_iter_10000.caffemodel`.\n",
    "\n",
    "If you want to resume training from a snapshot, it's very simple too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "snapshot_file = \"examples/mnist/lenet_iter_5000.solverstate\"\n",
    "solver.solve(snapshot_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And there you go! This is the Python equivalent of\n",
    "`example/mnist/train_lenet.sh`, or\n",
    "\n",
    "`$ caffe train --solver=examples/mnist/lenet_solver.prototxt`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can always consult at which iteration a solver is, with `solver.iter`. You can take a snapshot of the solver with `solver.snapshot(file)`, and load it with `solver.restort(file)`. You can choose to move step-by-step with `solver.step(step_num)`.\n",
    "\n",
    "The underlying nets can be accessed with `solver.net` for the training net, and `solver.test_nets` for the testing nets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But you can do much more than that with python, you don't have to use a pre-made solver limiting your possibilities. The next part covers network manipulation."
   ]
  }
 ],
 "metadata": {
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}