Treasure Drop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Lever:\n",
    "    def __init__(self):\n",
    "        self.position = np.random.randint(low=0, high=2)\n",
    "        self.coin = 0\n",
    "        self.leftChild = None  #these are either levers or ints.\n",
    "        self.rightChild = None\n",
    "        self.leftMouth = 0\n",
    "        self.rightMouth = 0\n",
    "    def printTop(self):  #prints top part and puts a | character end of it.\n",
    "        letter = 'V' if self.coin == 0 else 'O'\n",
    "        if self.position == 0:  #means left\n",
    "            print(letter + '  |', end=\"\")\n",
    "        else:\n",
    "            print('  ' + letter + '|', end=\"\")\n",
    "    def printMiddle(self):\n",
    "        if self.position == 0:\n",
    "            print(' \\ |', end=\"\")\n",
    "        else:\n",
    "            print(' / |', end=\"\")\n",
    "    def printBottom(self):\n",
    "        if self.position == 0:\n",
    "            print('  \\ ', end=\"\")\n",
    "        else:\n",
    "            print('/   ', end=\"\")\n",
    "            \n",
    "    def spitToLeft(self, i):\n",
    "        if self.leftChild == None: #for testing purposes\n",
    "            return 0\n",
    "        elif type(self.leftChild) == int:  #It's left child is a bucket therefore it's returning a score.\n",
    "            return i*self.leftChild\n",
    "        else:\n",
    "            self.leftChild.rightMouth += i\n",
    "            return 0\n",
    "            \n",
    "    def spitToRight(self, i):\n",
    "        if self.rightChild == None: #for testing purposes\n",
    "            return 0\n",
    "        if type(self.rightChild) == int:\n",
    "            return i*self.rightChild\n",
    "        else:\n",
    "            self.rightChild.leftMouth += i\n",
    "            return 0\n",
    "    def applyMotion(self):\n",
    "        score = 0\n",
    "        \n",
    "        if self.coin == 1:  #CASE 1\n",
    "            temp = self.leftMouth + self.rightMouth\n",
    "            self.leftMouth = 0 \n",
    "            self.rightMouth = 0\n",
    "            \n",
    "            if self.position == 0:  #O--\n",
    "                score += self.spitToRight(temp)\n",
    "                self.leftMouth = 1\n",
    "                self.coin = 0 #coin airborne\n",
    "            else:\n",
    "                score += self.spitToLeft(temp)\n",
    "                self.rightMouth = 1\n",
    "                self.coin = 0 #coin airborne\n",
    "                \n",
    "            if temp % 2 == 1:  #sum of coins is odd. Let's flip the lever\n",
    "                self.position = 0 if self.position == 1 else 1\n",
    "            \n",
    "        elif self.coin == 0:  #CASE 2, 3 and 4\n",
    "            #Here, the order of if statements are important. Do not change the order.\n",
    "            if self.leftMouth != 0 and self.rightMouth != 0 : #CASE 4\n",
    "                temp = self.leftMouth + self.rightMouth - 1\n",
    "                self.leftMouth = 0\n",
    "                self.rightMouth = 0\n",
    "                \n",
    "                if self.position == 0:  #U--\n",
    "                    score += self.spitToRight(temp)\n",
    "                    self.leftMouth = 1  #coin airborne\n",
    "                else:  #--U\n",
    "                    score += self.spitToLeft(temp)\n",
    "                    self.rightMouth = 1  #coin airborne\n",
    "                    \n",
    "                if temp % 2 == 1:  #sum of coins is odd. Let's flip the lever.\n",
    "                    self.position = 0 if self.position == 1 else 1\n",
    "                    \n",
    "            elif (self.leftMouth != 0 and self.position == 0) or (self.rightMouth != 0 and self.position == 1):\n",
    "                #CASE 2: Coin only arrives on top of empty slot.\n",
    "                \n",
    "                temp = self.leftMouth + self.rightMouth\n",
    "                self.leftMouth = 0\n",
    "                self.rightMouth = 0\n",
    "                self.coin = 1\n",
    "                temp -= 1\n",
    "                \n",
    "                if temp>0:  #Apparently, more than one coin arrived to the empty slot.\n",
    "                    if self.position == 0:  #U--\n",
    "                        score += self.spitToRight(temp)\n",
    "                        self.leftMouth = 1  #coin airborne\n",
    "                        self.coin = 0\n",
    "                    else:  #--U\n",
    "                        score += self.spitToLeft(temp)\n",
    "                        self.rightMouth = 1  #coin airborne\n",
    "                        self.coin = 0\n",
    "                        \n",
    "                if temp % 2 == 1:\n",
    "                    self.position = 0 if self.position == 1 else 1\n",
    "                    \n",
    "            elif (self.leftMouth != 0 and self.position == 1) or (self.rightMouth != 0 and self.position == 0):\n",
    "                #CASE 3: Coin only arrives to the non-slot side of lever.\n",
    "                \n",
    "                temp = self.leftMouth + self.rightMouth\n",
    "                self.leftMouth = 0\n",
    "                self.rightMouth = 0\n",
    "                \n",
    "                if self.position == 0:  #U--\n",
    "                    score += self.spitToRight(temp)\n",
    "                else:  #--U\n",
    "                    score += self.spitToLeft(temp)\n",
    "                    \n",
    "                if temp % 2 == 1:\n",
    "                    self.position = 0 if self.position == 1 else 1\n",
    "                    \n",
    "        return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    if n==1: \n",
    "        return 1\n",
    "    elif n==2: \n",
    "        return 2\n",
    "    else: \n",
    "        return fib(n-1)+fib(n-2)\n",
    "\n",
    "def fibonacciBuckets(length):  #length must be the number of lever in the bottom row.\n",
    "    buckets = [fib(n+1) for n in range(length)]\n",
    "    bucketsR = buckets.copy()\n",
    "    bucketsR.reverse()\n",
    "    return bucketsR+buckets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TreasureDrop:\n",
    "    def __init__(self, w=4, h=5, player=1, goalScore = 100):\n",
    "        #init levers bottom up, starting from buckets\n",
    "        if player != 1 and player != 2:  #player is who goes first here.\n",
    "            raise(Exception(\"Starting player can be 1 or 2, 1 by defauly.\"))\n",
    "        self.player = player\n",
    "        self.winner = None\n",
    "        self.isOver = False\n",
    "        self.p1score = 0\n",
    "        self.p2score = 0\n",
    "        self.goalScore = goalScore\n",
    "        self.w = w\n",
    "        self.h = h\n",
    "        self.buckets = fibonacciBuckets(w+self.h-1)  #This should be ints\n",
    "        self.levers = [[Lever() for n in range(w+i)] for i in range(self.h)]\n",
    "        #Set the lever hierarchy\n",
    "        for rowIndex in range(len(self.levers)):\n",
    "            for colIndex in range(len(self.levers[rowIndex])):\n",
    "                if rowIndex < len(self.levers)-1:  #Not the last row of levers\n",
    "                    self.levers[rowIndex][colIndex].leftChild = self.levers[rowIndex+1][colIndex]\n",
    "                    self.levers[rowIndex][colIndex].rightChild = self.levers[rowIndex+1][colIndex+1]\n",
    "                else:  #The last row of levers, buckets should be their children.\n",
    "                    self.levers[rowIndex][colIndex].leftChild = self.buckets[colIndex*2]\n",
    "                    self.levers[rowIndex][colIndex].rightChild = self.buckets[colIndex*2+1]\n",
    "        \n",
    "    def dropCoin(self, loc, verbose=False):  #loc starts from zero.\n",
    "        #Exception if game already ended or invalid location for coin\n",
    "        if self.winner:\n",
    "            raise(Exception(\"There is a winner. Can't play anymore.\"))\n",
    "        elif loc >= self.w*2:\n",
    "            raise(Exception(\"Invalid loc for coin\"))\n",
    "            \n",
    "        #Put the coin in proper mouth.\n",
    "        colIndex = loc//2\n",
    "        if loc%2 == 0:  #give it to left mouth\n",
    "            self.levers[0][colIndex].leftMouth = 1\n",
    "        elif loc%2 == 1:  #give it to right mouth\n",
    "            self.levers[0][colIndex].rightMouth = 1\n",
    "            \n",
    "        #Loop through levers until all mouths are empty\n",
    "        #Give every lever a timestep to move.\n",
    "        #Also, Collect the score at the same time\n",
    "        allMouthsAreEmpty = False\n",
    "        score = 0\n",
    "        while not allMouthsAreEmpty:  #Update should be from bottom rows all the way up\n",
    "            allMouthsAreEmpty = True\n",
    "            for r in range(len(self.levers)-1, -1, -1):  #Going through levers in a reverse order.\n",
    "                for i, l in enumerate(self.levers[r]):  #enumerating for debugging purposes.\n",
    "                    if l.leftMouth != 0 or l.rightMouth != 0:\n",
    "                        allMouthsAreEmpty = False\n",
    "                        score += l.applyMotion()\n",
    "        \n",
    "        #Give score to player\n",
    "        if self.player == 1:\n",
    "            self.p1score += score\n",
    "        elif self.player == 2:\n",
    "            self.p2score += score\n",
    "        \n",
    "        #It's other player's turn\n",
    "        if self.player == 1:\n",
    "            self.player = 2\n",
    "        elif self.player == 2:\n",
    "            self.player = 1\n",
    "        \n",
    "        #Check if the game ends\n",
    "        if self.p1score >= self.goalScore:\n",
    "            self.player = None\n",
    "            self.winner = 1\n",
    "            self.isOver = True\n",
    "        elif self.p2score >= self.goalScore:\n",
    "            self.player = None\n",
    "            self.winner = 2\n",
    "            self.isOver = True\n",
    "            \n",
    "        #If verbose, print the game state. OR, do this job somewhere else. I'm not sure.\n",
    "        if verbose:\n",
    "            self.printState()\n",
    "            \n",
    "        return score\n",
    "        \n",
    "    \n",
    "    def printRowOfLevers(self, rowIndex):  #Helper function of printState\n",
    "        #Print 1st line\n",
    "        print(\" \" * (self.h-rowIndex)*2 + '|', end=\"\")\n",
    "        for lever in self.levers[rowIndex]:\n",
    "            lever.printTop()\n",
    "        print(\"\")  #Jump to new line\n",
    "        #Print 2nd line\n",
    "        print(\" \" * (self.h-rowIndex)*2 + '|', end=\"\")\n",
    "        for lever in self.levers[rowIndex]:\n",
    "            lever.printMiddle()\n",
    "        print(\"\")  #Jump to new line\n",
    "        #Print 3rd line\n",
    "        leftBottomEdge = \" |\" if rowIndex == self.h-1 else \"/ \"\n",
    "        rightBottomEdge = \"\\b|\" if rowIndex == self.h-1 else \"\\\\\"\n",
    "        print(\" \" * ((self.h-rowIndex)*2-1) + leftBottomEdge, end=\"\")\n",
    "        for lever in self.levers[rowIndex]:\n",
    "            lever.printBottom()\n",
    "            \n",
    "        print(rightBottomEdge)\n",
    "        \n",
    "    def printState(self):\n",
    "        #Print score line\n",
    "        print(\"Player 1                 Player 2\")\n",
    "        print(\"%s\\t\\t\\t\\t%s\" % (self.p1score, self.p2score))\n",
    "        #Print TURN/WINNER line\n",
    "        if self.winner:\n",
    "            if self.winner == 1:\n",
    "                print(\"WINNER                           \")\n",
    "            elif self.winner == 2:\n",
    "                print(\"                           WINNER\")\n",
    "        else:\n",
    "            if self.player == 1:\n",
    "                print(\"TURN                             \")\n",
    "            elif self.player == 2:\n",
    "                print(\"                             TURN\")\n",
    "        #Print the available moves row\n",
    "        print(' '*self.h*2+\"|\", end=\"\")\n",
    "        for i in range(self.w*2):\n",
    "            print(str(i)+\"|\", end=\"\")\n",
    "        print()\n",
    "        #Print enterance row\n",
    "        print(' '*self.h*2 + \"|\" + \" |\"*self.w*2)\n",
    "        #Print intermediary rows\n",
    "        for idx, _ in enumerate(self.levers):\n",
    "            self.printRowOfLevers(idx)\n",
    "        #Print exit row\n",
    "        print('  ', end=\"\")\n",
    "        print(\"|\" + \" |\"*(self.w+self.h-1)*2)\n",
    "        #Print buckets\n",
    "        print(\"  |\", end=\"\")\n",
    "        for b in self.buckets:\n",
    "            numberToPrint = b//10\n",
    "            characterToPrint = \" \" if numberToPrint == 0 else str(numberToPrint)\n",
    "            print(characterToPrint+\"|\", end=\"\")\n",
    "        print()  #In order to move on to the next line\n",
    "        print(\"  |\", end=\"\")\n",
    "        for b in self.buckets:\n",
    "            print(str(b%10)+\"|\", end=\"\")\n",
    "        print()\n",
    "        print()\n",
    "    \n",
    "    def getState(self):  #state returns as a string\n",
    "        state = []\n",
    "        for r in range(len(self.levers)):\n",
    "            for l in self.levers[r]:\n",
    "                state.append(l.position)\n",
    "                state.append(l.coin)\n",
    "        return str(state), self.w, self.h\n",
    "    \n",
    "    def setState(self, state, w, h):  #adjust the states of levers according to the given state\n",
    "        if self.w != w or self.h != h:\n",
    "            print(self.w)\n",
    "            print(w)\n",
    "            print(self.h)\n",
    "            print(h)\n",
    "            raise(Exception(\"width and height not compatible for setState().\"))\n",
    "        \n",
    "        s = list(state)\n",
    "        for r in range(len(self.levers)):\n",
    "            for l in self.levers[r]:\n",
    "                l.position = s.pop(0)\n",
    "                l.coin = s.pop(0)\n",
    "    \n",
    "    def nextStatesAndRewards(self):  #Returns next states as strings and associated rewards.\n",
    "        currentState = self.getState()  #preserving the current state\n",
    "        nextStatesAndRewards = []\n",
    "        #because nextState[1] is width and nextState[2] is height\n",
    "        for i in range(self.w*2):\n",
    "            td = TreasureDrop(w=self.w, h=self.h)\n",
    "            td.setState(currentState[0], currentState[1], currentState[2])\n",
    "            reward = td.dropCoin(i, verbose=False)\n",
    "            nextState = td.getState()[0]\n",
    "            nextStatesAndRewards.append((nextState, reward))\n",
    "        return nextStatesAndRewards\n",
    "    \n",
    "    def playable(self):\n",
    "        return not self.isOver\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Play with Random Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Make a move: \n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: ''",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m--------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-389-226580d44b4e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mreply\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"q\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m     \u001b[0mmove\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreply\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m     \u001b[0mtd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdropCoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmove\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0mtd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdropCoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlow\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhigh\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m#The random Agent\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: ''"
     ]
    }
   ],
   "source": [
    "td = TreasureDrop(w=4, h=5)\n",
    "\n",
    "state = None\n",
    "while not td.isOver:\n",
    "    reply = input(\"Make a move: \")\n",
    "    if reply == \"q\": \n",
    "        break\n",
    "    move = int(reply)\n",
    "    td.dropCoin(move, verbose=True)\n",
    "    td.dropCoin(np.random.randint(low=0, high=2*w-1), verbose=True)  #The random Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Learning Part (still in progress)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "metadata": {},
   "outputs": [],
   "source": [
    "#QUESTIONS\n",
    "#\n",
    "class Agent():\n",
    "    def __init__(self, game_class, epsilon=0.1, alpha=1.0, gamma = 0.1, value_player=1, num_actions=8):\n",
    "        self.V = dict() # Build up the values of different states as we encounter them; Note the Markov assumption\n",
    "        self.NewGame = game_class\n",
    "        self.epsilon = epsilon\n",
    "        self.alpha = alpha\n",
    "        self.value_player = value_player\n",
    "        self.gamma = gamma\n",
    "        self.num_actions = num_actions\n",
    "        self.Q = defaultdict(lambda: np.zeros(num_actions))\n",
    "    \n",
    "    def learn_game(self, n_episodes=1_000):\n",
    "        \n",
    "        for episode in range(n_episodes):\n",
    "            self.learn_from_episode()\n",
    "\n",
    "    def learn_from_episode(self):\n",
    "        \n",
    "        game = self.NewGame()\n",
    "        while game.playable():\n",
    "            self.learn_from_move(game)\n",
    "            \n",
    "    def learn_from_move(self, game):\n",
    "        \n",
    "        #pick an action, e_greedily\n",
    "        state = game.getState()\n",
    "        e_greedy_action = np.argmax(self.Q[state])\n",
    "        if np.random.rand() < self.epsilon:  #random by epsilon\n",
    "            e_greedy_action = np.random.randint(low=0, high=self.num_actions)\n",
    "        \n",
    "        #do that action, get the reward\n",
    "        reward = game.dropCoin(e_greedy_action)\n",
    "        next_state = game.getState()\n",
    "        \n",
    "        #update q table\n",
    "        current_state_action_value = self.Q[state][e_greedy_action]\n",
    "        next_greedy_action = np.argmax(self.Q[next_state])\n",
    "        td_target = reward + self.gamma * self.Q[next_state][next_greedy_action]\n",
    "        td_error = td_target - self.Q[state][e_greedy_action]\n",
    "        self.Q[state][e_greedy_action] += self.alpha * td_error\n",
    "    \n",
    "    def pick_greedy_actionplay_select_move(self, game):\n",
    "        \n",
    "        state = game.getState()[0]\n",
    "        if game.player == self.value_player:  #Agent's turn\n",
    "            return np.argmax(self.Q[state])\n",
    "        else:  #Enemy agent's turn\n",
    "            return np.argmin(self.Q[state])\n",
    "        \n",
    "    def demo_game(self, verbose=False):\n",
    "        #Two agents play againt each other.\n",
    "        game = self.NewGame()\n",
    "        while game.playable():\n",
    "            action = self.pick_greedy_action(game)\n",
    "            game.dropCoin(action)\n",
    "            \n",
    "        return (game.p1score, game.p2score, game.winner)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 391,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def print_demo_game_stats(agent, n_games=100):\n",
    "    \n",
    "    results = [agent.demo_game() for _ in range(n_games)]\n",
    "    game_stats = {long_name[k]: v/n_games for k, v in results.items()}\n",
    "    for k in long_name.values():\n",
    "        print(f\"{k:<7}: {game_stats.get(k, 0):^8.2%}\")\n",
    "    #print avgp1score, avgp2score, nump1wins, nump2wins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 141, 2)"
      ]
     },
     "execution_count": 397,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agent = Agent(TreasureDrop, epsilon=0.1, alpha=0.1, gamma = 0.1, value_player=1, num_actions=8)\n",
    "agent.demo_game()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x1101eea88>"
      ]
     },
     "execution_count": 395,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}