rl.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "rl.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "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.8.2"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/adityaras/2048-Solver-using-TD-Learning/blob/master/rl.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HFdw6MGn95dt",
        "outputId": "f783dcac-c16b-442a-979e-88c84c65ae4d"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tJ0FJHdI-CNO",
        "outputId": "4207ac69-62f8-4478-c276-6976a95c88e9"
      },
      "source": [
        "cd /content/drive/MyDrive/RL"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/drive/MyDrive/RL\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
        "id": "oVxwMqCv39-W"
      },
      "source": [
        "import numpy as np \n",
        "import pandas as pd \n",
        "import os\n",
        "import random\n",
        "import numpy\n",
        "import copy\n",
        "import math\n",
        "from itertools import permutations "
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
        "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
        "id": "1TaMUfXl39-n"
      },
      "source": [
        "def print_board(tiles):\n",
        "    print(\" ---------------\")\n",
        "    for i in range(4):\n",
        "        print(\"| \",end=\"\")\n",
        "        for j in range(4):\n",
        "            if tiles[i][j]==0:\n",
        "                print(\" \"+\" | \",end=\"\")\n",
        "            else:\n",
        "                print(str(tiles[i][j])+\" | \",end=\"\")\n",
        "        print(\"\")\n",
        "        print(\" ---------------\")\n",
        "\n",
        "def new_tile(tiles):\n",
        "    available_cells=[]\n",
        "    for i in range(4):\n",
        "        for j in range(4):\n",
        "            if tiles[i][j]==0:\n",
        "                available_cells.append([i,j])\n",
        "    pos=random.randint(0,len(available_cells)-1)\n",
        "    val=numpy.random.choice([2,4],p=[0.9,0.1])\n",
        "    return available_cells[pos],val\n",
        "\n",
        "def check_game_over(tiles):\n",
        "    for i in range(4):\n",
        "        for j in range(4):\n",
        "            if tiles[i][j]==0:\n",
        "                return False\n",
        "    for i in range(4):\n",
        "        for j in range(3):\n",
        "            if tiles[i][j]==tiles[i][j+1]:\n",
        "                return False\n",
        "    for j in range(4):\n",
        "        for i in range(3):\n",
        "            if tiles[i][j]==tiles[i+1][j]:\n",
        "                return False\n",
        "    return True\n",
        "\n",
        "def take_action(tiles,action):\n",
        "    temp=copy.deepcopy(tiles)\n",
        "    update=0\n",
        "    if action==1:\n",
        "        for col in range(4):\n",
        "            for row in range(1,4):\n",
        "                if tiles[row][col]!=0:\n",
        "                    i=row-1\n",
        "                    f=0\n",
        "                    while(i>=0 and tiles[i][col]==0):\n",
        "                        f=1\n",
        "                        i-=1\n",
        "                    if f==1:\n",
        "                        tiles[i+1][col]=tiles[row][col]\n",
        "                        tiles[row][col]=0\n",
        "            for row in range(3):\n",
        "                if tiles[row][col]==tiles[row+1][col]:\n",
        "                    tiles[row][col]+=tiles[row][col]\n",
        "                    update+=tiles[row][col]\n",
        "                    for i in range(row+1,3):\n",
        "                        tiles[i][col]=tiles[i+1][col]\n",
        "                    tiles[3][col]=0\n",
        "    elif action==2:\n",
        "        for col in range(4):\n",
        "            for row in range(2,-1,-1):\n",
        "                if tiles[row][col]!=0:\n",
        "                    i=row+1\n",
        "                    f=0\n",
        "                    while(i<4 and tiles[i][col]==0):\n",
        "                        i+=1\n",
        "                        f=1\n",
        "                    if f==1:\n",
        "                        tiles[i-1][col]=tiles[row][col]\n",
        "                        tiles[row][col]=0\n",
        "            for row in range(3,0,-1):\n",
        "                if tiles[row][col]==tiles[row-1][col]:\n",
        "                    tiles[row][col]+=tiles[row][col]\n",
        "                    update+=tiles[row][col]\n",
        "                    for i in range(row-1,0,-1):\n",
        "                        tiles[i][col]=tiles[i-1][col]\n",
        "                    tiles[0][col]=0\n",
        "    elif action==3:\n",
        "        for row in range(4):\n",
        "            for col in range(1,4):\n",
        "                if tiles[row][col]!=0:\n",
        "                    f=0\n",
        "                    i=col-1\n",
        "                    while(i>=0 and tiles[row][i]==0):\n",
        "                        i-=1\n",
        "                        f=1\n",
        "                    if f==1:\n",
        "                        tiles[row][i+1]=tiles[row][col]\n",
        "                        tiles[row][col]=0\n",
        "            for col in range(3):\n",
        "                if tiles[row][col]==tiles[row][col+1]:\n",
        "                    tiles[row][col]+=tiles[row][col]\n",
        "                    update+=tiles[row][col]\n",
        "                    for i in range(col+1,3):\n",
        "                        tiles[row][i]=tiles[row][i+1]\n",
        "                    tiles[row][3]=0\n",
        "    elif action==4:\n",
        "        for row in range(4):\n",
        "            for col in range(2,-1,-1):\n",
        "                if tiles[row][col]!=0:\n",
        "                    f=0\n",
        "                    i=col+1\n",
        "                    while(i<4 and tiles[row][i]==0):\n",
        "                        f=1\n",
        "                        i+=1\n",
        "                    if f==1:\n",
        "                        tiles[row][i-1]=tiles[row][col]\n",
        "                        tiles[row][col]=0\n",
        "            for col in range(3,0,-1):\n",
        "                if tiles[row][col]==tiles[row][col-1]:\n",
        "                    tiles[row][col]+=tiles[row][col]\n",
        "                    update+=tiles[row][col]\n",
        "                    for i in range(col-1,0,-1):\n",
        "                        tiles[row][i]=tiles[row][i-1]\n",
        "                    tiles[row][0]=0\n",
        "    game_over=check_game_over(tiles)\n",
        "    if game_over:\n",
        "        return tiles,update,game_over\n",
        "    not_changed=check_same(tiles,temp)\n",
        "    while not_changed:\n",
        "        print(\"this action caused no change!\")\n",
        "        print(\"Choose Action : 1.Up 2.Down 3.Left 4.Right\")\n",
        "        action=int(input())\n",
        "        tiles,update,game_over=take_action(tiles,action)\n",
        "        not_changed=check_same(tiles,temp)\n",
        "    return tiles,update,game_over\n",
        "\n",
        "def check_same(x,y):\n",
        "    for i in range(4):\n",
        "        for j in range(4):\n",
        "            if x[i][j]!=y[i][j]:\n",
        "                return False\n",
        "    return True\n"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j4s1SFIVBy4M"
      },
      "source": [
        "def custom_log(value):\n",
        "  if value==0:\n",
        "    return str(hex(int(0)))\n",
        "  else:\n",
        "    return str(hex(int(math.log(value,2))))"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CKqfz98DD00J"
      },
      "source": [
        "ind={}\n",
        "count=0\n",
        "for i in range(16):\n",
        "  for j in range(16):\n",
        "    for k in range(16):\n",
        "      for l in range(16):\n",
        "            st=str(hex(i))+str(hex(j))+str(hex(k))+str(hex(l))\n",
        "            ind[st]=count\n",
        "            count+=1"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QIOqXyul5SCA"
      },
      "source": [
        "def line(grid):\n",
        "  ax=[]\n",
        "  grid_rot=grid\n",
        "  for i in range(3):\n",
        "    txt=\"\"\n",
        "    txt+=custom_log(grid_rot[0][i])\n",
        "    txt+=custom_log(grid_rot[1][i])\n",
        "    txt+=custom_log(grid_rot[2][i])\n",
        "    txt+=custom_log(grid_rot[3][i])\n",
        "    ax.append(txt)\n",
        "  for j in range(1,3):\n",
        "    grid_rot=np.rot90(grid,k=j)\n",
        "    for i in range(3):\n",
        "      txt=\"\"\n",
        "      txt+=custom_log(grid_rot[0][i])\n",
        "      txt+=custom_log(grid_rot[1][i])\n",
        "      txt+=custom_log(grid_rot[2][i])\n",
        "      txt+=custom_log(grid_rot[3][i])\n",
        "      ax.append(txt)\n",
        "  pos=np.array([np.array([0]*1) for i in range(len(ind.keys()))])\n",
        "  for i in ax:\n",
        "    pos[ind[i]][0]=1\n",
        "  return pos"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YaJezXkq39-q"
      },
      "source": [
        "def count_pair_of_mergable_tiles(tiles):\n",
        "    x=0\n",
        "    for i in range(4):\n",
        "        for j in range(3):\n",
        "            if tiles[i][j]==tiles[i][j+1]:\n",
        "                x+=1\n",
        "    for j in range(4):\n",
        "        for i in range(3):\n",
        "            if tiles[i][j]==tiles[i+1][j]:\n",
        "                x+=1\n",
        "    return x"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MmArStlG39-r"
      },
      "source": [
        "def count_empty_tiles(tiles):\n",
        "    x=0\n",
        "    for i in range(4):\n",
        "        for j in range(4):\n",
        "            if tiles[i][j]==0:\n",
        "                x+=1\n",
        "    return x"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "88lN9mcD39-s"
      },
      "source": [
        "def count_distinct_tiles(tiles):\n",
        "    tileset={}\n",
        "    for i in range(4):\n",
        "        for j in range(4):\n",
        "            if tiles[i][j] not in tileset:\n",
        "                tileset[tiles[i][j]]=1\n",
        "    return len(tileset.keys())"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0D35UCmx4A4U"
      },
      "source": [
        "def count_layered(grid): #relies on the fact that an empty tile is NOT represented as 0. 1 would be prefered for empty tile. \n",
        "    count = 0\n",
        "    for col in range(4):\n",
        "        if((grid[0][col]==2*grid[1][col]) and grid[0][col]!=0):\n",
        "            count+=1\n",
        "        if((grid[3][col]==2*grid[2][col]) and grid[3][col]!=0):\n",
        "            count+=1\n",
        "        for row in range(1, 3):\n",
        "            if((grid[row][col]==2*grid[row+1][col] or grid[row][col]==2*grid[row-1][col]) and  grid[row][col]!=0):\n",
        "                count+=1\n",
        "    return(count)"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HKKDG9Ef-EDC"
      },
      "source": [
        "def calculate_v(state,weights):\n",
        "  phi = feature_vec(state)\n",
        "  v = phi.dot(weights)\n",
        "  return v"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LTm5XZj7So7g"
      },
      "source": [
        "def count_large_tiles(grid):\n",
        "  count=0\n",
        "  for i in grid:\n",
        "    for j in i:\n",
        "      if j>=1024:\n",
        "        count+=1\n",
        "  return count"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w1jw1vmFOIkN"
      },
      "source": [
        "def feature_vec(state):\n",
        "  feat=[]\n",
        "  feat.append(np.array([count_layered(state)]))\n",
        "  feat.append(np.array([count_distinct_tiles(state)]))\n",
        "  feat.append(np.array([count_empty_tiles(state)]))\n",
        "  feat.append(np.array([count_pair_of_mergable_tiles(state)]))\n",
        "  feat.append(np.array([count_large_tiles(state)]))\n",
        "  feat=np.concatenate((np.array(feat),np.array(line(state))))\n",
        "  return np.array(feat).reshape((1,5+len(ind.keys())))"
      ],
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nmHV2mkyOkyg"
      },
      "source": [
        "def generate_game():\n",
        "  tiles=np.array([np.array([0]*4) for i in range(4)])\n",
        "  pos,val=new_tile(tiles)\n",
        "  tiles[pos[0]][pos[1]]=val\n",
        "  pos,val=new_tile(tiles)\n",
        "  tiles[pos[0]][pos[1]]=val\n",
        "  return tiles"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LPG1yYnghY5y"
      },
      "source": [
        "def count_rect(grid):\n",
        "  count = 0\n",
        "  for row in range(3):\n",
        "      for col in range(1, 3):\n",
        "        if(grid[row][col]!=0 and grid[row][col-1]!=0 and grid[row][col+1]!=0 and grid[row+1][col]!=0 and grid[row+1][col-1]!=0 and grid[row+1][col+1]!=0):\n",
        "          count+=1\n",
        "  for col in range(3):\n",
        "      for row in range(1, 3):\n",
        "        if(grid[row][col]!=0 and grid[row-1][col]!=0 and grid[row+1][col]!=0 and grid[row][col+1]!=0 and grid[row+1][col+1]!=0 and grid[row-1][col+1]!=0):\n",
        "          count+=1\n",
        "  return count"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f9CV1qsOPTGA"
      },
      "source": [
        "def next_move(tiles,action):\n",
        "  temp=copy.deepcopy(tiles)\n",
        "  update=0\n",
        "  if action==1:\n",
        "      for col in range(4):\n",
        "          for row in range(1,4):\n",
        "              if tiles[row][col]!=0:\n",
        "                  i=row-1\n",
        "                  f=0\n",
        "                  while(i>=0 and tiles[i][col]==0):\n",
        "                      f=1\n",
        "                      i-=1\n",
        "                  if f==1:\n",
        "                      tiles[i+1][col]=tiles[row][col]\n",
        "                      tiles[row][col]=0\n",
        "          for row in range(3):\n",
        "              if tiles[row][col]==tiles[row+1][col]:\n",
        "                  tiles[row][col]+=tiles[row][col]\n",
        "                  update+=tiles[row][col]\n",
        "                  for i in range(row+1,3):\n",
        "                      tiles[i][col]=tiles[i+1][col]\n",
        "                  tiles[3][col]=0\n",
        "  elif action==2:\n",
        "      for col in range(4):\n",
        "          for row in range(2,-1,-1):\n",
        "              if tiles[row][col]!=0:\n",
        "                  i=row+1\n",
        "                  f=0\n",
        "                  while(i<4 and tiles[i][col]==0):\n",
        "                      i+=1\n",
        "                      f=1\n",
        "                  if f==1:\n",
        "                      tiles[i-1][col]=tiles[row][col]\n",
        "                      tiles[row][col]=0\n",
        "          for row in range(3,0,-1):\n",
        "              if tiles[row][col]==tiles[row-1][col]:\n",
        "                  tiles[row][col]+=tiles[row][col]\n",
        "                  update+=tiles[row][col]\n",
        "                  for i in range(row-1,0,-1):\n",
        "                      tiles[i][col]=tiles[i-1][col]\n",
        "                  tiles[0][col]=0\n",
        "  elif action==3:\n",
        "      for row in range(4):\n",
        "          for col in range(1,4):\n",
        "              if tiles[row][col]!=0:\n",
        "                  f=0\n",
        "                  i=col-1\n",
        "                  while(i>=0 and tiles[row][i]==0):\n",
        "                      i-=1\n",
        "                      f=1\n",
        "                  if f==1:\n",
        "                      tiles[row][i+1]=tiles[row][col]\n",
        "                      tiles[row][col]=0\n",
        "          for col in range(3):\n",
        "              if tiles[row][col]==tiles[row][col+1]:\n",
        "                  tiles[row][col]+=tiles[row][col]\n",
        "                  update+=tiles[row][col]\n",
        "                  for i in range(col+1,3):\n",
        "                      tiles[row][i]=tiles[row][i+1]\n",
        "                  tiles[row][3]=0\n",
        "  elif action==4:\n",
        "      for row in range(4):\n",
        "          for col in range(2,-1,-1):\n",
        "              if tiles[row][col]!=0:\n",
        "                  f=0\n",
        "                  i=col+1\n",
        "                  while(i<4 and tiles[row][i]==0):\n",
        "                      f=1\n",
        "                      i+=1\n",
        "                  if f==1:\n",
        "                      tiles[row][i-1]=tiles[row][col]\n",
        "                      tiles[row][col]=0\n",
        "          for col in range(3,0,-1):\n",
        "              if tiles[row][col]==tiles[row][col-1]:\n",
        "                  tiles[row][col]+=tiles[row][col]\n",
        "                  update+=tiles[row][col]\n",
        "                  for i in range(col-1,0,-1):\n",
        "                      tiles[row][i]=tiles[row][i-1]\n",
        "                  tiles[row][0]=0\n",
        "  game_over=check_game_over(tiles)\n",
        "  not_changed=check_same(tiles,temp)\n",
        "  if game_over or not_changed:\n",
        "      return tiles,0,True\n",
        "  pos,val=new_tile(tiles)\n",
        "  tiles[pos[0]][pos[1]]=val\n",
        "  return tiles, update,False"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wmrs-RrA7Ko-"
      },
      "source": [
        "def single_stage_td():\n",
        "  weights1 = np.zeros((5+len(ind.keys()),1))\n",
        "  weights2 = np.zeros((5+len(ind.keys()),1))\n",
        "  weights3 = np.zeros((5+len(ind.keys()),1))\n",
        "  actions = np.array([1,2,3,4])\n",
        "  weights = copy.deepcopy(weights1) \n",
        "  dic={1:\"u\",2:\"d\",3:\"l\",4:\"r\"}\n",
        "  alpha = 0.00001\n",
        "  epsilon=1\n",
        "  cumm_reward=[]\n",
        "  for i in range(100):\n",
        "    state = generate_game() \n",
        "    timesteps = 1\n",
        "    weights = copy.deepcopy(weights1)\n",
        "    max_value=0\n",
        "    tot_reward=0\n",
        "    while True:\n",
        "      if max_value==math.pow(2,10):\n",
        "        weights1 = copy.deepcopy(weights)\n",
        "        weights = copy.deepcopy(weights2)\n",
        "      if max_value==math.pow(2,13):\n",
        "        weights2 = copy.deepcopy(weights)\n",
        "        weights = copy.deepcopy(weights3)\n",
        "      epsilon = 1 / timesteps\n",
        "      timesteps += 1\n",
        "      state_values = {}\n",
        "      action_selection = []\n",
        "      for a in actions:\n",
        "        temp_state = copy.deepcopy(state)\n",
        "        next_state,r,checker = next_move(temp_state,a)\n",
        "        if not checker:\n",
        "          action_selection.append(calculate_v(next_state,weights)[0][0])\n",
        "        else:\n",
        "          action_selection.append(float('-inf'))\n",
        "\n",
        "      if np.max(action_selection) == float('-inf'):\n",
        "        print(i,state) \n",
        "        t = np.amax(state)\n",
        "        if max_value < t:\n",
        "          max_value = t\n",
        "        print(\"\\n\")     \n",
        "        break\n",
        "      p=random.random()\n",
        "      if p<(1-epsilon):\n",
        "        selected_action = np.argmax(action_selection) + 1  \n",
        "      else:\n",
        "        selected_action = random.randint(1,4)\n",
        "      next_state, reward, checker = next_move(state,selected_action)\n",
        "      cumm_reward.append(reward)\n",
        "      phi = feature_vec(state)\n",
        "      if str(state) not in state_values:\n",
        "        state_values[str(state)] = 0\n",
        "      state_values[str(state)] = phi.dot(weights)\n",
        "\n",
        "      weights = weights + alpha * (reward + np.max(action_selection) - state_values[str(state)]) * np.transpose(phi) \n",
        "      state = next_state\n",
        "\n",
        "  return weights1, weights2, weights3, cumm_reward\n"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fEFgCD2JUxoW",
        "scrolled": true,
        "outputId": "55b0ab8f-e25e-4d21-9fc5-495baada5d7b"
      },
      "source": [
        "a,b,c,wt = single_stage_td()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 [[  2   8 128   2]\n",
            " [  4  64  32  16]\n",
            " [ 32  16 256   4]\n",
            " [  4   8  64  32]]\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BroZ64Qn9DTP"
      },
      "source": [
        "np.save(\"w_ntup_1.sav\",a)\n",
        "np.save(\"w_ntup_2.sav\",b)\n",
        "np.save(\"w_ntup_3.sav\",c)\n",
        "np.save(\"rewards_ntup.sav\",wt)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f5BIKHHiWK7n"
      },
      "source": [
        "import matplotlib.pyplot as plt\r\n",
        "plt.figure(num=None, figsize=(15,7.5), dpi=80, facecolor='w', edgecolor='k')\r\n",
        "plt.plot(wt)\r\n",
        "plt.ylabel('Cummulative Rewards')\r\n",
        "plt.xlabel('Runs')\r\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}