{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi Armed Bandit Problem\n",
    "\n",
    "## Problem Description\n",
    "\n",
    "Imagine you are at a casino, and you have N slot machines to play, each slot machine gives rewards according to a fixed probability distribution. What strategy should you play with to maximise your total reward ?\n",
    "\n",
    "This problem is known as [Multi Armed Bandit](https://en.wikipedia.org/wiki/Multi-armed_bandit) problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Importing numpy for math, and matplotlib for plots\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arms\n",
    "\n",
    "An arm when pulled, gives a random number from a normal distribution with fixed mean(mu) and deviation(sigma).\n",
    "When pulled many times the frequency of the rewards look like this:\n",
    "\n",
    "![normal distribution](https://upload.wikimedia.org/wikipedia/commons/thumb/7/74/Normal_Distribution_PDF.svg/350px-Normal_Distribution_PDF.svg.png)\n",
    "X axis is the magnitude of reward  \n",
    "Y axis is it's frequency.\n",
    "\n",
    "The Arm class provides an arm with these properties."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Arm:\n",
    "\n",
    "    def __init__(self, mu=None, sigma=None):\n",
    "        if mu is None:\n",
    "            self.mu = np.absolute(np.random.uniform())\n",
    "        else:\n",
    "            self.mu = mu\n",
    "        \n",
    "        \n",
    "        if sigma is None:\n",
    "            self.sigma=np.absolute(np.random.uniform())\n",
    "        else:\n",
    "            self.sigma = sigma\n",
    "\n",
    "\n",
    "    def pull(self):\n",
    "        reward = np.random.normal(self.mu, self.sigma, 1)\n",
    "        return reward\n",
    "\n",
    "\n",
    "def get_arms(k):\n",
    "    # returns a list of arms\n",
    "    arms = []\n",
    "    for i in range(k):\n",
    "        arms.append(Arm())\n",
    "    return arms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agents\n",
    "\n",
    "An agent here is a player who pulls arms to play.\n",
    "It has a policy, which is a list of probabilities associated with each arm.\n",
    "\n",
    "\n",
    "The agent class makes designing agents **fast**. The object is initialised with arms and whether it should play all arms once as part of the initialisation.\n",
    "\n",
    "Features provided by this class:  \n",
    "Attributes:\n",
    "* expectations[i]: gives the expected reward on playing arm[i]\n",
    "* times_played[i]: gives the number of times the agent has played arm[i]\n",
    "* N = Total number of times agent has played\n",
    "* reward_history : list of rewards earned by the agent\n",
    "* choice_history : list of choices made by the agent  \n",
    "\n",
    "Methods:\n",
    "* gamble(i): Plays for i iterations while updating it's policy.\n",
    "* play(i): Pulls arm[i] and updates reward_history, N , times_played\n",
    "* select_arm(): returns index of an arm by sampling  probability distribution given by the policy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class agent:\n",
    "    def __init__(self, arms, play_once=1):\n",
    "        self.expectations = np.zeros(len(arms))\n",
    "        self.times_played = np.zeros(len(arms))\n",
    "        self.arms = arms\n",
    "\n",
    "        self.number_of_arms = len(arms)\n",
    "        self.N = 0\n",
    "\n",
    "        self.reward_history = []\n",
    "        self.choice_history = []\n",
    "\n",
    "        if play_once == 1:\n",
    "            for i in range(self.number_of_arms):\n",
    "                self.expectations[i] = self.play(i)\n",
    "\n",
    "    def play(self, index):\n",
    "        reward = self.arms[index].pull()\n",
    "\n",
    "        self.times_played[index] += 1\n",
    "        self.N += 1\n",
    "\n",
    "        self.choice_history.append(index)\n",
    "        self.reward_history.append(reward)\n",
    "\n",
    "        return reward\n",
    "\n",
    "    def policy(self):\n",
    "        pass\n",
    "\n",
    "    def update_expectations(self, reward, index):\n",
    "        self.expectations[index] += (reward - self.expectations[index])/self.N\n",
    "\n",
    "    def select_arm(self):\n",
    "        options = range(self.number_of_arms)\n",
    "        i = np.random.choice(options, p=self.policy(), replace=False)\n",
    "        return i\n",
    "\n",
    "    def gamble(self, iterations):\n",
    "        for i in range(iterations):\n",
    "            index = self.select_arm()\n",
    "            reward = self.play(index)\n",
    "            self.update_expectations(reward, index)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example agents\n",
    "\n",
    "To make a new agent we [inherit]() the agent class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time to make some agents! \n",
    "\n",
    "### First up: epsilon-greedy\n",
    "\n",
    "This agent plays the arm with the highest expected reward with _1 - epsilon_ probability, and plays a random arm with _epsilon_ probability\n",
    "\n",
    "So  \n",
    "    epsilon = 1 => random choices  \n",
    "    epsilon = 0 => greedy choices \n",
    "    \n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class epsilon_greedy(agent):\n",
    "\n",
    "    def __init__(self, arms, play_once=1, epsilon=0.1):\n",
    "        super().__init__(arms, play_once)\n",
    "        self.epsilon = epsilon\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"Epsilon-Greedy Agent, epsilon= \"+str(self.epsilon)\n",
    "    \n",
    "    def policy(self):\n",
    "        temp = np.zeros_like(self.expectations)\n",
    "        temp[np.argmax(self.expectations)] = 1-self.epsilon\n",
    "        ans = temp + self.epsilon/self.number_of_arms\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Beta-Softmax\n",
    "\n",
    "This agent plays an arm[i] with probability proportional to: e^(expected_reward(arm[i])/beta)  \n",
    "We normalise the whole thing by the sum over all the arms.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class softmax(agent):\n",
    "\n",
    "    def __init__(self, arms, play_once=1, beta=1):\n",
    "        super().__init__(arms, play_once)\n",
    "        self.beta = beta\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"Softmax agent, beta= \"+ str(self.beta)\n",
    "\n",
    "    def policy(self):\n",
    "        temp = np.exp(self.expectations/self.beta)\n",
    "        ans = temp / np.sum(temp, axis=0)\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Upper Confidence Bound (UCB1)\n",
    "\n",
    "UCB1 agent plays the arm with the highest metric, where metric of arm i is :\n",
    "metric[i] = expected_reward[i] + sqrt(2*log(N)/times_played[i])\n",
    "\n",
    "__Note__ Best peformance when rewards are between 0 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class ucb(agent):\n",
    "\n",
    "    def __init__(self, arms, play_once=1):\n",
    "        super().__init__(arms, play_once)\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"UCB1 agent\"\n",
    "    \n",
    "    def policy(self):\n",
    "        temp = self.expectations + np.sqrt(2*np.log(self.N)/self.times_played)\n",
    "        ans = np.zeros_like(temp)\n",
    "        ans[np.argmax(temp)] = 1\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metrics\n",
    "\n",
    "Metric : A scalar number, makes comparison easier.  \n",
    "To compare the performance of our agents we can use these metrics\n",
    "\n",
    "* avg_reward[i] : this gives the average reward till i+1  iteration.\n",
    "* max_reward : this tells us the maximum expected reward\n",
    "\n",
    "* euclid_distance : we can think of as learnt policy and optimal policy as vectors and compute the distance between them , smaller is better \n",
    "* cosine_simmilarity : compute the cos(q) between the policies. larger is better"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def maxreward(arms):\n",
    "    #Max rewards\n",
    "    a= [arm.mu for arm in arms]\n",
    "    return max(a)\n",
    "\n",
    "def avg_reward(rewards):\n",
    "    ans = []\n",
    "    ans.append(rewards[0])\n",
    "    for i in range(1,len(rewards)):\n",
    "        ans.append(ans[i-1]+rewards[i])\n",
    "    for i in range(len(ans)):\n",
    "        ans[i]/=i+1\n",
    "    return ans\n",
    "\n",
    "def cosine_similarity(a,b):\n",
    "    temp = a*b\n",
    "    temp/=(euclid_distance(a)* euclid_distance(b))\n",
    "    return np.sum(temp, axis=0)\n",
    "    \n",
    "def euclid_distance(a):\n",
    "    return np.sqrt(np.sum(a*a, axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test\n",
    "\n",
    "This function takes a list of agents and the number of iterations. Makes each agent play, and prints its metrics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(agents, iterations):\n",
    "    for agent in agents:\n",
    "        \n",
    "        agent.gamble(iterations)\n",
    "        \n",
    "        temp = [ arm.mu for arm in levers] \n",
    "        optimal_policy = np.zeros_like(agent.expectations)\n",
    "        optimal_policy[temp.index(max(temp))] = 1\n",
    "        \n",
    "        avg_rewards_earned = avg_reward(agent.reward_history)\n",
    "        \n",
    "        print(agent)\n",
    "        print(\"maximum possible reward:\", maxreward(levers))\n",
    "        print(\"average reward:\", avg_rewards_earned[-1])\n",
    "        print(\"cosine similarity\" ,cosine_similarity(agent.policy(), optimal_policy))\n",
    "        euclid_norm = euclid_distance(agent.policy()-optimal_policy)/len(optimal_policy)\n",
    "        print(\"euclidian norm \",euclid_norm)\n",
    "        \n",
    "        \n",
    "        plt.plot(avg_rewards_earned)\n",
    "        plt.ylabel('Average Reward')\n",
    "        plt.xlabel('Iteration')\n",
    "        plt.show()\n",
    "        print(\"\\n\")\n",
    "    \n",
    "        # print(\"optimal policy:\" , optimal)\n",
    "        # print(\"learnt policy:\" ,agent.policy())\n",
    "        \n",
    "    \n",
    "        \n",
    "        # plt.scatter(range(len(agent.choice_history)),y=agent.choice_history)\n",
    "        # plt.title(\"Choices\")\n",
    "        # plt.xlabel(\"time\")\n",
    "        # plt.ylabel(\"arm\")\n",
    "        # plt.show()\n",
    "        # print(\"\\n\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "levers = get_arms(10)\n",
    "\n",
    "agents = [\n",
    "    epsilon_greedy(levers, epsilon=1),\n",
    "    epsilon_greedy(levers, epsilon=0),\n",
    "    softmax(levers, beta=0.1),\n",
    "    ucb(levers)\n",
    "\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'distribution of expected value of arms')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([ arm.mu for arm in levers] )\n",
    "plt.title(\"distribution of expected value of arms\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epsilon-Greedy Agent, epsilon= 1\n",
      "maximum possible reward: 0.9875803648377603\n",
      "average reward: [0.477258]\n",
      "cosine similarity 0.3162277660168379\n",
      "euclidian norm  0.09486832980505139\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Epsilon-Greedy Agent, epsilon= 0\n",
      "maximum possible reward: 0.9875803648377603\n",
      "average reward: [0.89626864]\n",
      "cosine similarity 0.0\n",
      "euclidian norm  0.1414213562373095\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XucnGV5//HPNbM7e8xxs4GcDxCK4RyXEAQpcpCgGDy1JthWq0D1Zzy21SAW/dFaW/2pVZu2olK1LwURW8yvRlPAyEmRhEOAACFLQkhCSDan3c1mD3O4+sfz7DDZ7OxMwj47uzvf9+s1r8xzzzPPXPdkdq65D8/9mLsjIiICECt1ACIiMnwoKYiISJaSgoiIZCkpiIhIlpKCiIhkKSmIiEiWkoKIiGQpKYiISJaSgoiIZFWUOoBjNWnSJJ89e3apwxARGVEeffTRve7eWGi/EZcUZs+ezfr160sdhojIiGJm24rZT91HIiKSpaQgIiJZSgoiIpKlpCAiIllKCiIikhVpUjCzxWa2ycyazWxFP4/PMrN7zexJM/uNmU2PMh4RERlYZEnBzOLASuBKYD6wzMzm99nt/wE/dPczgZuBL0UVj4iIFBbleQoLgWZ33wJgZrcDVwPP5OwzH/hUeH8tcFeE8cgo0ZPKUBk3zOy4j7G/o4cNOw4ypqqCZNrp6E4xt7GOuY31Az6vsydNTSIOQDKdIZ1xXtzXwfb9nTTUJ5g/ZSyHe9KMq6kkHjv++EazVDpDPGYc7kljBlUVcZLpDK+0dlGbiNOZTHPwcJK6qjg7D3ax8eVWJtYmqK2qoKEuwdjqSk4YV8Wkuipieo8HXZRJYRqwPWd7B3Ben302AO8EvgG8AxhjZg3uvi/CuMpCJuMs/c7DPLJ1PwD/8t4FvOWMKQB0dKe49cGtvOnUyZw+bVzBY6UzziNb9zOuppKuVJpMxmmaPfGo1ztwuIcX93XQ1pnimV1tLD79RP7zsR2sXPsCcxvrONyd5vRp4/jT82cxa2ItsxpqMTPaupK8tO8wp00de8QXfSbj3L+5hf96fCcPNe9l76EeJtYl2N/RA0BDXYJUxkmlMzTUV3HwcA+xmLFs4UzmTa5nxsRantrRyqHuFK2dSdo6k2x8uY2WQ920tHf3W9dERYwp46qZOq6G3e1dnDFtHNv3H+blg13sPdRNKuNMn1CDGexu7aYnncn7vl1y6mSqKmJ09KTZd6ibF1oOMW/yGGIxY1xNJZ09KWY31HHWjPG4O3vau5k8tpoJtZUA7DrYRU86w/hwe8eBTlo7k6TTzsutnXT2pInHjDecNInaRBzHmdVQRyIeo6Mnxf6OHhLxGJXxGM/uauPEcdVMHV9DzIz9HT20dyVx4HBPmq5kmt1tXbzS2sWJ46qpiMWoiBnP72knnXEq47Hs+z6htpL66kqqKmI0jqli8pgqKmJGLGYYRsyCz1jLoW7aOlO0dSVp60rRnUzT1pnklbYuKmKxAd+7YlTEjAl1Cdq7kjTUVdE4por9HT2cPLmemRNr6UlnSKUzjKmuJFERvA+JuFEZj1ERj7G/o5vOngztXUnS7kysTTCxPsHE2gTJjFOXiLOrtYuYGWfPGE9dVZxERYy6RAVm0N6VoieVoaoyxt724L2prYoza2ItE+sSr+lHSymZu0dzYLN3A4vd/dpw+0+B89x9ec4+U4F/BuYA9wPvAk5394N9jnU9cD3AzJkzX79tW1En5pWV1s4kP3t0B28/Zxq/37KPD//osaKed9aM8Xzx7acflRx6Uhkeat7Lw1v38e37tvT73NOmjiWdcZ57pf24Yp42voaG+gRP7mg9onxMdQXJdIau5NFfGhPrEiw5ayrP7mqjIm481Bz8fkhUxLjitBN5/pV2Nu3OH8/5cxuYObGWsTUVNI6pYsaEWrbtP8yCmRN4eMs+Ht12gLauJLtbu2jrSlFXFaejO81Jk+s5b85Edh7opDOZJpnOUFURZ2x1BefNncjshjq27T/MnrYuKuIx1j63h40vt1GTiAdfmvEYG7Yf5OwZ43GgO5mmvqqCTa+0096dAsAMBvpzrIwbY6srMYNJ9VXUJuI89tLB/E84BjWVceqq4kwZV5NNfl3JNKeeOIbqyjiptDOxPoERtLJa2rvpTKZp7UzS3pXq95gNdQlqEnEm1CaoqYxTk4gzsS7BieOqyWScsWFrqjuZIWYwvi5BJkxAdVVBayweM86b00BHd4quVJp9h3o41J1id1sXu1q7ONDRQ6Iixta9HXQl00wZV8NTO1vZe6ibyniMyrhxqCtFMu1HJaF4zEjEY9lW3f6OHjqT6UF5PxMVMeqrKmisr6KqMkhIjfVVTKxP4O5kMuA47uAE/++1iTgTaivpSmU40NHDnvZuzIK/xerKOF3JNB+4YA6XzT/huGIys0fdvangfhEmhfOBL7j7FeH2DQDu3u+4gZnVA8+5+4CDzU1NTV5uy1w8/tIBfvvCPhLxGG88ZRI33bWRmkScPe3dvOOcqXzjns109PT/Yf7M4lN51+unsfCL9x5RPqG2kprKOC+3dh1RPmVcNbv6lAG84aQG9rR385YzpvDNezdny+dOqmPL3g4q48a1b5zL7Y+8xJVnTGHupDoOdaeIm/Hhi09id3s3MYONO9t4oeUQOw92snVvB1taOhhbU8mpJ45h696O4Ne+GbVVcfYd6mH5JSdz/tyGgt06vXpbLK2dSbbu7WDDjlY+eOEc6qsqcHcq4kM34S6TCf62BuricHee2dVGdWWcOQ114a/rJK2dSaorg4RyuCdNVWWMyWOq++2Saj2cpCsVdLm0tHdTVxWnNlFBPGZ0dKcwg9dNGcue9m4OdPTQnUrTUBd8QVXEjOqK+GvqhslknLQ7h7pSOFBVEcOB+qrhtYqOu5PKOMl0hmTKqaqMUV0ZP2Kfzp40+zq6MTM6e1JMHV9DVzLDUztb6UllONyT4lB3ispYjERF8PzDPSmmja8hFjPaOpNsaelgT3sXh7rTtLR3k8pk6Ellsu9/LBa0pgzDDGJhi6KjJ8XBw0kSFTEm1iZoHFMFQEXc6OwJfkRcd9FcrjjtxOOq/3BIChXA88ClwE5gHXCNu2/M2WcSsN/dM2b2RSDt7jcNdNxySgrP727nzV+/v+j9qypidKcyzJ8yln/9kwXMaqg74vFMJvi1VFURyzZtN+9u56O3PX7Ur/3Xz5rABSdPYlxNJRfNm8S8E8Yc8bh78CsnFjPcfcQ2lUWGk2J+SByvYpNCZKnc3VNmthxYA8SBW919o5ndDKx391XAxcCXzMwJuo8+ElU8w822fR2Mr0kwLuwvznXPM7u59of5E9+shlo6e9LsCfvFJ9VX8chnLy34QYrFjOrYkb+M5p0whl994iIg+EBu23+YGRNqCv6iNgt+5fTeF5HXbjgMnEfWUojKSG8p9KQyJNMZTvv8Gs6cPo5Vyy8klc7wvQe3csLYak5qrOdt//zgEc/53Q2XMGVcTYkiFpHRoOQtBTlaS3s3537xnuz2kztamb3iF/3u+6Y/aOTr7zmb8bWJoQpPRERJYSit+NmTRe33rWXn8LazpkYcjYjI0ZQUhsjX7n6ee5/bw6K5E7ntukW4w6bd7Xz3ga187NKTmdVQxzMvt5GoME6ePKbwAUVEIqCkMES+fd8LAHz3fedmB2lfN2UsX/3js7L7zJ86tlThiYgAWiV1SCz6+3vpTmW4NpwvLyIyXCkpROTWB7cye8Uv+PVzu3mlLTgZ7BOXn1LiqEREBqafrYPsUHeKyrhx838H6/594PvB9Nmffuh8tRJEZNjTt9QgOuXGX+Zd5Ov1MycMcTQiIsdOSaFImYzTmUxTl+fX/m827TkqIfzsw2/goea9/FHT9GFxpqKISCEaUygglc6wdW8HX717E6d9fg2/37Ivuxx1rvf/+zoAbr9+EdPG17D8TSezYOZ4PnbpPJ2NLCIjhloKBfzVTzdw1xMvZ7ffc8vDADz6uctoqA9WMexdm7++qoJFcxt4aMUlQx+oiMggUEthAKl05oiEkOv1f3cPHd0pHnvpQHbpim8sPXsowxMRGXRqKQzg5Bt/ecT25DFV2ZVJAU77/JojHl80t2FI4hIRiYqSQhGWLZzBl955Znb74OEezr757iP2+cXHLsw7CC0iMlKo+ygPd2d8bSXLFs48IiEAjK9NcPq0V5ekeODTb+K0qYWvdSwiMtzpp20/Mhln7mdXA8EFbfpz23WLeHHvYeqq4syY2P8+IiIjTdknha5kmuY9h7jqW8GFbTb93WJ2HOjMPj6u5ugrowGMqa7kjOlqHYjI6FLWSaErmebUv/nVEWUvH+zi0q/el91+xznThjosEZGSKesxhe7k0UtSdCXT2fsbbnoz1ZXxo/YRERmtyjoppPu5PnVHdyp7f1xt/11HIiKjVaRJwcwWm9kmM2s2sxX9PD7TzNaa2eNm9qSZvSXKePpKZY5uKbR3BUlh7qS6oQxFRGRYiCwpmFkcWAlcCcwHlpnZ/D67fQ64w93PAZYC/xJVPP1JpV9tKdQlgm6iO9ZvB+Ca82YOZSgiIsNClC2FhUCzu29x9x7gduDqPvs40DvhfxzQ/5oSETncE4wfXH/RXH6+/AIAfvn0KwBs23d4KEMRERkWopx9NA3YnrO9Azivzz5fAP7HzD4K1AGXRRjPUXrHD86bM/GolUzfOG/SUIYiIjIslHqgeRnwfXefDrwF+A8zOyomM7vezNab2fqWlpZBe/FNu9sBqE1UUFdVweumvHqW8utn6aI4IlJ+okwKO4EZOdvTw7JcHwTuAHD33wHVwFE/0d39FndvcvemxsbG4wrG3XlgcwuZzKvjCJ++80kAeq9/k8q5SE7vstgiIuUkyqSwDphnZnPMLEEwkLyqzz4vAZcCmNnrCJLC4DUFcvzq6Vf40+89wvd/++JRj/VOPU3muZSmiEi5iCwpuHsKWA6sAZ4lmGW00cxuNrMl4W5/CVxnZhuA24D3u/dz8sAgeLm1C4DtB4IB5J0HX13K4g9OGAPAi+Hg8kWnHF9rRERkpIt0mQt3Xw2s7lN2U879Z4ALoowh57UA+PeHXuSkxnomj3m1e8gs6D86Z+Z4Hn/pIDdd9bqhCElEZNgp9UBzSXzurqeZPLb6qPKV1yzgK+8+k5MnjylBVCIipVc2SaFvp1TvGkc/vu7VWbJTx9fwR00zEBEpV2WTFPrqTQpa8E5E5FVlkxScI5sK2aRQoaQgItKrfJJCn+6je5/dA0B1Zdm8BSIiBZXNN2Lfea4/fXQHAImKsnkLREQKKptvxHxnP8TC6agiIlJGSSGf3PMVRETKXdkkhXwNgop42bwFIiIFlc03Yn85QVdXExE5Utkkhf7Mnzq28E4iImWkrJNCQl1HIiJHKJtvxf7GFCqVFEREjlA234rWz6jC+m37SxCJiMjwVTZJoT8d3elShyAiMqyUTVLor/tod3vX0AciIjKMlU1S6E8013gTERm5yjoprLxmQalDEBEZVso6Kbz1zCmlDkFEZFgpm6RgWvhORKSgSJOCmS02s01m1mxmK/p5/Otm9kR4e97MDkYZT65ZDbVD9VIiIiNGRVQHNrM4sBK4HNgBrDOzVe7+TO8+7v7JnP0/CpwTVTy5vvyuM7lw3qSheCkRkRElypbCQqDZ3be4ew9wO3D1APsvA26LKpjczqM/PncGU8fXRPVSIiIjVpRJYRqwPWd7R1h2FDObBcwBfh1VMBpSEBEpbLgMNC8F7nT3fk8xNrPrzWy9ma1vaWkZ4tBERMpH3jEFM/sWR1/aOMvdP1bg2DuBGTnb08Oy/iwFPjLAa90C3ALQ1NSkU85ERCIyUEthPfAoUA0sADaHt7OBRBHHXgfMM7M5ZpYg+OJf1XcnMzsVmAD87thCPzbqPRIRKSxvS8HdfwBgZh8GLnT3VLj9b8ADhQ7s7ikzWw6sAeLAre6+0cxuBta7e2+CWArc7q5FJ0RESq2YKakTgLFA7zrT9WFZQe6+Gljdp+ymPttfKOZYr5VOXhMRKayYpPAPwONmtpagF+Yi4AtRBhUF5QQRkcIGTAoW/Ly+B/glcF5Y/Bl3fyXqwEREZOgNmBTc3c1stbufAfx8iGISEZESKeY8hcfM7NzII4mYeo9ERAorZkzhPOC9ZrYN6CD4fnV3PzPSyAabBhVERAoqJilcEXkUIiIyLBRMCu6+DcDMJhOcyCYiIqNUwTEFM1tiZpuBrcB9wIsEs5FGFHUeiYgUVsxA898Ci4Dn3X0OcCnwcKRRRUBDCiIihRWTFJLuvg+ImVnM3dcCTRHHNehiygoiIgUVM9B80MzqgfuBH5nZHoJZSCOKUoKISGHFtBSuBg4DnwR+BbwAvC3KoKKghoKISGHFtBSWAve7+2bgBxHHExlTW0FEpKBiksJM4NtmNofgGgv3Aw+4+xORRjbI1FIQESmsYPeRu3/e3S8B5hNcR+GvCS6+M6Jo6WwRkcIKthTM7HPABQTXUXgc+CuKuMjOcKOUICJSWDHdR+8EUsAvCE5e+527d0caVQTUUBARKayY7qMFwGXAI8DlwFNm9mDUgQ02JQURkcKK6T46HXgj8IcEJ61tZwR2H+nkNRGRwoq9HOcDwDeBde6ejDYkEREplWK6j64iSAj7jjUhmNliM9tkZs1mtiLPPn9sZs+Y2UYz+/GxHP9YqKUgIlJYMaukvg14guBsZszsbDNbVcTz4sBK4EqC6azLzGx+n33mATcAF7j7acAnjrkGRVJOEBEprJhlLr4ALAQOAoQnrc0p4nkLgWZ33+LuPcDtBEtm5LoOWOnuB8Jj7yky7mOmM5pFRAordpXU1j5lXsTzphEMSvfaEZblOgU4xcweMrOHzWxxfwcys+vNbL2ZrW9paSnipfs7xnE9TUSkrBSTFDaa2TVA3Mzmmdm3gN8O0utXAPOAi4FlwHfMbHzfndz9FndvcvemxsbG43ohLyaNiYiUuWKSwkeB04Bu4MdAG8X1/e8EZuRsTw/Lcu0AVrl70t23As8TJAkRESmBYmYfHXb3G9393PB2IzC5iGOvA+aZ2RwzSxCsttp3gPouglYCZjaJoDtpy7FUQEREBs+AScHMzjezd5vZ5HD7zHDa6EOFDuzuKWA5sAZ4FrjD3Tea2c1mtiTcbQ2wz8yeAdYCfx1e5W3QeVHDICIi5S3vyWtm9hXgKoLpqJ8xszXAtcCXgA8Uc3B3Xw2s7lN2U859Bz4V3kREpMQGOqP5rcA57t5lZhMIZhKd7u4vDklkIiIy5AbqPupy9y6A8DyCzUoIIiKj20Athbl9zlyek7vt7kv6ec6wpSmpIiKFDZQU+p59/NUoAxERkdLLmxTc/b6hDEREREqvmJPXRgX1HomIFFY2SUFERAorOimYWW2UgYiISOkVcz2FN4RnHD8Xbp9lZv8SeWSDzDX9SESkoGJaCl8HrgD2Abj7BuCiKIOK0m3XLSp1CCIiw1ZR3Ufuvr1PUTqCWIbE5LFVpQ5BRGTYGug8hV7bzewNgJtZJfBxggXuRERklCmmpfAh4CMEV03bCZwdbouIyChTsKXg7nuB9w5BLENCV+UUEcmvYFIws2/2U9wKrHf3nw9+SCIiUirFdB9VE3QZbQ5vZxJcWvODZvZPEcY2qDQjVUSksGIGms8ELnD3NICZ/SvwAHAh8FSEsUXCTB1IIiL5FNNSmADU52zXARPDJNEdSVQiIlISxbQUvgw8YWa/IRinvQj4ezOrA+6JMLZBpWs0i4gUVszso++Z2WpgYVj0WXd/Obz/15FFFhF1HomI5FfsgnhdwC7gAHCymRW1zIWZLTazTWbWbGYr+nn8/WbWYmZPhLdriw9dREQGWzFTUq8lOIt5OvAEsAj4HXBJgefFgZXA5cAOYJ2ZrXL3Z/rs+hN3X34csYuIyCArpqXwceBcYJu7vwk4BzhYxPMWAs3uvsXde4DbOfoSn0NGU1JFRAorJil0uXsXgJlVuftzwB8U8bxpQO5CejvCsr7eZWZPmtmdZjajvwOZ2fVmtt7M1re0tBTx0vlpRqqISH7FJIUdZjYeuAu428x+DmwbpNf//8Bsdz8TuBv4QX87ufst7t7k7k2NjY2D9NIiItJXMbOP3hHe/YKZrQXGAb8q4tg7gdxf/tPDstxj78vZ/C7B9NdIqPtIRKSwAVsKZhY3s+d6t939PndfFY4RFLIOmGdmc8wsASwFVvU5/pSczSUMwZLcpkmpIiJ5DdhScPd0OKV0pru/dCwHdveUmS0H1gBx4FZ332hmNxMsprcK+JiZLQFSwH7g/cdVCxERGRTFnNE8AdhoZo8AHb2F7r6k0BPdfTWwuk/ZTTn3bwBuKDra10C9RyIihRWTFP4m8iiGkGYfiYjkV8xA831mNguY5+73mFktQXeQiIiMMgWnpJrZdcCdwLfDomkE01NFRGSUKeY8hY8AFwBtAO6+GZgcZVBRcM1JFREpqJik0J07BdXMKtC4rYjIqFRMUrjPzD4L1JjZ5cBPCc5EFhGRUaaYpLACaCG49OZfEEwx/VyUQUVBTRsRkcKKmZL6duCH7v6dqIMZCpqSKiKSXzEthbcBz5vZf5jZVeGYgoiIjEIFk4K7/zlwMsFYwjLgBTP7btSBDTr1H4mIFFTUr353T5rZLwm+WmsIupRG5KUzTf1HIiJ5FXPy2pVm9n1gM/AugiWuT4w4LhERKYFiWgp/BvwE+At37444HhERKaFi1j5alrttZhcCy9z9I5FFFQHXoIKISEFFjSmY2TnANcAfAVuB/4wyqChpREFEJL+8ScHMTiGYbbQM2EvQhWTu/qYhik1ERIbYQC2F54AHgKvcvRnAzD45JFFFQOvhiYgUNtDso3cCu4C1ZvYdM7uUUdD7ohmpIiL55U0K7n6Xuy8FTgXWAp8AJpvZv5rZm4cqQBERGTrFnNHc4e4/dve3AdOBx4HPFHNwM1tsZpvMrNnMVgyw37vMzM2sqejIj5F6j0RECitm7aMsdz/g7re4+6WF9jWzOLASuBKYDywzs/n97DcG+Djw+2OJ5XjZyO8BExGJzDElhWO0EGh29y3hRXpuB67uZ7+/Bf4R6IowFhERKUKUSWEasD1ne0dYlmVmC4AZ7v6LCOMQEZEiRZkUBmRmMeBrwF8Wse/1ZrbezNa3tLQc1+tpSqqISGFRJoWdwIyc7elhWa8xwOnAb8zsRWARsKq/weZwHKPJ3ZsaGxtfU1Cakioikl+USWEdMM/M5phZAlgKrOp90N1b3X2Su89299nAw8ASd18fYUwiIjKAyJKCu6eA5cAa4FngDnffaGY3m9mSqF43bzyalCoiUlCkl9Z099XA6j5lN+XZ9+IoY+ml3iMRkfxKNtAsIiLDT9kkBc0+EhEprGySQpb6j0RE8iq/pCAiInkpKYiISFbZJAUNKYiIFFY2SaGXVkkVEcmv7JKCiIjkVz5JQXNSRUQKKp+kENKCeCIi+ZVdUhARkfzKJimo80hEpLCySQq91HskIpJf2SUFERHJT0lBRESyyiYpaEaqiEhhZZMUepnmpIqI5FV2SUFERPIrm6Tg6j8SESmobJJCL3UeiYjkF2lSMLPFZrbJzJrNbEU/j3/IzJ4ysyfM7EEzmx9lPCIiMrDIkoKZxYGVwJXAfGBZP1/6P3b3M9z9bODLwNeiikedRyIihUXZUlgINLv7FnfvAW4Hrs7dwd3bcjbrGILvbk0+EhHJryLCY08Dtuds7wDO67uTmX0E+BSQAC6JMB4RESmg5APN7r7S3U8CPgN8rr99zOx6M1tvZutbWlqGNkARkTISZVLYCczI2Z4eluVzO/D2/h5w91vcvcndmxobG48rGM1IFREpLMqksA6YZ2ZzzCwBLAVW5e5gZvNyNt8KbI4wnuA1NSlVRCSvyMYU3D1lZsuBNUAcuNXdN5rZzcB6d18FLDezy4AkcAB4X1TxiIhIYVEONOPuq4HVfcpuyrn/8Shf/4jXHaoXEhEZwUo+0Dzk1HskIpJX+SUFERHJq2ySghbEExEprGySQi+d0Swikl/ZJQUREclPSUFERLKUFEREJKvskoKGFERE8iu7pCAiIvmVTVLQjFQRkcLKJin0Ms1JFRHJq+ySgoiI5Fc2ScG1JJ6ISEFlkxR6qfNIRCS/sksKIiKSn5KCiIhklU1S0JRUEZHCyiYp9NKMVBGR/MouKYiISH5lkxTmNtbz1jOmEFNTQUQkr0iTgpktNrNNZtZsZiv6efxTZvaMmT1pZvea2ayoYrl8/gmsfO8CqivjUb2EiMiIF1lSMLM4sBK4EpgPLDOz+X12exxocvczgTuBL0cVj4iIFBZlS2Eh0OzuW9y9B7gduDp3B3df6+6Hw82HgekRxiMiIgVEmRSmAdtztneEZfl8EPhlhPGIiEgBFaUOAMDM/gRoAv4wz+PXA9cDzJw5cwgjExEpL1G2FHYCM3K2p4dlRzCzy4AbgSXu3t3fgdz9FndvcvemxsbGSIIVEZFok8I6YJ6ZzTGzBLAUWJW7g5mdA3ybICHsiTAWEREpQmRJwd1TwHJgDfAscIe7bzSzm81sSbjbV4B64Kdm9oSZrcpzOBERGQKRjim4+2pgdZ+ym3LuXxbl64uIyLExH2ErxZlZC7DtOJ8+Cdg7iOGMBKpzeSi3OpdbfeG113mWuxcclB1xSeG1MLP17t5U6jiGkupcHsqtzuVWXxi6OpfN2kciIlKYkoKIiGSVW1K4pdQBlIDqXB7Krc7lVl8YojqX1ZiCiIgMrNxaCiIiMoCySQqFru0wkpjZrWa2x8yezimbaGZ3m9nm8N8JYbmZ2TfDej9pZgtynvO+cP/NZva+UtSlGGY2w8zWhtfe2GhmHw/LR3Odq83sETPbENb5/4blc8zs92HdfhKuFoCZVYXbzeHjs3OOdUNYvsnMrihNjYpjZnEze9zM/jvcHu31fdHMngpP3l0flpX2c+3uo/4GxIEXgLlAAtgAzC91XK+hPhcBC4Cnc8q+DKwI768A/jG8/xaC1WcNWAT8PiyfCGwJ/50Q3p9Q6rrlqe8UYEF4fwzwPME1OkZznQ2oD+9XAr8P63IHsDQs/zfgw+H9/wP8W3h/KfCT8P788PNeBcwJ/w7ipa7fAPXq0HE7AAAEw0lEQVT+FPBj4L/D7dFe3xeBSX3KSvq5LpeWQsFrO4wk7n4/sL9P8dXAD8L7PwDenlP+Qw88DIw3synAFcDd7r7f3Q8AdwOLo4/+2Ln7Lnd/LLzfTrBsyjRGd53d3Q+Fm5XhzYFLCC5IBUfXufe9uBO41MwsLL/d3bvdfSvQTPD3MOyY2XTgrcB3w21jFNd3ACX9XJdLUjjWazuMRCe4+67w/ivACeH9fHUfke9J2E1wDsEv51Fd57Ar5QlgD8Ef+gvAQQ/WFYMj48/WLXy8FWhgZNX5n4BPA5lwu4HRXV8IEv3/mNmjFlwiAEr8uR4W11OQweXubmajblqZmdUDPwM+4e5twQ/DwGiss7ungbPNbDzwX8CpJQ4pMmZ2FbDH3R81s4tLHc8QutDdd5rZZOBuM3su98FSfK7LpaVQ1LUdRrjdYVOS8N/epcjz1X1EvSdmVkmQEH7k7v8ZFo/qOvdy94PAWuB8gi6D3h9zufFn6xY+Pg7Yx8ip8wXAEjN7kaB79xLgG4ze+gLg7jvDf/cQJP6FlPhzXS5JoeC1HUaBVUDvrIP3AT/PKf+zcObCIqA1bJquAd5sZhPC2Q1vDsuGnbCv+HvAs+7+tZyHRnOdG8MWAmZWA1xOMJayFnh3uFvfOve+F+8Gfu3BKOQqYGk4W2cOMA94ZGhqUTx3v8Hdp7v7bIK/z1+7+3sZpfUFMLM6MxvTe5/g8/g0pf5cl3r0fahuBCP3zxP0y95Y6nheY11uA3YBSYL+ww8S9KfeC2wG7gEmhvsasDKs91NAU85xPkAwENcM/Hmp6zVAfS8k6Ht9EngivL1llNf5TODxsM5PAzeF5XMJvuSagZ8CVWF5dbjdHD4+N+dYN4bvxSbgylLXrYi6X8yrs49GbX3Dum0Ibxt7v5dK/bnWGc0iIpJVLt1HIiJSBCUFERHJUlIQEZEsJQUREclSUhARkSwlBSlbZnYo/He2mV0zyMf+bJ/t3w7m8UWioqQgArOBY0oKOWfZ5nNEUnD3NxxjTCIloaQgAv8AvDFc0/6T4UJ0XzGzdeG69X8BYGYXm9kDZrYKeCYsuytczGxj74JmZvYPQE14vB+FZb2tEguP/XS4jv57co79GzO708yeM7MfWe7iTiJDRAviiQRr1v+Vu18FEH65t7r7uWZWBTxkZv8T7rsAON2DZZkBPuDu+8OlKNaZ2c/cfYWZLXf3s/t5rXcCZwNnAZPC59wfPnYOcBrwMvAQwXpADw5+dUXyU0tB5GhvJlhj5gmCJbobCNbQAXgkJyEAfMzMNgAPEyxKNo+BXQjc5u5pd98N3Aecm3PsHe6eIVjKY/ag1EbkGKilIHI0Az7q7kcsKhYu6dzRZ/sy4Hx3P2xmvyFYk+d4defcT6O/TykBtRREoJ3gMp+91gAfDpfrxsxOCVex7GsccCBMCKcSXCKxV7L3+X08ALwnHLdoJLi06rBcxVPKk36JiAQrkabDbqDvE6zjPxt4LBzsbeHVSyLm+hXwITN7lmBFzodzHrsFeNLMHvNgCehe/0VwXYQNBCu/ftrdXwmTikjJaZVUERHJUveRiIhkKSmIiEiWkoKIiGQpKYiISJaSgoiIZCkpiIhIlpKCiIhkKSmIiEjW/wKetQRQ6J516QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Softmax agent, beta= 0.1\n",
      "maximum possible reward: 0.9875803648377603\n",
      "average reward: [0.89066404]\n",
      "cosine similarity 0.9850149331951742\n",
      "euclidian norm  0.027397006102730444\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "UCB1 agent\n",
      "maximum possible reward: 0.9875803648377603\n",
      "average reward: [0.93776872]\n",
      "cosine similarity 1.0\n",
      "euclidian norm  0.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test(agents, 5000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Experimental stuff:\n",
    "\n",
    "Below are a few agents I wrote for fun."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "class softmax_with_exponentiation(agent):\n",
    "\n",
    "    def __init__(self, arms, play_once=1, beta=1, exp=1):\n",
    "        super().__init__(arms, play_once)\n",
    "        self.beta = beta\n",
    "        self.exp = exp\n",
    "\n",
    "    def policy(self):\n",
    "        temp = np.exp(self.expectations/self.beta)\n",
    "        ans = temp / np.sum(temp, axis=0)\n",
    "        ans = ans**self.exp\n",
    "        ans /= np.sum(ans, axis=0)\n",
    "        return ans\n",
    "\n",
    "\n",
    "class softmax_with_reccurence(agent):\n",
    "\n",
    "    def __init__(self, arms, play_once=1, beta=1):\n",
    "        super().__init__(arms, play_once)\n",
    "        self.old_policy = np.ones_like(self.expectations)/self.l\n",
    "        self.beta = beta\n",
    "\n",
    "    def policy(self):\n",
    "        temp = np.exp(self.expectations/self.beta)\n",
    "        new_policy = temp / np.sum(temp, axis=0)\n",
    "\n",
    "        result = np.multiply(new_policy, self.old_policy)\n",
    "        result /= np.sum(result, axis=0)\n",
    "        self.old_policy = result\n",
    "\n",
    "        return result\n",
    "\n",
    "\n",
    "class greedy_with_reccurence(agent):\n",
    "    # alpha = number < 1; will sum over a number of observations and will keep\n",
    "    # osiclating.\n",
    "    # alpha = N will allow the algo to converge to an arm, greedy doesn't\n",
    "    # really need this, kind of always give one answer.\n",
    "\n",
    "    def __init__(self, arms, play_once=1, alpha=1):\n",
    "        super().__init__(arms, play_once)\n",
    "        self.old_policy = np.ones_like(self.expectations)\n",
    "        self.alpha = alpha\n",
    "\n",
    "    def policy(self):\n",
    "        new_policy = np.zeros_like(self.expectations)\n",
    "        new_policy[np.argmax(self.expectations)] = 1\n",
    "\n",
    "        new_policy = (1-self.alpha)*new_policy + self.alpha*self.old_policy\n",
    "\n",
    "        new_policy /= np.sum(new_policy, axis=0)\n",
    "        self.old_policy = new_policy\n",
    "\n",
    "        return new_policy\n",
    "\n",
    "# class magic(agent):\n",
    "#    def __init__(self, arms, play_once=1, exp=1):\n",
    "#        super().__init__(arms, play_once)\n",
    "#        self.old_policy = np.ones_like(self.expectations)/self.l\n",
    "#        self.exp = exp\n",
    "#\n",
    "#    def policy(self):\n",
    "#        new_policy = f(old_policy, g(expectations))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "arms = [Arm(mu=i,sigma=0) for i in range(4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arms[3].pull()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "class state:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def __repr___(self):\n",
    "        return f\"state(\\\"{self.name}\\\")\"\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.__repr__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.abs(np.random.randn(3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "t /= t.sum(axis=0, keepdims=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.sum(axis=0, keepdims=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.35690573, 0.4321061 , 0.06322358],\n",
       "       [0.61329573, 0.4507365 , 0.41143156],\n",
       "       [0.02979853, 0.11715741, 0.52534486]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [0]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = t.dot(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 10000\n",
    "l = s\n",
    "ls = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(n):\n",
    "    l = t.dot(l)\n",
    "    ls.append(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999999999999996"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 50\n",
    "\n",
    "states = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [0],\n",
       "       [1]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(n):\n",
    "    p = t.dot(s)\n",
    "    l = np.random.choice(p.shape[0],1,p=p.squeeze())\n",
    "    s = np.zeros_like(s)\n",
    "    s[l] = 1\n",
    "    states.append(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f2ede6ea588>]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([np.argmax(i) for i in states])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "class hard_generator:\n",
    "    \"\"\"A hard generator, which is stochastic but the underlying transition probabilities are stationary\"\"\"\n",
    "    def __init__(self, init, t):\n",
    "        self.t = t\n",
    "        self.init = init\n",
    "        self.current = init\n",
    "        \n",
    "    def __reset__(self):\n",
    "        self.current = self.init\n",
    "        \n",
    "    def step(self):\n",
    "        p = self.t.dot(self.current)\n",
    "     \n",
    "        self.current = np.zeros_like(self.current)\n",
    "        self.current[l] = 1\n",
    "        return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "class easy_generator:\n",
    "    \"\"\"A deterministic stationary generator\"\"\"\n",
    "    def __init__(self, init, t):\n",
    "        self.t = t\n",
    "        self.init = init\n",
    "        self.current = init\n",
    "        \n",
    "    def __reset__(self):\n",
    "        self.current = self.init\n",
    "        \n",
    "    def step(self):\n",
    "        p = self.t.dot(self.current)\n",
    "        l = np.random.choice(p.shape[0], 1 , p = p.squeeze())\n",
    "        self.current = np.zeros_like(self.current)\n",
    "        self.current[l] = 1\n",
    "        return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.array([[0,1,0],\n",
    "             [0,0,1],\n",
    "             [1,0,0]])\n",
    "init = np.array([[0,1,0]]).T\n",
    "\n",
    "gen = generator(init, t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0],\n",
       "       [0, 0, 1],\n",
       "       [1, 0, 0]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class learner:\n",
    "    def __init__(self, init, t):\n",
    "        self.t = t\n",
    "        self.init = init\n",
    "        self.current = init\n",
    "    \n",
    "    def __reset__(self):\n",
    "        self.current = self.init\n",
    "        \n",
    "    def step(self):\n",
    "        \n",
    "        return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}