Advanced AI: Deep Reinforcement Learning in Python

Advanced AI: Deep Reinforcement Learning in Python. In this Course we will be diving deep into the world of reinforcement learning (RL), a subfield of AI that aims to create intelligent systems that can learn and improve their performance without being explicitly programmed. RL has been shown to be successful in a variety of tasks, from playing video games to performing surgery, and has seen increasing popularity in recent years as more and more applications become available for it. In this tutorial, we will be using the well-known deep learning library TensorFlow to implement a basic RL agent.

This tutorial is aimed at beginners who are familiar with basic programming concepts, and covers the following topics:

– Introduction to deep learning and TensorFlow – Building a basic RL agent in TensorFlow – Training the agent on a training set and testing it on a test set

If you are not familiar with programming, we recommend that you start with our introductory tutorial on Python before proceeding.

To begin, let’s install TensorFlow. On macOS, this can be done by running the following command in a terminal: sudo pip install tensorflow On Windows, run the following command in a Command Prompt: tensorflow install tensorflow

Next, let’s create a new file called “” and enter the following code: from __future__ import absolute_import from __future__ import division from __future__ import print_ import tensorflow as tf from rl_tutorial import Agent

In this file, we first import the necessary libraries. We then create a new class called Agent which will represent our RL agent. We also define some constants to hold important information about our agent. The first constant is the learning rate, which is used to adjust the strength of the neural network during training.

The second constant is the number of epochs (or passes through the training data) that our agent will undergo before reaching convergence. The last constant defines how many errors our agent will make during training before it is discarded. Next, we create a function called train() which will be used to train our agent. The function takes as input the current values of the learning rate and the number of epochs, and returns the updated values of these variables.

Free Course:  Python Programming for Network Engineers: Cisco, Netmiko ++

Finally, create a function calledevaluate() which is used to evaluate our agent on a test set. The function takes as input a training set and an error threshold (which is used to determine when our agent has reached convergence). If the error threshold is exceeded, then we return True; otherwise, False is returned.

def train(self, learning_rate, epochs):    current_learning_rate = learning_rate   current_epochs = epochs

def evaluate(self, training_set, error_threshold):

if error_threshold > 0: return True

  • Build various deep learning agents (including DQN and A3C)
  • Apply a variety of advanced reinforcement learning algorithms to any problem
  • Q-Learning with Deep Neural Networks
  • Policy Gradient Methods with Neural Networks
  • Reinforcement Learning with RBF Networks
  • Use Convolutional Neural Networks with Deep Q-Learning

Advanced AI: Deep Reinforcement Learning in Python Course Requirements

  • Know reinforcement learning basics, MDPs, Dynamic Programming, Monte Carlo, TD Learning
  • College-level math is helpful
  • Experience building machine learning models in Python and Numpy
  • Know how to build ANNs and CNNs using Theano or Tensorflow

Advanced AI: Deep Reinforcement Learning in Python Course Description

This course is all about the application of deep learning and neural networks to reinforcement learning.

If you’ve taken my first reinforcement learning class, then you know that reinforcement learning is on the bleeding edge of what we can do with AI.

Specifically, the combination of deep learning with reinforcement learning has led to AlphaGo beating a world champion in the strategy game Go, it has led to self-driving cars, and it has led to machines that can play video games at a superhuman level.

Reinforcement learning has been around since the 70s but none of this has been possible until now.

The world is changing at a very fast pace. The state of California is changing their regulations so that self-driving car companies can test their cars without a human in the car to supervise.

We’ve seen that reinforcement learning is an entirely different kind of machine learning than supervised and unsupervised learning.

Free Course:  Machine Learning : Random Forest with Python from Scratch©

Supervised and unsupervised machine learning algorithms are for analyzing and making predictions about data, whereas reinforcement learning is about training an agent to interact with an environment and maximize its reward.

Unlike supervised and unsupervised learning algorithms, reinforcement learning agents have an impetus – they want to reach a goal.

This is such a fascinating perspective, it can even make supervised / unsupervised machine learning and “data science” seem boring in hindsight. Why train a neural network to learn about the data in a database, when you can train a neural network to interact with the real-world?

While deep reinforcement learning and AI has a lot of potential, it also carries with it huge risk.

Bill Gates and Elon Musk have made public statements about some of the risks that AI poses to economic stability and even our existence.

As we learned in my first reinforcement learning course, one of the main principles of training reinforcement learning agents is that there are unintended consequences when training an AI.

AIs don’t think like humans, and so they come up with novel and non-intuitive solutions to reach their goals, often in ways that surprise domain experts – humans who are the best at what they do.

OpenAI is a non-profit founded by Elon Musk, Sam Altman (Y Combinator), and others, in order to ensure that AI progresses in a way that is beneficial, rather than harmful.

Part of the motivation behind OpenAI is the existential risk that AI poses to humans. They believe that open collaboration is one of the keys to mitigating that risk.

One of the great things about OpenAI is that they have a platform called the OpenAI Gym, which we’ll be making heavy use of in this course.

It allows anyone, anywhere in the world, to train their reinforcement learning agents in standard environments.

In this Advanced AI: Deep Reinforcement Learning in Python course, we’ll build upon what we did in the last course by working with more complex environments, specifically, those provided by the OpenAI Gym:

  • CartPole
  • Mountain Car
  • Atari games
Free Course:  Python Machine Learning Bootcamp

To train effective learning agents, we’ll need new techniques.

We’ll extend our knowledge of temporal difference learning by looking at the TD Lambda algorithm, we’ll look at a special type of neural network called the RBF network, we’ll look at the policy gradient method, and we’ll end the course by looking at Deep Q-Learning (DQN) and A3C (Asynchronous Advantage Actor-Critic).

Thanks for reading, and I’ll see you in class!

“If you can’t implement it, you don’t understand it”

  • Or as the great physicist Richard Feynman said: “What I cannot create, I do not understand”.
  • My courses are the ONLY courses where you will learn how to implement machine learning algorithms from scratch
  • Other courses will teach you how to plug in your data into a library, but do you really need help with 3 lines of code?
  • After doing the same thing with 10 datasets, you realize you didn’t learn 10 things. You learned 1 thing, and just repeated the same 3 lines of code 10 times…

Suggested Prerequisites:

  • College-level math is helpful (calculus, probability)
  • Object-oriented programming
  • Python coding: if/else, loops, lists, dicts, sets
  • Numpy coding: matrix and vector operations
  • Linear regression
  • Gradient descent
  • Know how to build ANNs and CNNs in Theano or TensorFlow
  • Markov Decision Proccesses (MDPs)
  • Know how to implement Dynamic Programming, Monte Carlo, and Temporal Difference Learning to solve MDPs


  • Check out the lecture “Machine Learning and AI Prerequisite Roadmap” (available in the FAQ of any of my courses, including the free Numpy course)

Recommended Course: A Complete Guide on TensorFlow 2.0 using Keras API

Who this course is for:

  • Professionals and students with strong technical backgrounds who wish to learn state-of-the-art AI techniques


Advanced AI: Deep Reinforcement Learning in Python Course Download Now

Hash Code Work Only

Leave a Comment