LearnModel.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a reinforcement model that follows the line\n",
    "\n",
    "First we import the necessary simulator libraries\n",
    "- CarModel: a simulated car\n",
    "- CanvasModel: a simulated training ground where the car can follow a line\n",
    "- SimulatorControl: an environment where we can simulate actions like driving forward or turning left and right and read out new sensor values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "outputs": [],
   "source": [
    "import logging\n",
    "import Car\n",
    "import Canvas\n",
    "import RobotCarSimulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "GAMMA = 0.995             # discount factor\n",
    "ALPHA = 1e-2              # learning rate  \n",
    "TAU = 1e-2                # soft update\n",
    "NUM_STEPS_FOR_UPDATE = 4  # perform a learning update every C time steps\n",
    "STEPS_SENSOR_HISTORY = 2\n",
    "MEMORY_SIZE = 10_000     # size of memory buffer\n",
    "MINIBATCH_SIZE = 64   # mini-batch size\n",
    "E_DECAY = 0.995       # ε decay rate for ε-greedy policy\n",
    "E_MIN = 0.01          # minimum ε value for ε-greedy policy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "vscode": {
     "languageId": "plaintext"
    }
   },
   "outputs": [],
   "source": [
    "car = Car.CarModel()\n",
    "# the seed controls the curve/line that we are following\n",
    "canvas = Canvas.CanvasModel(seed=11)\n",
    "# we set createGif to False to save space and runtime - we will generate the video once we apply the trained model\n",
    "sim = RobotCarSimulator.SimulatorControl(canvas, car, createGif=False, stephistory=STEPS_SENSOR_HISTORY)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Action space\n",
    "\n",
    "- 0 - driveForward(100,150)\n",
    "- 1 - turnLeft(100,50)\n",
    "- 2 - turnRight(100,50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def driveForward():\n",
    "    global sim\n",
    "    sim.driveForward(100,150)\n",
    "\n",
    "def turnLeft():\n",
    "    global sim\n",
    "    sim.turnLeft(100,50)\n",
    "    \n",
    "def turnRight():\n",
    "    global sim\n",
    "    sim.turnRight(100,50)\n",
    "    \n",
    "actions = (driveForward, turnLeft, turnRight)\n",
    "\n",
    "num_actions = len(actions)\n",
    "\n",
    "#to invoke action 0:\n",
    "#actions[0]()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Observation space\n",
    "\n",
    "the observation space is only the sensor values of the 3 infrared sensors (two time steps ) ==>\n",
    "- current sensor values\n",
    "- previous sensor values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 30.         557.35703254 814.33883274  30.         557.35703254\n",
      " 814.33883274  30.         146.91333487 900.        ] False 20.0 0.25\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def getReward():\n",
    "    global sim\n",
    "    return sim.getReward()\n",
    "\n",
    "def getSensors():\n",
    "    global sim\n",
    "    return list(sim.getPreviousLineTrackingSensorValues()) + sim.getLineTrackingSensorValues()\n",
    "\n",
    "def getDuration():\n",
    "    global sim\n",
    "    return sim.getDuration()\n",
    "\n",
    "def isDone():\n",
    "    global sim\n",
    "    return sim.isTerminated()\n",
    "\n",
    "\n",
    "# run one step and return next state (sensors), reward, done and time exceeded\n",
    "def step(action):\n",
    "    action()\n",
    "    return (np.array(getSensors()), isDone(), getReward(), getDuration())\n",
    "    \n",
    "next_state, done, reward, duration = step(actions[0])     \n",
    "    \n",
    "state_size = 3 * (STEPS_SENSOR_HISTORY+1) # we have three sensors and n+1 time steps (n+1 * 3)\n",
    "\n",
    "print(next_state, done, reward, duration) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep Q-learning (reinforcement learning)\n",
    "\n",
    "as learned in the coursera course we will use two models, the Q and target Q' networks (Deep Q Network) DQN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras import Sequential\n",
    "from tensorflow.keras.layers import Dense, Input\n",
    "from tensorflow.keras.losses import MSE\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from collections import deque, namedtuple # for experience replay\n",
    "import numpy as np\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-08-23 20:12:08.868467: I tensorflow/core/platform/cpu_feature_guard.cc:145] This TensorFlow binary is optimized with Intel(R) MKL-DNN to use the following CPU instructions in performance critical operations:  SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "To enable them in non-MKL-DNN operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-08-23 20:12:08.868745: I tensorflow/core/common_runtime/process_util.cc:115] Creating new thread pool with default inter op setting: 8. Tune using inter_op_parallelism_threads for best performance.\n"
     ]
    }
   ],
   "source": [
    "# Create the Q-Network\n",
    "q_network = Sequential([\n",
    "    ### START CODE HERE ### \n",
    "    Input(shape=state_size),                      \n",
    "    Dense(units=64, activation='relu'),            \n",
    "    Dense(units=64, activation='relu'),            \n",
    "    Dense(units=num_actions, activation='linear'),\n",
    "    ### END CODE HERE ### \n",
    "    ])\n",
    "\n",
    "# Create the target Q^-Network\n",
    "target_q_network = Sequential([\n",
    "    ### START CODE HERE ### \n",
    "    Input(shape=state_size),                      \n",
    "    Dense(units=64, activation='relu'),            \n",
    "    Dense(units=64, activation='relu'),            \n",
    "    Dense(units=num_actions, activation='linear'),\n",
    "    ### END CODE HERE ###\n",
    "    ])\n",
    "\n",
    "\n",
    "optimizer = Adam(learning_rate=ALPHA)           \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experience replay \n",
    "\n",
    "The coursera course recommends to use experience replay to avoid problematic correlations, oscillations and instabilities. In addition, experience replay also allows the agent to potentially use the same experience in multiple weight updates, which increases data efficiency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store experiences as named tuples\n",
    "experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# calculate_loss\n",
    "\n",
    "def compute_loss(experiences, gamma, q_network, target_q_network):\n",
    "    \"\"\" \n",
    "    Calculates the loss.\n",
    "    \n",
    "    Args:\n",
    "      experiences: (tuple) tuple of [\"state\", \"action\", \"reward\", \"next_state\", \"done\"] namedtuples\n",
    "      gamma: (float) The discount factor.\n",
    "      q_network: (tf.keras.Sequential) Keras model for predicting the q_values\n",
    "      target_q_network: (tf.keras.Sequential) Karas model for predicting the targets\n",
    "          \n",
    "    Returns:\n",
    "      loss: (TensorFlow Tensor(shape=(0,), dtype=int32)) the Mean-Squared Error between\n",
    "            the y targets and the Q(s,a) values.\n",
    "    \"\"\"\n",
    "    \n",
    "    # Unpack the mini-batch of experience tuples\n",
    "    states, actions, rewards, next_states, done_vals = experiences\n",
    "    \n",
    "    # Compute max Q^(s,a)\n",
    "    max_qsa = tf.reduce_max(target_q_network(next_states), axis=-1)\n",
    "    \n",
    "    # Set y = R if episode terminates, otherwise set y = R + γ max Q^(s,a).\n",
    "    ### START CODE HERE ### \n",
    "    y_targets = rewards + (gamma * max_qsa * (1 - done_vals))\n",
    "    ### END CODE HERE ###\n",
    "    \n",
    "    # Get the q_values\n",
    "    q_values = q_network(states)\n",
    "    q_values = tf.gather_nd(q_values, tf.stack([tf.range(q_values.shape[0]),\n",
    "                                                tf.cast(actions, tf.int32)], axis=1))\n",
    "        \n",
    "    # Compute the loss\n",
    "    ### START CODE HERE ### \n",
    "    loss = MSE(y_targets, q_values)\n",
    "    ### END CODE HERE ### \n",
    "    \n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_target_network(q_network, target_q_network):\n",
    "    for target_weights, q_net_weights in zip(target_q_network.weights, q_network.weights):\n",
    "        target_weights.assign(TAU * q_net_weights + (1.0 - TAU) * target_weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def agent_learn(experiences, gamma):\n",
    "    \"\"\"\n",
    "    Updates the weights of the Q networks.\n",
    "    \n",
    "    Args:\n",
    "      experiences: (tuple) tuple of [\"state\", \"action\", \"reward\", \"next_state\", \"done\"] namedtuples\n",
    "      gamma: (float) The discount factor.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    # Calculate the loss\n",
    "    with tf.GradientTape() as tape:\n",
    "        loss = compute_loss(experiences, gamma, q_network, target_q_network)\n",
    "\n",
    "    # Get the gradients of the loss with respect to the weights.\n",
    "    gradients = tape.gradient(loss, q_network.trainable_variables)\n",
    "    \n",
    "    # Update the weights of the q_network.\n",
    "    optimizer.apply_gradients(zip(gradients, q_network.trainable_variables))\n",
    "\n",
    "    # update the weights of target q_network\n",
    "    update_target_network(q_network, target_q_network)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_action(q_values, epsilon=0):\n",
    "    if random.random() > epsilon:\n",
    "        return np.argmax(q_values.numpy()[0])\n",
    "    else:\n",
    "        return random.choice(np.arange(num_actions))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_update_conditions(t, num_steps_upd, memory_buffer):\n",
    "    if (t + 1) % num_steps_upd == 0 and len(memory_buffer) > MINIBATCH_SIZE:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_experiences(memory_buffer):\n",
    "    experiences = random.sample(memory_buffer, k=MINIBATCH_SIZE)\n",
    "    states = tf.convert_to_tensor(np.array([e.state for e in experiences if e is not None]),dtype=tf.float32)\n",
    "    actions = tf.convert_to_tensor(np.array([e.action for e in experiences if e is not None]), dtype=tf.float32)\n",
    "    rewards = tf.convert_to_tensor(np.array([e.reward for e in experiences if e is not None]), dtype=tf.float32)\n",
    "    next_states = tf.convert_to_tensor(np.array([e.next_state for e in experiences if e is not None]),dtype=tf.float32)\n",
    "    done_vals = tf.convert_to_tensor(np.array([e.done for e in experiences if e is not None]).astype(np.uint8),\n",
    "                                     dtype=tf.float32)\n",
    "    return (states, actions, rewards, next_states, done_vals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_new_eps(epsilon):\n",
    "    return max(E_MIN, E_DECAY*epsilon)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import pprint\n",
    "import sys\n",
    "start = time.time()\n",
    "\n",
    "num_episodes = 2000\n",
    "max_num_timesteps = 200\n",
    "\n",
    "total_point_history = []\n",
    "\n",
    "num_p_av = 100    # number of total points to use for averaging\n",
    "epsilon = 1.0     # initial ε value for ε-greedy policy\n",
    "\n",
    "# Create a memory buffer D with capacity N\n",
    "memory_buffer = deque(maxlen=MEMORY_SIZE)\n",
    "\n",
    "# Set the target network weights equal to the Q-Network weights\n",
    "target_q_network.set_weights(q_network.get_weights())\n",
    "# learn with 9 different curves to generalize the model and not optimize for a single curve\n",
    "seeds = (2,5,9,11,13,15,17,19,21)\n",
    "\n",
    "duration = 0.0\n",
    "\n",
    "for i in range(num_episodes):\n",
    "    \n",
    "    # Reset the environment to the initial state and get the initial state\n",
    "    car = Car.CarModel()\n",
    "    # the seed controls the curve/line that we are following\n",
    "    seed = seeds[i%len(seeds)]\n",
    "    canvas = Canvas.CanvasModel(seed=seed)\n",
    "    # we set createGif to False to save space and runtime - we will generate the video once we apply the trained model\n",
    "    sim = RobotCarSimulator.SimulatorControl(canvas, car, createGif=False, stephistory=STEPS_SENSOR_HISTORY)\n",
    "    state = np.array(getSensors())\n",
    "    total_points = 0\n",
    "    \n",
    "    for t in range(max_num_timesteps):\n",
    "        \n",
    "        # From the current state S choose an action A using an ε-greedy policy\n",
    "        state_qn = np.expand_dims(state, axis=0)  # state needs to be the right shape for the q_network\n",
    "        q_values = q_network(state_qn)\n",
    "        action = get_action(q_values, epsilon)\n",
    "        \n",
    "        # Take action A and receive reward R and the next state S'\n",
    "        next_state, done, reward, duration = step(actions[action])   \n",
    "       \n",
    "        # Store experience tuple (S,A,R,S') in the memory buffer.\n",
    "        # We store the done variable as well for convenience.\n",
    "        memory_buffer.append(experience(state, action, reward, next_state, done))\n",
    "        \n",
    "        # Only update the network every NUM_STEPS_FOR_UPDATE time steps.\n",
    "        update = check_update_conditions(t, NUM_STEPS_FOR_UPDATE, memory_buffer)\n",
    "        \n",
    "        if update:\n",
    "            # Sample random mini-batch of experience tuples (S,A,R,S') from D\n",
    "            experiences = get_experiences(memory_buffer)\n",
    "            \n",
    "            # Set the y targets, perform a gradient descent step,\n",
    "            # and update the network weights.\n",
    "            #print(\"\\nUpdating model after \",t,\" steps\")\n",
    "            agent_learn(experiences, GAMMA)\n",
    "        \n",
    "        state = next_state.copy()\n",
    "        total_points += reward\n",
    "        \n",
    "        if done:\n",
    "            print(\"\\nBreaking episode \",i,\" with seed \", seed, \" after \",t,\" steps with reward \",total_points)\n",
    "            break\n",
    "        if (t==(max_num_timesteps-1)):\n",
    "            print(\"\\nAborting episode \",i,\" with seed \", seed, \" after \",t,\" steps with reward \",total_points)\n",
    "            \n",
    "    total_point_history.append(total_points)\n",
    "    av_latest_points = np.mean(total_point_history[-num_p_av:])\n",
    "    \n",
    "    # Update the ε value\n",
    "    epsilon = get_new_eps(epsilon)\n",
    "\n",
    "    print(f\"\\rEpisode {i+1} | Total point average of the last {num_p_av} episodes: {av_latest_points:.2f}\", end=\"\")\n",
    "\n",
    "    if (i+1) % num_p_av == 0:\n",
    "        print(f\"\\rEpisode {i+1} | Total point average of the last {num_p_av} episodes: {av_latest_points:.2f}\")\n",
    "        with open('train_episode_{}_seed_{}.txt'.format(i,seed), 'w') as f:\n",
    "            f.write(\"actions:\\n\")\n",
    "            f.write(pprint.pformat(sim._actionLog))\n",
    "            f.write(\"\\n\\npositions:\\n\")\n",
    "            f.write(pprint.pformat(sim._carPositions))\n",
    "            f.write(\"\\n\\norientations:\\n\")\n",
    "            f.write(pprint.pformat(sim._carOrientations))\n",
    "\n",
    "    # We will consider that the environment is solved if we get an\n",
    "    # average of 200 points in the last 100 episodes.\n",
    "    if av_latest_points >= 14000.0:\n",
    "        print(f\"\\n\\nEnvironment solved in {i+1} episodes!\")\n",
    "        q_network.save('curve_tracking_model.h5')\n",
    "        break\n",
    "        \n",
    "tot_time = time.time() - start\n",
    "\n",
    "print(f\"\\nTotal Runtime: {tot_time:.2f} s ({(tot_time/60):.2f} min)\")\n",
    "q_network.save('curve_tracking_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as mticker\n",
    "\n",
    "def plot_history(reward_history, rolling_window=20, lower_limit=None,\n",
    "                 upper_limit=None, plot_rw=True, plot_rm=True):\n",
    "    \n",
    "    if lower_limit is None or upper_limit is None:\n",
    "        rh = reward_history\n",
    "        xs = [x for x in range(len(reward_history))]\n",
    "    else:\n",
    "        rh = reward_history[lower_limit:upper_limit]\n",
    "        xs = [x for x in range(lower_limit,upper_limit)]\n",
    "    \n",
    "    df = pd.DataFrame(rh)\n",
    "    rollingMean = df.rolling(rolling_window).mean()\n",
    "\n",
    "    plt.figure(figsize=(10,7), facecolor='white')\n",
    "    \n",
    "    if plot_rw:\n",
    "        plt.plot(xs, rh, linewidth=1, color='cyan')\n",
    "    if plot_rm:\n",
    "        plt.plot(xs, rollingMean, linewidth=2, color='magenta')\n",
    "\n",
    "    text_color = 'black'\n",
    "        \n",
    "    ax = plt.gca()\n",
    "    ax.set_facecolor('black')\n",
    "    plt.grid()\n",
    "#     plt.title(\"Total Point History\", color=text_color, fontsize=40)\n",
    "    plt.xlabel('Episode', color=text_color, fontsize=30)\n",
    "    plt.ylabel('Total Points', color=text_color, fontsize=30)\n",
    "    yNumFmt = mticker.StrMethodFormatter('{x:,}')\n",
    "    ax.yaxis.set_major_formatter(yNumFmt)\n",
    "    ax.tick_params(axis='x', colors=text_color)\n",
    "    ax.tick_params(axis='y', colors=text_color)\n",
    "    plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the point history\n",
    "plot_history(total_point_history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Apply learned model and revisit results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 64)                640       \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 64)                4160      \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 3)                 195       \n",
      "=================================================================\n",
      "Total params: 4,995\n",
      "Trainable params: 4,995\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-08-24 09:50:34.979033: I tensorflow/core/platform/cpu_feature_guard.cc:145] This TensorFlow binary is optimized with Intel(R) MKL-DNN to use the following CPU instructions in performance critical operations:  SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "To enable them in non-MKL-DNN operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-08-24 09:50:34.979290: I tensorflow/core/common_runtime/process_util.cc:115] Creating new thread pool with default inter op setting: 8. Tune using inter_op_parallelism_threads for best performance.\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "import sys\n",
    "import logging\n",
    "import Car\n",
    "import Canvas\n",
    "import RobotCarSimulator\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import Sequential\n",
    "import numpy as np\n",
    "\n",
    "model = tf.keras.models.load_model('curve_tracking_model.h5')\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def driveForward():\n",
    "    global sim\n",
    "    sim.driveForward(100,150)\n",
    "\n",
    "def turnLeft():\n",
    "    global sim\n",
    "    sim.turnLeft(100,50)\n",
    "    \n",
    "def turnRight():\n",
    "    global sim\n",
    "    sim.turnRight(100,50)\n",
    "    \n",
    "actions = (driveForward, turnLeft, turnRight)\n",
    "\n",
    "# training curves used seeds (2,5,9,11,13,15,17,19,21)\n",
    "# we use 7, and 23 in addition to see how the model performs on unknown curves\n",
    "for seed in (2,5,7,9,11,13,15,17,19,21,23):\n",
    "    car = Car.CarModel()\n",
    "    # the seed controls the curve/line that we are following\n",
    "    canvas = Canvas.CanvasModel(seed=seed)\n",
    "    # we set createGif to False to save space and runtime - we will generate the video once we apply the trained model\n",
    "    sim = RobotCarSimulator.SimulatorControl(canvas, car, createGif=True, stephistory=STEPS_SENSOR_HISTORY)\n",
    "\n",
    "    while not sim.isTerminated() and sim.getDuration() < 20.0:\n",
    "        state_qn = np.expand_dims(np.array(list(sim.getPreviousLineTrackingSensorValues()) + sim.getLineTrackingSensorValues()), axis=0)\n",
    "        q_values = model(state_qn)\n",
    "        action = np.argmax(q_values.numpy()[0])\n",
    "        actions[action]()\n",
    "\n",
    "    sim.saveImage('images/model_seed_{}.gif'.format(seed))\n",
    "    with open('data/model_seed_{}.txt'.format(seed), 'w') as f:\n",
    "        f.write(\"actions:\\n\")\n",
    "        f.write(pprint.pformat(sim._actionLog))\n",
    "        f.write(\"\\n\\npositions:\\n\")\n",
    "        f.write(pprint.pformat(sim._carPositions))\n",
    "        f.write(\"\\n\\norientations:\\n\")\n",
    "        f.write(pprint.pformat(sim._carOrientations))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:No training configuration found in save file: the model was *not* compiled. Compile it manually.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-08-24 10:19:05.354555: I tensorflow/core/platform/cpu_feature_guard.cc:145] This TensorFlow binary is optimized with Intel(R) MKL-DNN to use the following CPU instructions in performance critical operations:  SSE4.1 SSE4.2 AVX AVX2 FMA\n",
      "To enable them in non-MKL-DNN operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-08-24 10:19:05.354859: I tensorflow/core/common_runtime/process_util.cc:115] Creating new thread pool with default inter op setting: 8. Tune using inter_op_parallelism_threads for best performance.\n"
     ]
    }
   ],
   "source": [
    "import RobotCarSimulator as sim\n",
    "sim.runModelAndSaveVideo('curve_tracking_model.h5')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}