intro_to_game_ai_and_reinforcement_learning/02-one-step-lookahead.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c38a0d41",
   "metadata": {
    "papermill": {
     "duration": 0.013176,
     "end_time": "2021-08-26T17:58:10.518767",
     "exception": false,
     "start_time": "2021-08-26T17:58:10.505591",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**This notebook is an exercise in the [Intro to Game AI and Reinforcement Learning](https://www.kaggle.com/learn/intro-to-game-ai-and-reinforcement-learning) course.  You can reference the tutorial at [this link](https://www.kaggle.com/alexisbcook/one-step-lookahead).**\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d42b0c7e",
   "metadata": {
    "papermill": {
     "duration": 0.011424,
     "end_time": "2021-08-26T17:58:10.542211",
     "exception": false,
     "start_time": "2021-08-26T17:58:10.530787",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Introduction\n",
    "\n",
    "In the tutorial, you learned how to define a simple heuristic that the agent used to select moves.  In this exercise, you'll check your understanding and make the heuristic more complex.\n",
    "\n",
    "To get started, run the code cell below to set up our feedback system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8312c874",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-26T17:58:10.580164Z",
     "iopub.status.busy": "2021-08-26T17:58:10.579495Z",
     "iopub.status.idle": "2021-08-26T17:58:10.792411Z",
     "shell.execute_reply": "2021-08-26T17:58:10.791303Z",
     "shell.execute_reply.started": "2021-08-26T17:34:59.484012Z"
    },
    "papermill": {
     "duration": 0.238903,
     "end_time": "2021-08-26T17:58:10.792677",
     "exception": false,
     "start_time": "2021-08-26T17:58:10.553774",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading environment football failed: No module named 'gfootball'\n"
     ]
    }
   ],
   "source": [
    "from learntools.core import binder\n",
    "binder.bind(globals())\n",
    "from learntools.game_ai.ex2 import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34d7f309",
   "metadata": {
    "papermill": {
     "duration": 0.011706,
     "end_time": "2021-08-26T17:58:10.817780",
     "exception": false,
     "start_time": "2021-08-26T17:58:10.806074",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 1) A more complex heuristic\n",
    "\n",
    "The heuristic from the tutorial looks at all groups of four adjacent grid locations on the same row, column, or diagonal and assigns points for each occurrence of the following patterns:\n",
    "\n",
    "<center>\n",
    "<img src=\"https://i.imgur.com/vzQa4ML.png\" width=60%><br/>\n",
    "</center>\n",
    "\n",
    "In the image above, we assume that the agent is the red player, and the opponent plays yellow discs.\n",
    "\n",
    "For reference, here is the `get_heuristic()` function from the tutorial:\n",
    "```python\n",
    "def get_heuristic(grid, mark, config):\n",
    "    num_threes = count_windows(grid, 3, mark, config)\n",
    "    num_fours = count_windows(grid, 4, mark, config)\n",
    "    num_threes_opp = count_windows(grid, 3, mark%2+1, config)\n",
    "    score = num_threes - 1e2*num_threes_opp + 1e6*num_fours\n",
    "    return score\n",
    "```\n",
    "\n",
    "In the `get_heuristic()` function, `num_fours`, `num_threes`, and `num_threes_opp` are the number of windows in the game grid that are assigned 1000000, 1, and -100 point(s), respectively. \n",
    "    \n",
    "In this tutorial, you'll change the heuristic to the following (where you decide the number of points to apply in each of `A`, `B`, `C`, `D`, and `E`).  You will define these values in the code cell below.\n",
    "\n",
    "<center>\n",
    "<img src=\"https://i.imgur.com/FBoWr2f.png\" width=80%><br/>\n",
    "</center>\n",
    "    \n",
    "\n",
    "To check your answer, we use your values to create a heuristic function as follows:\n",
    "\n",
    "```python\n",
    "def get_heuristic_q1(grid, col, mark, config):\n",
    "    num_twos = count_windows(grid, 2, mark, config)\n",
    "    num_threes = count_windows(grid, 3, mark, config)\n",
    "    num_fours = count_windows(grid, 4, mark, config)\n",
    "    num_twos_opp = count_windows(grid, 2, mark%2+1, config)\n",
    "    num_threes_opp = count_windows(grid, 3, mark%2+1, config)\n",
    "    score = A*num_fours + B*num_threes + C*num_twos + D*num_twos_opp + E*num_threes_opp\n",
    "    return score\n",
    "```\n",
    "\n",
    "This heuristic is then used to create an agent, that competes against the agent from the tutorial in 50 different game rounds.  In order to be marked correct, \n",
    "- your agent must win at least half of the games, and\n",
    "- `C` and `D` must both be nonzero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4e92ed51",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-26T17:58:10.847652Z",
     "iopub.status.busy": "2021-08-26T17:58:10.846696Z",
     "iopub.status.idle": "2021-08-26T17:58:40.445014Z",
     "shell.execute_reply": "2021-08-26T17:58:40.444273Z",
     "shell.execute_reply.started": "2021-08-26T17:40:03.930199Z"
    },
    "papermill": {
     "duration": 29.615303,
     "end_time": "2021-08-26T17:58:40.445180",
     "exception": false,
     "start_time": "2021-08-26T17:58:10.829877",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your Agent's Win Percentage (in 50 game rounds): 0.74\n",
      "Tutorial Agent's Win Percentage (in 50 game rounds): 0.26\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"outcomeType\": 1, \"valueTowardsCompletion\": 0.3333333333333333, \"interactionType\": 1, \"questionType\": 2, \"questionId\": \"1_BetterHeuristic\", \"learnToolsVersion\": \"0.3.4\", \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\"}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc33\">Correct</span>"
      ],
      "text/plain": [
       "Correct"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Assign your values here\n",
    "A = 1e6\n",
    "B = 1e1\n",
    "C = 1e0\n",
    "D = -1e1\n",
    "E = -1e2\n",
    "\n",
    "# Check your answer (this will take a few seconds to run!)\n",
    "q_1.check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a23aba33",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-26T17:58:40.477946Z",
     "iopub.status.busy": "2021-08-26T17:58:40.477025Z",
     "iopub.status.idle": "2021-08-26T17:58:40.480416Z",
     "shell.execute_reply": "2021-08-26T17:58:40.479877Z",
     "shell.execute_reply.started": "2021-08-26T17:40:22.479116Z"
    },
    "papermill": {
     "duration": 0.021133,
     "end_time": "2021-08-26T17:58:40.480560",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.459427",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Lines below will give you a hint or solution code\n",
    "#q_1.hint()\n",
    "#q_1.solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7422600f",
   "metadata": {
    "papermill": {
     "duration": 0.015022,
     "end_time": "2021-08-26T17:58:40.510349",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.495327",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 2) Does the agent win?\n",
    "\n",
    "Consider the game board below.  \n",
    "\n",
    "<center>\n",
    "<img src=\"https://i.imgur.com/AlnaQ3J.png\" width=30%><br/>\n",
    "</center>\n",
    "\n",
    "Say the agent uses red discs, and it's the agent's turn.  \n",
    "- If the agent uses the heuristic **_from the tutorial_**, does it win or lose the game?\n",
    "- If the agent uses the heuristic **_that you just implemented_**, does it win or lose the game?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3ee5e53c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-26T17:58:40.543762Z",
     "iopub.status.busy": "2021-08-26T17:58:40.543074Z",
     "iopub.status.idle": "2021-08-26T17:58:40.545938Z",
     "shell.execute_reply": "2021-08-26T17:58:40.545324Z",
     "shell.execute_reply.started": "2021-08-26T17:43:42.849695Z"
    },
    "papermill": {
     "duration": 0.020751,
     "end_time": "2021-08-26T17:58:40.546074",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.525323",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "#q_2.hint()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7ef472d9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-26T17:58:40.579675Z",
     "iopub.status.busy": "2021-08-26T17:58:40.579005Z",
     "iopub.status.idle": "2021-08-26T17:58:40.583575Z",
     "shell.execute_reply": "2021-08-26T17:58:40.584124Z",
     "shell.execute_reply.started": "2021-08-26T17:45:54.416708Z"
    },
    "papermill": {
     "duration": 0.023823,
     "end_time": "2021-08-26T17:58:40.584329",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.560506",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"outcomeType\": 1, \"valueTowardsCompletion\": 0.3333333333333333, \"interactionType\": 1, \"questionType\": 4, \"questionId\": \"2_BothLose\", \"learnToolsVersion\": \"0.3.4\", \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\"}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc33\">Correct:</span> \n",
       "\n",
       "The agent has two choices: it can play in either column 0 (the leftmost column), or column 6 (the rightmost column). If the agent plays in column 0, it definitely wins the game in its next move.  And, if it plays in column 6, it likely loses the game (since, if the opponent responds by playing in the same column, then the opponent wins the game). \n",
       "\n",
       "If the agent uses the heuristic **from the tutorial**, both columns are scored equally, and so the agent will select from them (uniformly) at random.  In this case, the agent has about a 50/50 chance of winning the game. \n",
       "\n",
       "As for the heuristic **that** **you just implemented**, this will depend on your implementation, so we'll provide an answer for the solution heuristic that we provided -- in this case, the agent most likely loses the game, since it will definitely select the final column. \n",
       "\n",
       "This is an interesting situation, because on average, we see that the agent with the new heuristic performs better than the agent from the tutorial (and yet, for this board, it's guaranteed to make the wrong decision)."
      ],
      "text/plain": [
       "Correct: \n",
       "\n",
       "The agent has two choices: it can play in either column 0 (the leftmost column), or column 6 (the rightmost column). If the agent plays in column 0, it definitely wins the game in its next move.  And, if it plays in column 6, it likely loses the game (since, if the opponent responds by playing in the same column, then the opponent wins the game). \n",
       "\n",
       "If the agent uses the heuristic **from the tutorial**, both columns are scored equally, and so the agent will select from them (uniformly) at random.  In this case, the agent has about a 50/50 chance of winning the game. \n",
       "\n",
       "As for the heuristic **that** **you just implemented**, this will depend on your implementation, so we'll provide an answer for the solution heuristic that we provided -- in this case, the agent most likely loses the game, since it will definitely select the final column. \n",
       "\n",
       "This is an interesting situation, because on average, we see that the agent with the new heuristic performs better than the agent from the tutorial (and yet, for this board, it's guaranteed to make the wrong decision)."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Check your answer (Run this code cell to receive credit!)\n",
    "#q_2.solution()\n",
    "q_2.check()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1c21f09",
   "metadata": {
    "papermill": {
     "duration": 0.016673,
     "end_time": "2021-08-26T17:58:40.618822",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.602149",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "### 3) Submit to the competition\n",
    "\n",
    "Now, it's time to submit an agent to the competition!  Use the next code cell to define an agent.  (You can see an example of how to write a valid agent in **[this notebook](https://www.kaggle.com/alexisbcook/create-a-connectx-agent)**.)\n",
    "\n",
    "You're encouraged to use what you learned in the first question of this exercise to write an agent.  Use the code from the tutorial as a starting point. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ee906bfe",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-26T17:58:40.652114Z",
     "iopub.status.busy": "2021-08-26T17:58:40.651447Z",
     "iopub.status.idle": "2021-08-26T17:58:40.673701Z",
     "shell.execute_reply": "2021-08-26T17:58:40.674350Z",
     "shell.execute_reply.started": "2021-08-26T17:54:07.129251Z"
    },
    "papermill": {
     "duration": 0.040342,
     "end_time": "2021-08-26T17:58:40.674529",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.634187",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def my_agent(obs, config):\n",
    "    # Your code here: Amend the agent!\n",
    "    import random\n",
    "    import numpy as np\n",
    "        \n",
    "    A = 1e6\n",
    "    B = 1e1\n",
    "    C = 1e0\n",
    "    D = -1e1\n",
    "    E = -1e2\n",
    "    \n",
    "    # Calculates score if agent drops piece in selected column\n",
    "    def score_move(grid, col, mark, config):\n",
    "        next_grid = drop_piece(grid, col, mark, config)\n",
    "        score = get_heuristic(next_grid, mark, config)\n",
    "        return score\n",
    "\n",
    "    # Helper function for score_move: gets board at next step if agent drops piece in selected column\n",
    "    def drop_piece(grid, col, mark, config):\n",
    "        next_grid = grid.copy()\n",
    "        for row in range(config.rows-1, -1, -1):\n",
    "            if next_grid[row][col] == 0:\n",
    "                break\n",
    "        next_grid[row][col] = mark\n",
    "        return next_grid\n",
    "\n",
    "    # Helper function for score_move: calculates value of heuristic for grid\n",
    "    def get_heuristic(grid, mark, config):\n",
    "        num_twos = count_windows(grid, 2, mark, config)\n",
    "        num_threes = count_windows(grid, 3, mark, config)\n",
    "        num_fours = count_windows(grid, 4, mark, config)\n",
    "        num_twos_opp = count_windows(grid, 2, mark%2+1, config)\n",
    "        num_threes_opp = count_windows(grid, 3, mark%2+1, config)\n",
    "        score = A*num_fours + B*num_threes + C*num_twos + D*num_twos_opp + E*num_threes_opp\n",
    "        return score\n",
    "\n",
    "    # Helper function for get_heuristic: checks if window satisfies heuristic conditions\n",
    "    def check_window(window, num_discs, piece, config):\n",
    "        return (window.count(piece) == num_discs and window.count(0) == config.inarow-num_discs)\n",
    "\n",
    "    # Helper function for get_heuristic: counts number of windows satisfying specified heuristic conditions\n",
    "    def count_windows(grid, num_discs, piece, config):\n",
    "        num_windows = 0\n",
    "        # horizontal\n",
    "        for row in range(config.rows):\n",
    "            for col in range(config.columns-(config.inarow-1)):\n",
    "                window = list(grid[row, col:col+config.inarow])\n",
    "                if check_window(window, num_discs, piece, config):\n",
    "                    num_windows += 1\n",
    "        # vertical\n",
    "        for row in range(config.rows-(config.inarow-1)):\n",
    "            for col in range(config.columns):\n",
    "                window = list(grid[row:row+config.inarow, col])\n",
    "                if check_window(window, num_discs, piece, config):\n",
    "                    num_windows += 1\n",
    "        # positive diagonal\n",
    "        for row in range(config.rows-(config.inarow-1)):\n",
    "            for col in range(config.columns-(config.inarow-1)):\n",
    "                window = list(grid[range(row, row+config.inarow), range(col, col+config.inarow)])\n",
    "                if check_window(window, num_discs, piece, config):\n",
    "                    num_windows += 1\n",
    "        # negative diagonal\n",
    "        for row in range(config.inarow-1, config.rows):\n",
    "            for col in range(config.columns-(config.inarow-1)):\n",
    "                window = list(grid[range(row, row-config.inarow, -1), range(col, col+config.inarow)])\n",
    "                if check_window(window, num_discs, piece, config):\n",
    "                    num_windows += 1\n",
    "        return num_windows\n",
    "    \n",
    "    # Get list of valid moves\n",
    "    valid_moves = [col for col in range(config.columns) if obs.board[col] == 0]\n",
    "    # Convert the board to a 2D grid\n",
    "    grid = np.asarray(obs.board).reshape(config.rows, config.columns)\n",
    "    # Use the heuristic to assign a score to each possible board in the next turn\n",
    "    scores = dict(zip(valid_moves, [score_move(grid, col, obs.mark, config) for col in valid_moves]))\n",
    "    # Get a list of columns (moves) that maximize the heuristic\n",
    "    max_cols = [key for key in scores.keys() if scores[key] == max(scores.values())]\n",
    "    # Select at random from the maximizing columns\n",
    "    return random.choice(max_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dac37bbb",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-26T17:58:40.708917Z",
     "iopub.status.busy": "2021-08-26T17:58:40.707911Z",
     "iopub.status.idle": "2021-08-26T17:58:40.713632Z",
     "shell.execute_reply": "2021-08-26T17:58:40.714281Z",
     "shell.execute_reply.started": "2021-08-26T17:54:08.715500Z"
    },
    "papermill": {
     "duration": 0.024306,
     "end_time": "2021-08-26T17:58:40.714462",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.690156",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"outcomeType\": 1, \"valueTowardsCompletion\": 0.3333333333333333, \"interactionType\": 1, \"questionType\": 2, \"questionId\": \"3_CreateAgentEx2\", \"learnToolsVersion\": \"0.3.4\", \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\"}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc33\">Thank you for creating an agent!</span>"
      ],
      "text/plain": [
       "Thank you for creating an agent!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this code cell to get credit for creating an agent\n",
    "q_3.check()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b43b544",
   "metadata": {
    "papermill": {
     "duration": 0.015558,
     "end_time": "2021-08-26T17:58:40.745371",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.729813",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Run the next code cell to convert your agent to a submission file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "80ada0b0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-26T17:58:40.783091Z",
     "iopub.status.busy": "2021-08-26T17:58:40.782420Z",
     "iopub.status.idle": "2021-08-26T17:58:40.796185Z",
     "shell.execute_reply": "2021-08-26T17:58:40.796681Z",
     "shell.execute_reply.started": "2021-08-26T17:54:15.090464Z"
    },
    "papermill": {
     "duration": 0.034806,
     "end_time": "2021-08-26T17:58:40.796883",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.762077",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function my_agent at 0x7ff5fe8a0cb0> written to submission.py\n"
     ]
    }
   ],
   "source": [
    "import inspect\n",
    "import os\n",
    "\n",
    "def write_agent_to_file(function, file):\n",
    "    with open(file, \"a\" if os.path.exists(file) else \"w\") as f:\n",
    "        f.write(inspect.getsource(function))\n",
    "        print(function, \"written to\", file)\n",
    "\n",
    "write_agent_to_file(my_agent, \"submission.py\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c978a7eb",
   "metadata": {
    "papermill": {
     "duration": 0.01533,
     "end_time": "2021-08-26T17:58:40.829379",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.814049",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "Then, follow these steps to submit your agent to the competition:\n",
    "1. Begin by clicking on the blue **Save Version** button in the top right corner of the window.  This will generate a pop-up window.  \n",
    "2. Ensure that the **Save and Run All** option is selected, and then click on the blue **Save** button.\n",
    "3. This generates a window in the bottom left corner of the notebook.  After it has finished running, click on the number to the right of the **Save Version** button.  This pulls up a list of versions on the right of the screen.  Click on the ellipsis **(...)** to the right of the most recent version, and select **Open in Viewer**.  This brings you into view mode of the same page. You will need to scroll down to get back to these instructions.\n",
    "4. Click on the **Output** tab on the right of the screen.  Then, click on the file you would like to submit, and click on the blue **Submit** button to submit your results to the leaderboard.\n",
    "\n",
    "You have now successfully submitted to the competition!\n",
    "\n",
    "If you want to keep working to improve your performance, select the blue **Edit** button in the top right of the screen. Then you can change your code and repeat the process. There's a lot of room to improve, and you will climb up the leaderboard as you work.\n",
    "\n",
    "\n",
    "Go to **\"My Submissions\"** to view your score and episodes being played.\n",
    "\n",
    "# Keep going\n",
    "\n",
    "Move on to **[develop a longer-term strategy](https://www.kaggle.com/alexisbcook/n-step-lookahead)** with the minimax algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "941381aa",
   "metadata": {
    "papermill": {
     "duration": 0.015668,
     "end_time": "2021-08-26T17:58:40.860687",
     "exception": false,
     "start_time": "2021-08-26T17:58:40.845019",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "*Have questions or comments? Visit the [Learn Discussion forum](https://www.kaggle.com/learn-forum/161477) to chat with other Learners.*"
   ]
  }
 ],
 "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.10"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 39.724105,
   "end_time": "2021-08-26T17:58:42.247636",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2021-08-26T17:58:02.523531",
   "version": "2.3.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}