linear-regression-map-reduce/linear_regression_map_reduce.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Acknowledgement \n",
    "This is based on [this wonderful post](https://freakonometrics.hypotheses.org/53269), but adapted to a \"tidy\" approach for coding in R. Therefore we start by ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading required package: tidyverse\n",
      "── Attaching packages ─────────────────────────────────────── tidyverse 1.2.1 ──\n",
      "✔ ggplot2 3.0.0     ✔ purrr   0.2.5\n",
      "✔ tibble  1.4.2     ✔ dplyr   0.7.6\n",
      "✔ tidyr   0.8.1     ✔ stringr 1.3.1\n",
      "✔ readr   1.1.1     ✔ forcats 0.3.0\n",
      "── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──\n",
      "✖ dplyr::filter() masks stats::filter()\n",
      "✖ dplyr::lag()    masks stats::lag()\n"
     ]
    }
   ],
   "source": [
    "require(tidyverse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Background\n",
    "TBD (you can find the details in the original [post](https://freakonometrics.hypotheses.org/53269))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# R's built-in function\n",
    "For reference, this is the result of the built-in R function `lm`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<dl class=dl-horizontal>\n",
       "\t<dt>(Intercept)</dt>\n",
       "\t\t<dd>-17.5790948905109</dd>\n",
       "\t<dt>speed</dt>\n",
       "\t\t<dd>3.93240875912408</dd>\n",
       "</dl>\n"
      ],
      "text/latex": [
       "\\begin{description*}\n",
       "\\item[(Intercept)] -17.5790948905109\n",
       "\\item[speed] 3.93240875912408\n",
       "\\end{description*}\n"
      ],
      "text/markdown": [
       "(Intercept)\n",
       ":   -17.5790948905109speed\n",
       ":   3.93240875912408\n",
       "\n"
      ],
      "text/plain": [
       "(Intercept)       speed \n",
       " -17.579095    3.932409 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "lm(dist~speed,data=cars)$coefficients"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrix multiplication\n",
    "This is what's behind the function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = data_frame(intercept = 1, speed = cars$speed) %>% as.matrix()\n",
    "y = cars$dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can see that matrix multiplication $\\left( X^{T}X \\right)^{-1} X^{T} y$ gives the same results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead><tr><th scope=col>intercept</th><th scope=col>speed</th></tr></thead>\n",
       "<tbody>\n",
       "\t<tr><td>-17.57909</td><td>3.932409 </td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "\\begin{tabular}{ll}\n",
       " intercept & speed\\\\\n",
       "\\hline\n",
       "\t -17.57909 & 3.932409 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "intercept | speed | \n",
       "|---|\n",
       "| -17.57909 | 3.932409  | \n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "     intercept speed   \n",
       "[1,] -17.57909 3.932409"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "solve(t(X) %*% X) %*% t(X) %*% y %>% t()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QR decomposition\n",
    "\n",
    "Using the [QR decomposition](https://en.wikipedia.org/wiki/QR_decomposition) $X = QR$ (with $Q^{T} Q = \\mathbf{I}$) and $R$ an upper-triangular matrix) we can re-write the calculation as:\n",
    "\n",
    "$$ \\hat{\\beta} = \\left( X^{T} X \\right)^{-1} X^{T} y = \\left( R^{T}Q^{T} QR \\right)^{-1} R^{T}Q^{T} y = \\left( R^{T} R \\right)^{-1} R^{T}Q^{T} y = R^{-1} \\left( R^{T} \\right)^{-1} R^{T} Q^{T} y  = R^{-1} Q^{T} y$$ \n",
    "\n",
    "* Note: The trivial looking operations of inversion and transposing multiplicated matrices requires some assumptionson the properties of $Q$ and $R$ mentioned above.\n",
    "\n",
    "Putting the new formula into action we get the same results as before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead><tr><th scope=col>intercept</th><th scope=col>speed</th></tr></thead>\n",
       "<tbody>\n",
       "\t<tr><td>-17.57909</td><td>3.932409 </td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "\\begin{tabular}{ll}\n",
       " intercept & speed\\\\\n",
       "\\hline\n",
       "\t -17.57909 & 3.932409 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "intercept | speed | \n",
       "|---|\n",
       "| -17.57909 | 3.932409  | \n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "     intercept speed   \n",
       "[1,] -17.57909 3.932409"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(X %>% qr %>% qr.R %>% solve()) %*% \n",
    "  (X %>% qr %>% qr.Q %>% t()) %*% \n",
    "  y %>% \n",
    "  t()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map reduce\n",
    "\n",
    "As our data matrix increases in size (either number rows as observations or columns as attributes), the inversion part of the calculation `solve` and/or QR-factorization `qr` become more memory and time intensive for a single thread calculation.\n",
    "\n",
    "## Map\n",
    "\n",
    "Let's say we have `m = 5` cores at our disposal and we'd like to distribute the calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "m <- 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define the process in a \"tidy\" way, so all `map` operations here are [embarrassingly parallel](https://en.wikipedia.org/wiki/Embarrassingly_parallel). For simplicity we split the rows between the blocks using modulo operation, but this can be done sequentially or based on existing partitions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "mats <- X %>%\n",
    "  as_data_frame() %>%\n",
    "  mutate(\n",
    "    id = row_number() %% m,\n",
    "    y = y\n",
    "  ) %>% \n",
    "  ## this is where partitioning happens\n",
    "  nest(-id) %>% \n",
    "  mutate(\n",
    "    X = map(data, ~ .x %>% select(-y) %>% as.matrix()),\n",
    "    y = map(data, ~ .x %>% pull(y))\n",
    "  ) %>% \n",
    "  ## We calculate QR decomposition for each partition independently\n",
    "  mutate(\n",
    "    Q2 = map(X, ~ .x %>% qr() %>% qr.Q()),\n",
    "    R1 = map(X, ~ .x %>% qr() %>% qr.R())\n",
    "  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collect\n",
    "\n",
    "Having some of the heavy lifting in a distributed way (in the case the QR decomposition) we can collect the results "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_collect <- mats$R1 %>% do.call(what = 'rbind', args = .)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And continue our calculations with a matrix of lower dimensions (number of partitions X number of columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead><tr><th scope=col>dimension</th><th scope=col>X1</th><th scope=col>X2</th></tr></thead>\n",
       "<tbody>\n",
       "\t<tr><td>rows   </td><td>50     </td><td>10     </td></tr>\n",
       "\t<tr><td>columns</td><td> 2     </td><td> 2     </td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "\\begin{tabular}{r|lll}\n",
       " dimension & X1 & X2\\\\\n",
       "\\hline\n",
       "\t rows    & 50      & 10     \\\\\n",
       "\t columns &  2      &  2     \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "dimension | X1 | X2 | \n",
       "|---|---|\n",
       "| rows    | 50      | 10      | \n",
       "| columns |  2      |  2      | \n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "  dimension X1 X2\n",
       "1 rows      50 10\n",
       "2 columns    2  2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.frame(dimension = c('rows', 'columns'), cbind(X %>% dim(), df_collect %>% dim()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduce\n",
    "\n",
    "Final calculations require only the small matrix we've created.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead><tr><th scope=col>intercept</th><th scope=col>speed</th></tr></thead>\n",
       "<tbody>\n",
       "\t<tr><td>-17.57909</td><td>3.932409 </td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "\\begin{tabular}{ll}\n",
       " intercept & speed\\\\\n",
       "\\hline\n",
       "\t -17.57909 & 3.932409 \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "intercept | speed | \n",
       "|---|\n",
       "| -17.57909 | 3.932409  | \n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "     intercept speed   \n",
       "[1,] -17.57909 3.932409"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Number of groups for nesting can be automatically inferred\n",
    "m2 <-  dim(mats$R1[[1]])[2]\n",
    "\n",
    "## The map-stage QR-decomposition\n",
    "Q1 = df_collect %>% qr %>% qr.Q\n",
    "R2 = df_collect %>% qr %>% qr.R\n",
    "\n",
    "## For some reason this did not work with a `mutate` command...\n",
    "mats$Q1 = Q1 %>% \n",
    "  as_data_frame() %>% \n",
    "  mutate(id = ceiling(row_number() / m2)) %>% \n",
    "  nest(-id) %>% \n",
    "  mutate(data = map(data, ~ as.matrix(.x))) %>% \n",
    "  pull(data)\n",
    "\n",
    "v_sum = mats %>% \n",
    "  mutate(Q3_t = map2(.x = Q2, .y = Q1, .f = ~ t(.x %*% .y))) %>%\n",
    "  mutate(V = map2(.x = Q3_t, .y = y, .f = ~ .x %*% .y)) %>% \n",
    "  pull(V) %>% \n",
    "  reduce(`+`)\n",
    "\n",
    "t(solve(R2) %*% v_sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voila! :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A note the number of nodes vs. efficiency \n",
    "\n",
    "As the number of nodes available to us increases, we encounter a little paradox - at some point the calculation time will actually start getting longer! This is because we run QR-factorization (QRF) both on the map *and* the reduce stage. \n",
    "\n",
    "Think of 2 extreme cases: \n",
    "\n",
    "1. $m=1$: We run QRF the entire matrix on a single node and end up with 2X2 matrix for the second QRF (this is `dim()`).\n",
    "\n",
    "2. $m=50$: The QRF on each node is trivial and returns the original row $X_i$ that was sent to the node, so the second QRF is in-fact again a full scale QRF of the original function (with `df_collect = X`)\n",
    "\n",
    "But - sending data to the nodes and collecting it has overhead, so in fact our expected run-time with 50 nodes is longer than with 1 node! \n",
    "\n",
    "We can demonstrate the trade-off with a simple formula, but first let's make some assumptions:\n",
    "\n",
    "* From digging around the web (_citation needed_), we know that the QR algorithm has a complexity of $O(n k^2)$, where $n$ is the number of rows and $k$ is the number of columns. \n",
    "\n",
    "* This means that run-time for `qr` should be roughly proportional to the number of rows, so the unit we are interested in is the incremental time it takes to process an additional row of the matrix $X$. Let's call this unit of time $t_{row}$, but instead of looking at a specific duration (which really depends on the platform, CPU, etc) we just mark it as a single unit of time (so $t_{row} = 1$ arbitrarily) .\n",
    "\n",
    "* We also denote the overhead time to set-up a node as $\\delta$ units of $t_{row}$. Again, this does not stand for a specific duration but for the ratio between the overhead time and the time increment per-row.\n",
    "\n",
    "* We neglect the communication time between the mapper and the nodes (and if it's proportional to $n$ it remains fixed anyway)\n",
    "\n",
    "* And a final simplification is that we only look at values of $m$ that are factors of $n$ ($n/m \\in \\mathbb{N}$) and ignore the trivial case where $m = n$ (it just makes the math more simple...)\n",
    "\n",
    "With this in mind we can calculate the total run-time $T$ as:\n",
    "1. The time it takes to set-up the nodes (proportional to the number of nodes) + \n",
    "2. The time it takes to run QRF on each node (which is the number of nodes X number of rows per nodes X time per row divided by number of nodes, as they run in parallel) +\n",
    "3. The time to run QRF on the reduced matrix (which is the number of rows of the reduced matrix X time per row)\n",
    "\n",
    "Or as:\n",
    "\n",
    "$$ \\frac{T}{t_{row}} = m \\delta + m \\frac{n}{m} \\frac{1}{m} + m k = m(\\delta + k) + \\frac{n}{m} $$ \n",
    "\n",
    "We can calculate for our example ($k = 2, n = 50, t_{row} = 1$) and see how sensitive is the optimal choice to the overhead time ratio $\\delta$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table>\n",
       "<thead><tr><th scope=col>m</th><th scope=col>time_d1</th><th scope=col>time_d2</th><th scope=col>time_d5</th><th scope=col>time_d20</th><th scope=col>time_d100</th></tr></thead>\n",
       "<tbody>\n",
       "\t<tr><td> 1  </td><td>53  </td><td> 54 </td><td> 57 </td><td> 62 </td><td> 152</td></tr>\n",
       "\t<tr><td> 2  </td><td>31  </td><td> 33 </td><td> 39 </td><td> 49 </td><td> 229</td></tr>\n",
       "\t<tr><td> 5  </td><td>25  </td><td> 30 </td><td> 45 </td><td> 70 </td><td> 520</td></tr>\n",
       "\t<tr><td>10  </td><td>35  </td><td> 45 </td><td> 75 </td><td>125 </td><td>1025</td></tr>\n",
       "\t<tr><td>25  </td><td>77  </td><td>102 </td><td>177 </td><td>302 </td><td>2552</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "\\begin{tabular}{r|llllll}\n",
       " m & time\\_d1 & time\\_d2 & time\\_d5 & time\\_d20 & time\\_d100\\\\\n",
       "\\hline\n",
       "\t  1   & 53   &  54  &  57  &  62  &  152\\\\\n",
       "\t  2   & 31   &  33  &  39  &  49  &  229\\\\\n",
       "\t  5   & 25   &  30  &  45  &  70  &  520\\\\\n",
       "\t 10   & 35   &  45  &  75  & 125  & 1025\\\\\n",
       "\t 25   & 77   & 102  & 177  & 302  & 2552\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "m | time_d1 | time_d2 | time_d5 | time_d20 | time_d100 | \n",
       "|---|---|---|---|---|\n",
       "|  1   | 53   |  54  |  57  |  62  |  152 | \n",
       "|  2   | 31   |  33  |  39  |  49  |  229 | \n",
       "|  5   | 25   |  30  |  45  |  70  |  520 | \n",
       "| 10   | 35   |  45  |  75  | 125  | 1025 | \n",
       "| 25   | 77   | 102  | 177  | 302  | 2552 | \n",
       "\n",
       "\n"
      ],
      "text/plain": [
       "  m  time_d1 time_d2 time_d5 time_d20 time_d100\n",
       "1  1 53       54      57      62       152     \n",
       "2  2 31       33      39      49       229     \n",
       "3  5 25       30      45      70       520     \n",
       "4 10 35       45      75     125      1025     \n",
       "5 25 77      102     177     302      2552     "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data.frame(m = c(1,2,5,10,25)) %>% \n",
    "  mutate(\n",
    "    time_d1 = m * (1 + 2 ) + 50 / m, \n",
    "    time_d2 = m * (2 + 2 ) + 50 / m,\n",
    "    time_d5 = m * (5 + 2 ) + 50 / m,\n",
    "    time_d20 = m * (10 + 2 ) + 50 / m,\n",
    "    time_d100 = m * (100 + 2 ) + 50 / m\n",
    "  )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And as expected - as the overhead time increases the time saved by parallelization decreases (or even disappears...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading required package: future\n",
      "Loading required package: future.apply\n",
      "\n",
      "Attaching package: ‘future.apply’\n",
      "\n",
      "The following object is masked from ‘package:future’:\n",
      "\n",
      "    future_lapply\n",
      "\n"
     ]
    }
   ],
   "source": [
    "require(future)\n",
    "require(future.apply)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to really test the value of parallelization we make 2 changes:\n",
    "1. Inflate `X` to a 10M size matrix\n",
    "2. Allocate all the data manipulation activities to the map function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_rows <- sample(x = 1:nrow(X), size = 10000000L, replace = TRUE)\n",
    "X2 <- X[sample_rows,]\n",
    "y2 <- y[sample_rows]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "getQR <- function(X) {X %>% select(-y) %>% as.matrix() %>% qr()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim1 <- function(m) {\n",
    "    tic <- Sys.time()\n",
    "\n",
    "    plan(multiprocess(workers = {m}))\n",
    "    \n",
    "    ## Map\n",
    "    mats <- X2 %>%\n",
    "      as_data_frame() %>%\n",
    "      mutate(\n",
    "        id = row_number() %% m,\n",
    "        y = y2\n",
    "      ) %>% \n",
    "      ## this is where partitioning happens\n",
    "      nest(-id) %>% \n",
    "      mutate(\n",
    "        QR = future_lapply(data, getQR),\n",
    "        y = map(data, ~ .x %>% pull(y))\n",
    "      ) %>% \n",
    "      ## We calculate QR decomposition for each partition independently\n",
    "      mutate(\n",
    "        Q2 = map(QR, qr.Q),\n",
    "        R1 = map(QR, qr.R)\n",
    "      )\n",
    "\n",
    "    ## Collect\n",
    "    df_collect <- mats$R1 %>% do.call(what = 'rbind', args = .)\n",
    "    \n",
    "    ## Number of groups for nesting can be automatically inferred\n",
    "    m2 <-  dim(mats$R1[[1]])[2]\n",
    "    \n",
    "    ## The map-stage QR-decomposition\n",
    "    Q1 = df_collect %>% qr %>% qr.Q\n",
    "    R2 = df_collect %>% qr %>% qr.R\n",
    "\n",
    "    ## For some reason this did not work with a `mutate` command...\n",
    "    mats$Q1 = Q1 %>% \n",
    "      as_data_frame() %>% \n",
    "      mutate(id = ceiling(row_number() / m2)) %>% \n",
    "      nest(-id) %>% \n",
    "      mutate(data = map(data, ~ as.matrix(.x))) %>% \n",
    "      pull(data)\n",
    "\n",
    "    v_sum = mats %>% \n",
    "      mutate(Q3_t = map2(.x = Q2, .y = Q1, .f = ~ t(.x %*% .y))) %>%\n",
    "      mutate(V = map2(.x = Q3_t, .y = y, .f = ~ .x %*% .y)) %>% \n",
    "      pull(V) %>% \n",
    "      reduce(`+`)\n",
    "\n",
    "    return(list(values = t(solve(R2) %*% v_sum), time = Sys.time() - tic))\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running the simulation can also be parallelized, but to avoid conflicts with the `plan` function we run sequentially:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_results <- data_frame(m = c(1,2,5,10,25,50)) %>% \n",
    "    mutate(\n",
    "        y = map(m, sim1), \n",
    "        time = map_dbl(y, ~.x$time),\n",
    "        intercept = map_dbl(y, ~.x$values[1]),\n",
    "        beta = map_dbl(y, ~.x$values[2])\n",
    "    ) %>% \n",
    "    select(-y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_results %>% \n",
    "    mutate(m = as.factor(m)) %>% \n",
    "    ggplot(aes(x = m, y = time)) + geom_point() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R 3.5.0",
   "language": "R",
   "name": "ir35"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.5.1"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}