Overview of this book

Reinforcement learning (RL) is a branch of machine learning that has gained popularity in recent times. It allows you to train AI models that learn from their own actions and optimize their behavior. PyTorch has also emerged as the preferred tool for training RL models because of its efficiency and ease of use. With this book, you'll explore the important RL concepts and the implementation of algorithms in PyTorch 1.x. The recipes in the book, along with real-world examples, will help you master various RL techniques, such as dynamic programming, Monte Carlo simulations, temporal difference, and Q-learning. You'll also gain insights into industry-specific applications of these techniques. Later chapters will guide you through solving problems such as the multi-armed bandit problem and the cartpole problem using the multi-armed bandit algorithm and function approximation. You'll also learn how to use Deep Q-Networks to complete Atari games, along with how to effectively implement policy gradients. Finally, you'll discover how RL techniques are applied to Blackjack, Gridworld environments, internet advertising, and the Flappy Bird game. By the end of this book, you'll have developed the skills you need to implement popular RL algorithms and use RL techniques to solve real-world problems.
Preface
Free Chapter
Getting Started with Reinforcement Learning and PyTorch
Markov Decision Processes and Dynamic Programming
Monte Carlo Methods for Making Numerical Estimations
Capstone Project – Playing Flappy Bird with DQN
Other Books You May Enjoy

Simulating the CartPole environment

In this recipe, we will work on simulating one more environment in order to get more familiar with Gym. The CartPole environment is a classic one in reinforcement learning research.

CartPole is a traditional reinforcement learning task in which a pole is placed upright on top of a cart. The agent moves the cart either to the left or to the right by 1 unit in a timestep. The goal is to balance the pole and prevent it from falling over. The pole is considered to have fallen if it is more than 12 degrees from the vertical, or the cart moves 2.4 units away from the origin. An episode terminates when any of the following occurs:

• The pole falls over
• The number of timesteps reaches 200

How to do it...

Let's simulate the CartPole environment by following these steps:

1. To run the CartPole environment, let's first search for its name in the table of environments at https://github.com/openai/gym/wiki/Table-of-environments. We get 'CartPole-v0' and also learn that the observation space is represented in a 4-dimensional array, and that there are two possible actions (which makes sense).
2. We import the Gym library and create an instance of the CartPole environment:
` >>> import gym >>> env = gym.make('CartPole-v0')`
1. Reset the environment:
` >>> env.reset() array([-0.00153354,  0.01961605, -0.03912845, -0.01850426])`

As you can see, this also returns the initial state represented by an array of four floats.

1. Render the environment:
` >>> env.render() True`

You will see a small window popping up, as follows:

1. Now, let's make a while loop and let the agent perform as many random actions as it can:
` >>> is_done = False >>> while not is_done: ...     action = env.action_space.sample() ...     new_state, reward, is_done, info = env.step(action) ...     print(new_state) ...     env.render() ... [-0.00114122 -0.17492355 -0.03949854  0.26158095] True [-0.00463969 -0.36946006 -0.03426692  0.54154857] True …… …… [-0.11973207 -0.41075106  0.19355244 1.11780626] True [-0.12794709 -0.21862176  0.21590856 0.89154351] True`

Meanwhile, you will see that the cart and pole are moving. At the end, you will see they both stop. The window looks like the following:

The episode only lasts several steps because the left or right actions are chosen randomly. Can we record the whole process so we can replay it afterward? We can do so with just two lines of code in Gym, as shown in Step 7. If you are using a Mac or Linux system, you need to complete Step 6 first; otherwise, you can jump to Step 7.

1. To record video, we need to install the ffmpeg package. For Mac, it can be installed via the following command:
`brew install ffmpeg`

For Linux, the following command should do it:

`sudo apt-get install ffmpeg`
1. After creating the CartPole instance, add these two lines:
`>>> video_dir = './cartpole_video/'>>> env = gym.wrappers.Monitor(env, video_dir)`

This will record what is displayed in the window and store it in the specified directory.

Now re-run the codes from Step 3 to Step 5. After an episode terminates, we can see that an .mp4 file is created in the video_dir folder. The video is quite short; it may last 1 second or so.

How it works...

In this recipe, we print out the state array for every step. But what does each float in the array mean? We can find more information about CartPole on Gym's GitHub wiki page: https://github.com/openai/gym/wiki/CartPole-v0. It turns out that those four floats represent the following:

• Cart position: This ranges from -2.4 to 2.4, and any position beyond this range will trigger episode termination.
• Cart velocity.
• Pole angle: Any value less than -0.209 (-12 degrees) or greater than 0.209 (12 degrees) will trigger episode termination.
• Pole velocity at the tip.

In terms of the action, it is either 0 or 1, which corresponds to pushing the cart to the left and to the right, respectively.

The reward in this environment is +1 for every timestep before the episode terminates. We can also verify this by printing out the reward for every step. And the total reward is simply the number of timesteps.

There's more...

So far, we've run only one episode. In order to assess how well the agent performs, we can simulate many episodes and then average the total rewards for an individual episode. The average total reward will tell us about the performance of the agent that takes random actions.

Let’s set 10,000 episodes:

` >>> n_episode = 10000`

In each episode, we compute the total reward by accumulating the reward in every step:

` >>> total_rewards = [] >>> for episode in range(n_episode): ...     state = env.reset() ...     total_reward = 0 ...     is_done = False ...     while not is_done: ...         action = env.action_space.sample() ...         state, reward, is_done, _ = env.step(action) ...         total_reward += reward ...     total_rewards.append(total_reward)`

Finally, we calculate the average total reward:

` >>> print('Average total reward over {} episodes: {}'.format(           n_episode, sum(total_rewards) / n_episode)) Average total reward over 10000 episodes: 22.2473`

On average, taking a random action scores 22.25.

We all know that taking random actions is not sophisticated enough, and we will implement an advanced policy in upcoming recipes. But for the next recipe, let's take a break and review the basics of PyTorch.