Original subtitles

This course will be taught entirely in Python 3 .6.

I'm not being oddly specific here for its own sake.

There are some intricacies in some of the packages that require this

version, and Python 3 .7 or later won't actually work.

So if you're running an earlier or later version, it's best to create a separate

environment with 3 .6 or just downgrade or upgrade your global install.

As far as what features of the language you need to be comfortable with, you

should be proficient with the core features.

You don't need to know every nuance, but you should be able to use list

comprehensions, looping, conditionals, and know a little bit about the basics

inheritance and object -oriented programming.

With respect to the mathematics, the more exposure you've had, the better.

While I will put a heavy emphasis on math in this course, I'll explain

everything you need to know as we go along.

If you've studied linear algebra before, then you'll be well equipped to

understand the mechanics of neural networks.

If not, it's alright.

We'll cover what we need, when we need it.

A healthy dose of calculus would also be helpful, as it makes the concept of

gradient descent rather intuitive.

Again, don't worry, since we'll cover all of that when we need it.

As far as packages are concerned, they are relatively light.

You'll need PyTorch, TorchVision,

NumPy, Matplotlib, the OpenAI Gym, Box2Dpy, and AtariPy.

You can set all of this up in a virtual environment if you like, or just install

all of it to your default Python environment.

You may notice that I didn't mention Jupyter as a requirement.

To be honest, I'm not a big fan of Jupyter notebooks, and we won't be using

for this course.

They are pretty good for doing demonstrations and simple lessons.

but they have a number of shortcomings for serious programming.

If you want to put all of your code and some video into a Jupyter notebook to

show off on your GitHub, that's a great idea, but my solutions will all be in

Python files.

You can use the editor of your choice.

I'll be using Atom as its relatively lightweight and open source software.

VS Code is another great option, and it's available for all the major

systems.

Sublime is a great choice, though it is Nagware.

Bonus points if you use Vim.

Let's address the elephant in the room, the hardware.

Make no mistake, DeepQ learning is resource intensive.

For best results, you'll need an NVIDIA GPU of at least the Kepler generation or

better, which is the GTX 700 series and above.

I know that many of you won't meet this requirement, and that's fine, you can

still complete the course.

For those that don't have a heavy hitting GPU, I recommend sticking to the

environment.

It's simple enough that a modern CPU can learn to achieve world -class

performance in a reasonable amount of time.

If you have an adequate GPU, please feel free to apply these algorithms to as

many environments as you want.

The choice of environment doesn't affect the underlying code, so you'll learn

just as much by having an agent beat Pong as you will Breakout or any of the

other games in the Atari library.

For several environments, I'll provide pre -trained models on my GitHub. You

download these and play with them as you see fit.

Okay, that's all for now.

While you don't need to be a master of Python to succeed in this course,

familiarity with its core functionality is required.

A strong mathematical background is certainly helpful, but it is by no means

required.

The list of required packages is relatively light, just make sure you're

Python 3 .6 and a reliable code editor.

In the next video, we're going to talk about how to succeed in this course.