2021-07-21-vw-tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vowpal Wabbit Tutorial\n",
    "\n",
    "[Vowpal Wabbit (VW)](https://vowpalwabbit.org/) is a fast online machine learning (ML) library.\n",
    "\n",
    "VW is extremely useful as a baseline for us at Sisu because it is one of the few open source approaches to fitting linear (and polynomial) models which supports the scale and parallelism for our data sets.\n",
    "\n",
    "The focus of this tutorial will be purely on the high-level basics of working with VW in a supervised ML setting and mostly about parallelizing its training procedure.\n",
    "\n",
    "Lots of great resources on VW already exist to cover scope outside of this:\n",
    "\n",
    " - A [python interface tutorial](https://vowpalwabbit.org/) \n",
    " - The full [Github wiki](https://github.com/VowpalWabbit/vowpal_wabbit/wiki)\n",
    " - Amazing NLP [examples](https://github.com/hal3/vwnlp)\n",
    " - A [functionality overview](https://www.zinkov.com/posts/2013-08-13-vowpal-tutorial/)\n",
    " - Feature [hashing](https://arxiv.org/abs/0902.2206)\n",
    " - Installation\n",
    " \n",
    "VW is a very generic and flexible system for reinforcement learning, recommendations, learning-to-search-based structured output prediction, active learning, and topic modelling."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics\n",
    "\n",
    "We'll use the [RCV1](https://www.jmlr.org/papers/v5/lewis04a.html) dataset, which contains\n",
    "\n",
    " - normalized [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) features for news articles\n",
    " - a manual classification of the topic of each article\n",
    " \n",
    "For simplicity we use the libsvm preprocessed datasets, with positive labels corresponding to CCAT (Corporate category) or ECAT (Economic category) and negative to GCAT (Goverment category) or MCAT (Markets category). In principle we'd want to model the full multiclass problem here (and VW is capable of doing so) but since the focus of this tutorial is on performance and parallel processing rather than preprocessing, we will be using the binary problem. That said---hopefully the utility of a classifier like this is clear. If you've ever filed a JIRA or Asana ticket, you probably had an easy time filling in the natural language description but found the tagging and prioritization field entry a chore.\n",
    "\n",
    "Note further, that for the same reason, I'll use a different train/test split than usually applied to RCV1 to make training harder (i.e., larger train set). This is not standard for RCV1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    677399 rcv1_test.binary\n",
      "     20242 rcv1_train.binary\n",
      "    697641 total\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "mkdir -p vw-tutorial\n",
    "cd vw-tutorial\n",
    "\n",
    "train=https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/binary/rcv1_train.binary.bz2\n",
    "test=https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/binary/rcv1_test.binary.bz2\n",
    "test -f rcv1_train.binary.bz2 || test -f rcv1_train.binary || curl  -s $train -o rcv1_train.binary.bz2 &\n",
    "test -f rcv1_test.binary.bz2 || test -f rcv1_test.binary || curl -s $test -o rcv1_test.binary.bz2 &\n",
    "wait\n",
    "\n",
    "test -f rcv1_train.binary || bunzip2 rcv1_train.binary.bz2 &\n",
    "test -f rcv1_test.binary || bunzip2 rcv1_test.binary.bz2 &\n",
    "wait\n",
    "\n",
    "wc -l rcv1*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, we've downloaded our datasets and are ready to chop them up so that we have a larger train set (to evaluate how performance improves). While we're at it, let's format these text files into something VW expects.\n",
    "\n",
    "Right now, they're in libsvm format, which is\n",
    "\n",
    "```\n",
    "target feature1:value feature2:value ...\n",
    "```\n",
    "\n",
    "Where features are integers and for binary problems the target is `-1` or `+1`. Vowpal wabbit has a far more flexible format, which allows weighing examples, tagging examples, namespacing features, and having non-integer feature keys. Feature hashing has very interesting implications for ML, but at this level we can view it as a convenience for not needing to specify which feature maps to which index up-front.\n",
    "\n",
    "VW supports binary classification through logistic regression. The most basic VW input format (with no feature namespaces, tags, default-valued features, or weights) looks like\n",
    "\n",
    "```\n",
    "target | feature1:value feature2:value...\n",
    "```\n",
    "\n",
    "and in our problem needs a binary target (also positive/negative 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "libsvm format\n",
      "1 440:0.033906222568727 730:0.0424739279722748 1523:0.0773048148348295 1893:0.04...\n",
      "1 271:0.0646290650479301 405:0.0653366028581683 584:0.0744087075001463 770:0.071...\n",
      "1 577:0.0679078686536282 761:0.0506946081073312 1523:0.0487487662585784 1897:0.0...\n",
      "vw format\n",
      "+1 | 440:0.033906222568727 730:0.0424739279722748 1523:0.0773048148348295 1893:0...\n",
      "+1 | 271:0.0646290650479301 405:0.0653366028581683 584:0.0744087075001463 770:0....\n",
      "+1 | 577:0.0679078686536282 761:0.0506946081073312 1523:0.0487487662585784 1897:...\n",
      "    500000 shuf.vw\n",
      "    197641 test.vw\n",
      "    500000 train.vw\n",
      "   1197641 total\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cd vw-tutorial\n",
    "\n",
    "echo \"libsvm format\"\n",
    "head -3 rcv1_train.binary | cut -c-80 | sed 's/$/.../'\n",
    "\n",
    "cat rcv1_train.binary rcv1_test.binary \\\n",
    "  | sed 's/^-1/-1 |/' \\\n",
    "  | sed 's/^0/-1 |/' \\\n",
    "  | sed 's/^+1/+1 |/' \\\n",
    "  | sed 's/^1/+1 |/' \\\n",
    "  | head -n 500000 > train.vw\n",
    "  \n",
    "\n",
    "cat rcv1_train.binary rcv1_test.binary \\\n",
    "  | sed 's/^-1/-1 |/' \\\n",
    "  | sed 's/^0/-1 |/' \\\n",
    "  | sed 's/^+1/+1 |/' \\\n",
    "  | sed 's/^1/+1 |/' \\\n",
    "  | tail -n +500001 > test.vw\n",
    "  \n",
    "echo \"vw format\"\n",
    "head -3 train.vw | cut -c-80 | sed 's/$/.../'\n",
    "  \n",
    "wc -l *.vw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we jump into VW usage, we can get a sense of our dataset beyond the train/test size by asking\n",
    "\n",
    " - what's the number of features\n",
    " - what's the average number of nonzeros per row\n",
    " - what's the pos/neg breakdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "words 36655000\n",
      "lines 500000\n",
      "avg nnz 73\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cd vw-tutorial\n",
    "\n",
    "words=$(parallel --pipepart 'cut -f3- -d\" \" | wc -w' :::: train.vw | datamash sum 1)\n",
    "lines=$(parallel --pipepart 'cut -f3- -d\" \" | wc -l' :::: train.vw | datamash sum 1)\n",
    "\n",
    "echo \"words $words\"\n",
    "echo \"lines $lines\"\n",
    "echo \"avg nnz $(( $words / $lines ))\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "47236\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cd vw-tutorial\n",
    "\n",
    "parallel --pipepart '\n",
    "cut -f3- -d\" \" \\\n",
    "| sed -E '\"'\"'s/([0-9]+):\\S+/\\1/g'\"'\"' \\\n",
    "| tr \" \" \"\\n\" \\\n",
    "| datamash max 1' :::: train.vw | datamash max 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "neg 234187 (46%)\n",
      "pos 265813 (53%)\n",
      "lines 500000\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cd vw-tutorial\n",
    "\n",
    "negs=$(parallel --pipepart grep -c \"^-1\" :::: train.vw | datamash sum 1)\n",
    "poss=$(parallel --pipepart grep -c \"^+1\" :::: train.vw | datamash sum 1)\n",
    "lines=$(parallel --pipepart 'cut -f3- -d\" \" | wc -l' :::: train.vw | datamash sum 1)\n",
    "\n",
    "echo \"neg $negs ($(($negs * 100 / $lines))%)\"\n",
    "echo \"pos $poss ($(($poss * 100 / $lines))%)\"\n",
    "echo \"lines $lines\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time to train!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "# RECOMMENDED -- run in command line to see output\n",
    "exit 0\n",
    "\n",
    "cd vw-tutorial\n",
    "\n",
    "# --bit_precision / -b defaults to 18, or 2^18. Default ints are unhashed so this is plenty\n",
    "# for our tiny little 47K dimensional problem, in fact we can downgrade to 16 bits\n",
    "\n",
    "# --loss_function defaults to square loss, but in our case we want logistic. We could do hinge.\n",
    "\n",
    "# --final_regressor / -f writes the output model after training to a file\n",
    "\n",
    "vw --bit_precision 16 --loss_function logistic --final_regressor b16o1.model train.vw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpreting VW output: running under default as above does _no_ shuffling of the data and runs a single online pass through the dataset. In typical online convex optimization fashion, this relies on a standard square-root decay in learning rate, but this is controllable through various parameters.\n",
    "\n",
    "By default, VW's online update has lots of extra bells and whistles (adaptivity based on AdaGrad, normalization based on [normalized online gradient](http://www.cs.cmu.edu/~sross1/publications/uai13_normalized.pdf), weighted steps based on an invariant [continuous differential equation](https://arxiv.org/abs/1011.1576) solve), which we won't touch on here. The code is freely [available](https://github.com/VowpalWabbit/vowpal_wabbit/blob/master/vowpalwabbit/gd.cc).\n",
    "\n",
    "```\n",
    "final_regressor = b16o1.model\n",
    "Num weight bits = 16\n",
    "learning rate = 0.5\n",
    "initial_t = 0\n",
    "power_t = 0.5\n",
    "using no cache\n",
    "Reading datafile = train.vw\n",
    "num sources = 1\n",
    "average  since         example        example  current  current  current\n",
    "loss     last          counter         weight    label  predict features\n",
    "0.693147 0.693147            1            1.0   1.0000   0.0000      182\n",
    "0.579074 0.465001            2            2.0   1.0000   0.5242      142\n",
    "0.722714 0.866353            4            4.0  -1.0000   0.8827      145\n",
    "0.640078 0.557442            8            8.0  -1.0000  -0.9066      198\n",
    "0.640367 0.640657           16           16.0  -1.0000  -1.7261      190\n",
    "0.554364 0.468360           32           32.0   1.0000   0.2800       32\n",
    "0.485971 0.417578           64           64.0  -1.0000  -0.1567       66\n",
    "0.461202 0.436432          128          128.0   1.0000   1.6216      150\n",
    "0.421228 0.381255          256          256.0  -1.0000  -0.3880      126\n",
    "0.355553 0.289877          512          512.0   1.0000   1.4453       30\n",
    "0.336748 0.317943         1024         1024.0  -1.0000  -0.2843      101\n",
    "0.291487 0.246226         2048         2048.0   1.0000   0.5170       70\n",
    "0.248249 0.205011         4096         4096.0   1.0000   4.6111       67\n",
    "0.202177 0.156104         8192         8192.0   1.0000   3.3094       38\n",
    "0.169778 0.137379        16384        16384.0  -1.0000  -2.1202      116\n",
    "0.142966 0.116154        32768        32768.0   1.0000   5.1527       37\n",
    "0.123728 0.104490        65536        65536.0  -1.0000  -7.0800      108\n",
    "0.104505 0.085282       131072       131072.0   1.0000   8.0332       64\n",
    "0.093636 0.082766       262144       262144.0  -1.0000  -5.0297      109\n",
    "\n",
    "finished run\n",
    "number of examples per pass = 500000\n",
    "passes used = 1\n",
    "weighted example sum = 500000.000000\n",
    "weighted label sum = 31626.000000\n",
    "average loss = 0.084595\n",
    "best constant = 0.126673\n",
    "best constant's loss = 0.691145\n",
    "total feature number = 37155000\n",
    "```\n",
    "To discuss: all columns / values above. Note loss here is based on [progressive validation](https://www.cs.cmu.edu/~jcl/papers/progressive_validation/coltfinal.pdf) while in this online mode.\n",
    "\n",
    "This online mode showcase the speed of VW: 0.5M examples in a few seconds!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation\n",
    "\n",
    "Running VW in `--testonly` mode lets us evaluate our existing model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#!/bin/bash\n",
      "# Usage: bash vw-eval.sh cwd model testfile cache\n",
      "\n",
      "cd \"$1\"\n",
      "\n",
      "model=\"$2\"\n",
      "testfile=\"$3\"\n",
      "cache=\"$4\"\n",
      "\n",
      "acc=$(vw --binary --testonly --cache_file \"${testfile}.${cache}\" -i \"$model\" \"$testfile\" 2>&1 | grep \"average loss\" | cut -d\"=\" -f2)\n",
      "acc=$(echo \"$acc\" | awk '{printf \"%.6f\\n\", 1-$1}')\n",
      "echo \"acc     $acc\"\n",
      "\n",
      "logloss=$(vw --loss_function logistic --testonly --cache_file \"${testfile}.${cache}\" -i \"$model\" \"$testfile\" 2>&1 \\\n",
      "    | grep \"average loss\" | cut -d\"=\" -f2 )\n",
      "logloss=$(echo \"$logloss\" | awk '{printf \"%.6f\\n\", $0}')\n",
      "echo \"logloss $logloss\"\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "cat vw-eval.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train\n",
      "acc     0.979274\n",
      "logloss 0.065122\n",
      "test\n",
      "acc     0.975162\n",
      "logloss 0.076964\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "echo \"train\"\n",
    "bash vw-eval.sh vw-tutorial b16o1.model train.vw b16.cache\n",
    "echo \"test\"\n",
    "bash vw-eval.sh vw-tutorial b16o1.model test.vw b16.cache\n",
    "\n",
    "# RECOMMENDED -- run below in command line to see output\n",
    "exit 0\n",
    "\n",
    "cd vw-tutorial\n",
    "\n",
    "# --initial_regressor / -i sets the initial model, both for warm starts and testing\n",
    "# --testonly indicates that we shouldn't be doing any training\n",
    "# --binary gives classification accuracy vs. logistic loss\n",
    "vw --loss_function logistic --testonly -i b16o1.model test.vw\n",
    "vw --binary --testonly -i b16o1.model test.vw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Passes and Caching\n",
    "\n",
    "We can see above that single-pass VW does a pretty good job at not overfitting. Since the learning rate tunes down, we could still reasonable still get some perf improvements with more passes.\n",
    "\n",
    "Since we're passing over the dataset multiple times, it's worthwhile to cache the parsed dataset.\n",
    "\n",
    "VW typically has a parser thread and core update thread. The parser thread can easily end up dominating runtime! It's responsible for taking an example line in the above format and parse it into a sparse vector corresponding to the active features in each line.\n",
    "\n",
    "We tell VW to create (and re-use) a cache file with pre-parsed lines in an internal binary format. `-c / --cache` specifies to use a cache file at train + `.cache` (as opposed to a directed location `--cache_file`) and `-k / --kill_cache` clears it on re-runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no cache\n",
      "5.10 sec\n",
      "create cache\n",
      "5.63 sec\n",
      "reuse cache\n",
      "0.84 sec\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "cd vw-tutorial\n",
    "\n",
    "echo \"no cache\"\n",
    "/usr/bin/time -f \"%e sec\" bash -c 'vw -b 16 --loss_function logistic train.vw 2>/dev/null' 2>&1\n",
    "echo \"create cache\"\n",
    "/usr/bin/time -f \"%e sec\" bash -c 'vw -c -k -b 16 --loss_function logistic train.vw 2>/dev/null' 2>&1\n",
    "echo \"reuse cache\"\n",
    "/usr/bin/time -f \"%e sec\" bash -c 'vw -c -b 16 --loss_function logistic train.vw 2>/dev/null' 2>&1\n",
    "\n",
    "# RECOMMENDED - run in command line\n",
    "exit 0\n",
    "\n",
    "/usr/bin/time -f \"%e sec\" vw --cache --passes 100 --bit_precision 16 \\\n",
    "  --loss_function logistic --final_regressor b16o1p10.model train.vw"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In multi-pass mode, VW will use a holdout by using every 10th example as a validation example. This is used by default for early stopping (in the sample output, notice the `h` indicating as much). All of these options are configurable.\n",
    "\n",
    "Notice that when we consider just a regular order-1 model, extra training doesn't buy us much. Note that if we wanted to train a linear regression to convergence on a full dataset without validation, we'd need to loop over a single pass invocation, using `-i` to specify the previous warm start, `--holdout_off` to use the full set, and check for progressive validation loss convergence (which in this case would be equal to a lagged train loss)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train\n",
      "acc     0.985144\n",
      "logloss 0.046969\n",
      "test\n",
      "acc     0.975703\n",
      "logloss 0.074126\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "echo \"train\"\n",
    "bash vw-eval.sh vw-tutorial b16o1p100.model train.vw b16.cache\n",
    "echo \"test\"\n",
    "bash vw-eval.sh vw-tutorial b16o1p100.model test.vw b16.cache"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Higher Degrees and Regularization\n",
    "\n",
    "To push to a more sophisticated model, we can consider `-q / --quadratic` features between every pair `::` (can be used to restrict to cross terms between certain namespaces.\n",
    "\n",
    "At this point we need to start considering some regularization, `--l1` or `--l2`.\n",
    "\n",
    "Further, we'll introduce `--hash all` (instead of default `strings`) which hashes the order-1 features as well as higher-order features into a larger bit vector. I like to turn this on for higher-degree polynomials since the default mapping of order-1 features ensures no collisions on the order-1s, which may not actually be what we want to optimize for if a lot of the order-1 features are null."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "acc     0.980394\n",
      "logloss 0.071671\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "real\t1m35.755s\n",
      "user\t1m49.573s\n",
      "sys\t0m2.862s\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "# typically requires a minute or so\n",
    "pushd vw-tutorial >/dev/null\n",
    "time vw --hash all -q :: -b 20 --loss_function logistic -f b20o2.model \\\n",
    "  --l1 1e-6 --l2 1e-6 \\\n",
    "  --cache_file train.vw.b20.cache train.vw 2>/dev/null\n",
    "popd >/dev/null\n",
    "bash vw-eval.sh vw-tutorial b20o2.model test.vw b20.cache"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A couple things to note here: the regularization constant is *per datapoint*, so we need to divide our typical setting by the dataset size. Also, it takes a *long while* to train, even with one pass, because of the quadratic feature expansion, but we are paid off with a bit of accuracy improvement.\n",
    "\n",
    "You can see the parser + runner threads at work in htop!\n",
    "\n",
    "Even more interesting option (not sure how sensible it is to parallelize though, that might break guarantees) is `--stage_poly`, but that's a bit advanced. See the relatively unknown [apple](https://arxiv.org/abs/1410.0440) paper."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VW Parallelization\n",
    "\n",
    "OK, but say we want to have it all: higher-order polynomials and fast (since higher order kernel evaluation is expensive). VW comes with a super cool shared-nothing process-based paralellism system, which you can run on shards of your dataset.\n",
    "\n",
    "Every so often, e.g., between epochs, an all-reduce operation is run, averaging the weights (it's a little more clever than that, in that you have adaptive learning rates, but essentially it's averaging). The critical operation here is summing up the coefficient vectors across all active nodes.\n",
    "\n",
    "![all reduce semantics](https://tech.preferred.jp/wp-content/uploads/2018/07/fig_1.png)\n",
    "\n",
    "There are lots of way of implementing all-reduce (in multi-GPU neural network training, such as in Horovod, the minimal-communication \"ring\" pattern is used, which passes an accumulator in a ring across all GPUs, albeit requiring a linear latency). For linear coefficient vectors there's less of a throughput bottleneck due to weight transfer being smaller, so the higher-communication but lower-latency tree reduce is used.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"data:image/png;base64,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\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Paper link](https://jmlr.org/papers/volume15/agarwal14a/agarwal14a.pdf).\n",
    "\n",
    "In order to set up the tree hierarchy and manage synchronization, individual VW nodes need to be set up against a span server.\n",
    "\n",
    "Moreover, we need to preprocess the dataset a bit to split it up into chunks. But after that, we're home free! Notice that in typicall allreduce fashion, all nodes emit their own copies of the final model, so we need to make sure they won't all write over each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "njobs 32\n",
      "shuf.vw\n",
      "train.vw.00\n",
      "train.vw.01\n",
      "train.vw.02\n",
      "train.vw.03\n",
      "train.vw.04\n",
      "train.vw.05\n",
      "train.vw.06\n",
      "train.vw.07\n",
      "train.vw.08\n",
      "train.vw.09\n",
      "train.vw.10\n",
      "train.vw.11\n",
      "train.vw.12\n",
      "train.vw.13\n",
      "train.vw.14\n",
      "train.vw.15\n",
      "train.vw.16\n",
      "train.vw.17\n",
      "train.vw.18\n",
      "train.vw.19\n",
      "train.vw.20\n",
      "train.vw.21\n",
      "train.vw.22\n",
      "train.vw.23\n",
      "train.vw.24\n",
      "train.vw.25\n",
      "train.vw.26\n",
      "train.vw.27\n",
      "train.vw.28\n",
      "train.vw.29\n",
      "train.vw.30\n",
      "train.vw.31\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "cd vw-tutorial\n",
    "\n",
    "mkdir -p sharded-files\n",
    "cd sharded-files\n",
    "rm *\n",
    "\n",
    "njobs=$(nproc)\n",
    "echo \"njobs $njobs\"\n",
    "shuf ../train.vw > shuf.vw\n",
    "\n",
    "split -n l/$njobs -a 2 -d shuf.vw train.vw.\n",
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "\n",
    "# sets up spanning tree server on some default port\n",
    "\n",
    "nohup spanning_tree >/tmp/span.out 2>/tmp/span.err &\n",
    "\n",
    "# then tail -f /tmp/span.err"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# unique identifier for the job (the span server supports multiple jobs at once)\r\n",
      "jobid=\"$RANDOM\"\r\n",
      "\r\n",
      "cd vw-tutorial\r\n",
      "cd sharded-files\r\n",
      "\r\n",
      "njobs=$(nproc)\r\n",
      "\r\n",
      "# use gnu parallel to generate commands\r\n",
      "\r\n",
      "cmd=\"vw --bit_precision 24 --loss_function logistic\"\r\n",
      "# cmd=\"$cmd --kill_cache --cache --passes 10\"\r\n",
      "cmd=\"$cmd -q :: --l2 1e-6 --l1 1e-6 --hash all --holdout_off\"\r\n",
      "cmd=\"$cmd --node {} --unique_id ${jobid} \"\r\n",
      "cmd=\"$cmd --span_server localhost --total ${njobs}\"\r\n",
      "\r\n",
      "start=$(date +%s.%N)\r\n",
      "# only ask the head node to persist the model\r\n",
      "seq -f \"%02g\" 0 $(($njobs - 1)) | parallel --lb '\r\n",
      "  if [ {} -eq 0 ] ; then\r\n",
      "      extra_args=\"--final_regressor parallel.model\"\r\n",
      "  fi\r\n",
      "  echo \"node {} reporting for duty\"\r\n",
      "  '\"$cmd\"' train.vw.{} ${extra_args} 2>/dev/null'\r\n",
      "end=$(date +%s.%N)\r\n",
      "\r\n",
      "dt=$(echo \"$end - $start\" | bc)\r\n",
      "echo \"train_sec $dt\"\r\n"
     ]
    }
   ],
   "source": [
    "! cat vw-train.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an exercise: do parallel prediction too (requires some new flags we haven't seen, `parallel`, and other tools)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "node 18 reporting for duty\n",
      "node 02 reporting for duty\n",
      "node 30 reporting for duty\n",
      "node 27 reporting for duty\n",
      "node 23 reporting for duty\n",
      "node 28 reporting for duty\n",
      "node 04 reporting for duty\n",
      "node 17 reporting for duty\n",
      "node 06 reporting for duty\n",
      "node 01 reporting for duty\n",
      "node 22 reporting for duty\n",
      "node 24 reporting for duty\n",
      "node 19 reporting for duty\n",
      "node 00 reporting for duty\n",
      "node 03 reporting for duty\n",
      "node 10 reporting for duty\n",
      "node 05 reporting for duty\n",
      "node 12 reporting for duty\n",
      "node 16 reporting for duty\n",
      "node 29 reporting for duty\n",
      "node 11 reporting for duty\n",
      "node 13 reporting for duty\n",
      "node 21 reporting for duty\n",
      "node 25 reporting for duty\n",
      "node 08 reporting for duty\n",
      "node 15 reporting for duty\n",
      "node 07 reporting for duty\n",
      "node 14 reporting for duty\n",
      "node 20 reporting for duty\n",
      "node 09 reporting for duty\n",
      "node 26 reporting for duty\n",
      "node 31 reporting for duty\n",
      "train_sec 34.944436968\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "bash vw-train.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "acc     0.963424\n",
      "logloss 0.288551\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "\n",
    "bash vw-eval.sh vw-tutorial sharded-files/parallel.model test.vw b24.cache"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because parallel evaluation performs averaging, it won't do as well as single-threaded evaluation. However, for `--cubic`, we often have no choice but to leverage parallelism because of how long each example takes to evaluate.\n",
    "\n",
    "Notice how we're able to train faster than the original quadratic but get worse accuracy."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}