ray.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-25T23:58:09.796697Z",
     "start_time": "2020-06-25T23:58:09.794468Z"
    }
   },
   "outputs": [],
   "source": [
    "# %pip install -U ray ray[debug] ray[dashboard]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-25T23:58:19.473489Z",
     "start_time": "2020-06-25T23:58:10.349291Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-06-25 23:58:10,664\tINFO resource_spec.py:212 -- Starting Ray with 27.34 GiB memory available for workers and up to 29.8 GiB for objects. You can adjust these settings with ray.init(memory=<bytes>, object_store_memory=<bytes>).\n",
      "2020-06-25 23:58:10,904\tWARNING services.py:923 -- Redis failed to start, retrying now.\n",
      "2020-06-25 23:58:11,149\tINFO services.py:1165 -- View the Ray dashboard at \u001b[1m\u001b[32mlocalhost:8265\u001b[39m\u001b[22m\n"
     ]
    }
   ],
   "source": [
    "# May need to restart kernel\n",
    "import ray\n",
    "import time\n",
    "\n",
    "\n",
    "# This is pretty unreliable, may need to manually retry\n",
    "def restart_ray():\n",
    "    ray.shutdown()\n",
    "    ray.init(object_store_memory=32e9)  # is this ignored? consumes 110+ GB\n",
    "    \n",
    "restart_ray()    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-25T23:58:20.273303Z",
     "start_time": "2020-06-25T23:58:19.673458Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def local_matmul(a: np.ndarray, b: np.ndarray) -> np.ndarray:\n",
    "    \"\"\"A(l, m) x B(m, n) = C(l, n)\"\"\"\n",
    "    assert a.shape[1] == b.shape[0]  # m == m\n",
    "    res = np.zeros((a.shape[0], b.shape[1]))  # (l,n)\n",
    "    b_t = b.T  # for read localility from row-major  # (m, n) -> (n, m)\n",
    "    for i in range(a.shape[0]):  # l\n",
    "        for j in range(b_t.shape[0]):  # n\n",
    "            res[i,j] = np.dot(a[i], b_t[j])\n",
    "    return res  \n",
    "\n",
    "@ray.remote\n",
    "def transpose(x):\n",
    "    return x.T\n",
    "\n",
    "@ray.remote\n",
    "def dot(x_vec: np.ndarray, y_mat: np.ndarray, row: int):\n",
    "    # Fetch entire matrix?\n",
    "    return np.dot(x_vec, y_mat[row])\n",
    "\n",
    "@ray.remote\n",
    "def dot2(x_vec: np.ndarray, y_vec: np.ndarray):\n",
    "    # seems slower?\n",
    "    return np.dot(x_vec, y_vec)\n",
    "\n",
    "@ray.remote\n",
    "def par_matmul(a: np.ndarray, b: np.ndarray):\n",
    "    \"\"\"A(l, m) x B(m, n) = C(l, n)\"\"\"\n",
    "    assert a.shape[1] == b.shape[0]  # m == m\n",
    "    bt = transpose.remote(b)  # for read localility from row-major  # (m, n) -> (n, m)\n",
    "    values = dict()\n",
    "    for i in range(a.shape[0]):  # l\n",
    "        for j in range(b.shape[1]):  # n\n",
    "            values[(i,j)] = dot.remote(a[i], bt, j)\n",
    "            \n",
    "    res = np.zeros((a.shape[0], b.shape[1]))  # l,n\n",
    "    for i in range(a.shape[0]):  # l\n",
    "        for j in range(b.shape[1]):  # n\n",
    "            res[i, j] = ray.get(values[(i,j)])\n",
    "    return res\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-25T23:58:50.945882Z",
     "start_time": "2020-06-25T23:58:50.931495Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.39868872 0.7425399 ]\n",
      " [0.20669572 0.60497341]]\n",
      "[[0.39868872 0.7425399 ]\n",
      " [0.20669572 0.60497341]]\n",
      "[[0.39868872 0.7425399 ]\n",
      " [0.20669572 0.60497341]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "a = np.random.rand(2, 4)\n",
    "b = np.random.rand(4, 2)\n",
    "print(np.matmul(a, b))\n",
    "print(local_matmul(a, b))\n",
    "\n",
    "# May need to wait and retry after ray.init()\n",
    "matmul_id = par_matmul.remote(a, b)\n",
    "print(ray.get(par_matmul.remote(a, b)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:00:57.768675Z",
     "start_time": "2020-06-25T23:58:55.186148Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>m</th>\n",
       "      <th>reference</th>\n",
       "      <th>local</th>\n",
       "      <th>ray</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.000013</td>\n",
       "      <td>0.000033</td>\n",
       "      <td>0.007760</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "      <td>0.000009</td>\n",
       "      <td>0.000063</td>\n",
       "      <td>0.005077</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100</td>\n",
       "      <td>0.000006</td>\n",
       "      <td>0.000031</td>\n",
       "      <td>0.005088</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>0.000018</td>\n",
       "      <td>0.000041</td>\n",
       "      <td>0.005903</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10000</td>\n",
       "      <td>0.000094</td>\n",
       "      <td>0.000115</td>\n",
       "      <td>0.008433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>100000</td>\n",
       "      <td>0.001027</td>\n",
       "      <td>0.000360</td>\n",
       "      <td>0.156800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>1000000</td>\n",
       "      <td>0.025610</td>\n",
       "      <td>0.007744</td>\n",
       "      <td>0.234164</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>10000000</td>\n",
       "      <td>0.103698</td>\n",
       "      <td>0.093780</td>\n",
       "      <td>1.200920</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>100000000</td>\n",
       "      <td>1.030290</td>\n",
       "      <td>1.204478</td>\n",
       "      <td>9.778903</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           m  reference     local       ray\n",
       "0          1   0.000013  0.000033  0.007760\n",
       "1         10   0.000009  0.000063  0.005077\n",
       "2        100   0.000006  0.000031  0.005088\n",
       "3       1000   0.000018  0.000041  0.005903\n",
       "4      10000   0.000094  0.000115  0.008433\n",
       "5     100000   0.001027  0.000360  0.156800\n",
       "6    1000000   0.025610  0.007744  0.234164\n",
       "7   10000000   0.103698  0.093780  1.200920\n",
       "8  100000000   1.030290  1.204478  9.778903"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import time\n",
    "from IPython.display import display\n",
    "\n",
    "\n",
    "REFERENCE = lambda a, b: np.matmul(a, b)\n",
    "LOCAL = lambda a, b: local_matmul(a, b)\n",
    "RAY = lambda a, b: ray.get(par_matmul.remote(a, b))\n",
    "\n",
    "\n",
    "def time_matmul(impl, l, m, n, trials=3):\n",
    "    # not sure if this is a fair test (caching, background processes, etc)    \n",
    "    times = []\n",
    "    for _ in range(trials):  \n",
    "        a = np.random.rand(l, m)\n",
    "        b = np.random.rand(m, n)\n",
    "        \n",
    "        start_time = time.time()\n",
    "        res = impl(a, b)\n",
    "        runtime = time.time() - start_time\n",
    "        times.append(runtime)\n",
    "        \n",
    "        expected = REFERENCE(a, b)\n",
    "        np.testing.assert_allclose(res, expected)\n",
    "    s = pd.Series(times)\n",
    "    return s.mean(), s.std()\n",
    "\n",
    "l = 5\n",
    "n = 3\n",
    "ms, ref_times, loc_times, ray_times = [], [], [], []\n",
    "for m_exp in range(9):\n",
    "    m = int(10**m_exp)\n",
    "    ms.append(m)\n",
    "    ref_mean, ref_std = time_matmul(REFERENCE, l, m, n)\n",
    "    ref_times.append(ref_mean)\n",
    "    loc_time, loc_std = time_matmul(LOCAL, l, m, n)\n",
    "    loc_times.append(loc_time)\n",
    "    ray_time, ray_std = time_matmul(RAY, l, m, n)\n",
    "    ray_times.append(ray_time)\n",
    "\n",
    "# oof\n",
    "results = pd.DataFrame({'m': ms, 'reference': ref_times, 'local': loc_times, 'ray': ray_times})\n",
    "results.plot(0)  \n",
    "display(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:01:28.413871Z",
     "start_time": "2020-06-26T00:01:28.409057Z"
    }
   },
   "outputs": [],
   "source": [
    "@ray.remote\n",
    "class StreamingStats:\n",
    "    def __init__(self):\n",
    "        self.count = 0\n",
    "        self.sum = 0\n",
    "        self.squared_sum = 0\n",
    "        \n",
    "    def update(self, val):\n",
    "        self.count += 1\n",
    "        self.sum += val\n",
    "        self.squared_sum += val * val\n",
    "        \n",
    "    def mean(self):\n",
    "        return self.sum / self.count\n",
    "    \n",
    "    def std(self):\n",
    "        return (abs(self.squared_sum / self.count - (self.sum / self.count) ** 2)) ** 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:01:29.577362Z",
     "start_time": "2020-06-26T00:01:29.371043Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expected: mean=0.49958139824917963, std=0.2906121857594889\n",
      "Streaming: mean=0.4995813982491802, std=0.2906121857594887\n"
     ]
    }
   ],
   "source": [
    "s = StreamingStats.remote()\n",
    "\n",
    "stream = np.random.rand(1000)\n",
    "for val in stream:\n",
    "    s.update.remote(val)\n",
    "    \n",
    "print(f'Expected: mean={stream.mean()}, std={stream.std()}')\n",
    "print(f'Streaming: mean={ray.get(s.mean.remote())}, std={ray.get(s.std.remote())}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thompson Sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:01:32.877439Z",
     "start_time": "2020-06-26T00:01:32.871313Z"
    }
   },
   "outputs": [],
   "source": [
    "import collections\n",
    "\n",
    "\n",
    "@ray.remote\n",
    "class BetaBernoulliArm:\n",
    "    def __init__(self, name='arm', alpha=1, beta=1, true_reward=0.5):\n",
    "        assert alpha >= 1\n",
    "        assert beta >= 1\n",
    "        self.name = name\n",
    "        self.alpha = alpha\n",
    "        self.beta = beta\n",
    "        self.true_reward = true_reward\n",
    "        \n",
    "    def name(self):\n",
    "        return self.name\n",
    "        \n",
    "    def update_impression(self):\n",
    "        # Pessimistic, immediate update encourages exploration\n",
    "        self.beta += 1\n",
    "        \n",
    "    def update_conversion(self):\n",
    "        self.alpha += 1\n",
    "        self.beta += 1\n",
    "        \n",
    "    def empirical_mean(self):\n",
    "        return self.alpha / (self.alpha + self.beta)\n",
    "        \n",
    "    def sample(self):\n",
    "        return np.random.beta(self.alpha, self.beta)\n",
    "    \n",
    "    def outcome(self):\n",
    "        return np.random.binomial(1, self.true_reward)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:01:36.450288Z",
     "start_time": "2020-06-26T00:01:34.766583Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int, {'promising': 1599, 'uniform': 159, 'good': 242})"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import collections\n",
    "import pprint\n",
    "\n",
    "\n",
    "def thompson_sample(arms):\n",
    "    if not arms:\n",
    "        return None\n",
    "    \n",
    "    sample_futures = np.array([arm.sample.remote() for arm in arms])\n",
    "    best_sample, best_index = float('-inf'), 0\n",
    "    for i, future in enumerate(sample_futures):\n",
    "        sample = ray.get(future)\n",
    "        if sample > best_sample:\n",
    "            best_sample, best_index = sample, i\n",
    "    return ray.get(arms[best_index].name.remote())\n",
    "\n",
    "def exposures(arms, resolution=1e-3):\n",
    "    trials = int(2 / resolution)\n",
    "    counts = collections.defaultdict(int)\n",
    "    for _ in range(trials):\n",
    "        variant = thompson_sample(arms)\n",
    "        counts[variant] += 1\n",
    "    return counts\n",
    "\n",
    "uniform_arm = BetaBernoulliArm.remote('uniform', 1, 1, 0.5)\n",
    "good_arm = BetaBernoulliArm.remote('good', 80, 20, 0.85)\n",
    "bad_arm = BetaBernoulliArm.remote('bad', 20, 80, 0.25)\n",
    "promising_arm = BetaBernoulliArm.remote('promising', 9, 1, 0.99)\n",
    "arms = [uniform_arm, good_arm, bad_arm, promising_arm]\n",
    "\n",
    "exposures(arms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-26T00:09:13.982432Z",
     "start_time": "2020-06-26T00:02:52.609135Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'reward')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "\n",
    "TRIALS = 10\n",
    "EPISODE = 14\n",
    "BATCH = 1000\n",
    "\n",
    "\n",
    "@ray.remote\n",
    "def simulate(trial, episodes, batches):\n",
    "    uniform_arm = BetaBernoulliArm.remote('uniform', 1, 1, 0.5)\n",
    "    good_arm = BetaBernoulliArm.remote('good', 80, 20, 0.85)\n",
    "    bad_arm = BetaBernoulliArm.remote('bad', 20, 80, 0.25)\n",
    "    promising_arm = BetaBernoulliArm.remote('great', 9, 1, 0.99)\n",
    "    arm_list = [uniform_arm, good_arm, bad_arm, promising_arm]\n",
    "    arms = {ray.get(arm.name.remote()): arm for arm in arm_list}\n",
    "    \n",
    "    dates = []\n",
    "    conversions = []\n",
    "    for episode in range(episodes):\n",
    "        \n",
    "        conversion = 0\n",
    "        for batch in range(batches):\n",
    "            arm = arms[thompson_sample(arm_list)]\n",
    "            arm.update_impression.remote()\n",
    "            if ray.get(arm.outcome.remote()):\n",
    "                arm.update_conversion.remote()\n",
    "                conversion += 1\n",
    "        dates.append(episode)\n",
    "        conversions.append(conversion)\n",
    "    return pd.DataFrame({'trial': trial, 'date': dates, 'reward': conversions})\n",
    "\n",
    "\n",
    "sim_ids = [simulate.remote(trial, EPISODE, BATCH) for trial in range(TRIALS)]\n",
    "result_df = pd.concat([pd.DataFrame(ray.get(sim_id)) for sim_id in sim_ids])\n",
    "ax = result_df.pivot(index='date', columns='trial', values='reward').plot()\n",
    "ax.set_ylabel('reward')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-06-25T22:55:49.973902Z",
     "start_time": "2020-06-25T22:55:39.309393Z"
    }
   },
   "outputs": [],
   "source": [
    "#restart_ray()"
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}