Learning Path:TensorFlow: The Road to TensorFlow-2nd Edition
4.0 (33 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
583 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learning Path:TensorFlow: The Road to TensorFlow-2nd Edition to your Wishlist.

Add to Wishlist

Learning Path:TensorFlow: The Road to TensorFlow-2nd Edition

Discover deep learning and machine learning with Python and TensorFlow
4.0 (33 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
583 students enrolled
Created by Packt Publishing
Last updated 7/2017
English
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 10.5 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Build Python packages to efficiently create reusable code
  • Become proficient at creating tools and utility programs in Python
  • Design and train a multilayer neural network with TensorFlow
  • Understand convolutional neural networks for image recognition
  • Create pipelines to deal with real-world input data
  • Set up and run cross domain-specific examples (economics, medicine, text classification, and advertising)
  • Learn how to go from concept to a production-ready machine learning setup/pipeline capable of real-world usage
View Curriculum
Requirements
  • Requires a firm understanding of Python and the Python ecosystem.
  • Basic data science knowledge would be an added advantage
Description

Packt’s Video Learning Paths are a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.

It can be hard to get started with machine learning, particularly as new frameworks like TensorFlow start to gain traction across enterprise companies. TensorFlow is an open source software library for numerical computation using data flow graphs. The flexible architecture allows you to deploy computation to one or more CPUs or GPUs in a desktop, server, or mobile device with a single API.

This Learning Path begins by covering a mastery on Python with a deep focus on unlocking Python’s secrets. We then move on to understand deep learning as implemented by Python and TensorFlow. Finally, we solve common commercial machine learning problems using TensorFlow.

If you have no prior exposure to one of the most important trends impacting how we do data science in the next few years, this Learning Path will help you get up to speed.

The goal of this Learning Path is to help you understand deep learning and machine learning by getting to know Python first and then TensorFlow.

This Learning Path is authored by some of the best in their fields.

About the Authors

Daniel Arbuckle

Daniel Arbuckle got his Ph.D. In Computer Science from the University of Southern California. He has published numerous papers, along with several books and video courses, and is both a teacher of computer science and a professional programmer.

Eder Santana

Eder Santana is a Ph.D. candidate in Electrical and Computer Engineering. After working for 3 years with kernel machines (SVMs, Information Theoretic Learning, and so on), Eder moved to the field of deep learning 2.5 years ago, when he started learning Theano, Caffe, and other machine learning frameworks. Now, Eder contributes to Keras, the deep learning library for Python. Besides deep learning, he also likes data visualization and teaches machine learning, either on online forums or as a teacher assistant.

Dan Van Boxel

Dan Van Boxel is a data scientist and machine learning engineer with over 10 years of experience. He is well-known for "Dan Does Data", a YouTube livestream demonstrating the power and pitfalls of neural networks. He has developed and applied novel statistical models of machine learning to topics such as accounting for truck traffic on highways, travel time outlier detection, and other areas. Dan has also published research and presented findings at the Transportation Research Board and other academic journals.

Shams Ul Azeem

Shams Ul Azeem is an undergraduate student of NUST Islamabad, Pakistan, in Electrical Engineering. He’s pursuing his career in machine learning, particularly in deep learning, by doing medical-related freelance projects with different companies.

Who is the target audience?
  • This course is ideal for Python professionals looking to familiarize themselves with deep learning and machine learning. No commercial domain knowledge is required but familiarity with Python and matrix math is expected.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
111 Lectures
10:21:09
+
Mastering Python - Second Edition
51 Lectures 05:20:43

This video provides an overview of the entire course

Preview 03:24

The goal of this video is to provide a basic understanding of the Python language constructs.

Python Basic Syntax and Block Structure
11:54

The goal of this video is to ensure we have the basic ability to operate with Python's most common data structures.

Built-in Data Structures and Comprehensions
08:54

People used to lower-level languages are unfamiliar with First-class functions and classes; we'll take a look at them in this video.

First-Class Functions and Classes
05:49

Python comes with a lot of tools. We need to be familiar with them in order to make the best use of the language. That's the topic we will be covering in this video.

Extensive Standard Library
05:55

The goal of this video is to look at the overview of recent language changes in Python.

New in Python 3.5
06:01

In this video, we are going to download and install the correct version of Python and make sure it's functional.

Preview 05:16

The fastest way to get rolling is to use a textual interface, so we need to make sure we know how to use it. That's the goal in this video

Using the Command-Line and the Interactive Shell
04:01

Python has good support for installing and managing third-party code packages; let's take a look at them in this video.

Installing Packages with pip
03:16

There's a lot of good code available. How do we find it? Let's take a look in this video.

Finding Packages in the Python Package Index
04:29

The goal of this video is to know how to create the structure of a Python program.

Preview 05:50

A package containing no code isn't of much use. How do we make it do something? Let's take a look at it in this video.

Adding Modules to the Package
05:30

The goal in this video is to understand how we can make code in separate modules of the package interact.

Importing One of the Package's Modules from Another
05:26

A complete program usually involves static data files along with the code. How do we integrate non-python files in a package? Let's find out!

Adding Static Data Files to the Package
02:53

The computer can read our code as long as the syntax is correct, but humans require more care. Let's see how we can write readable code in Python.

Preview 07:50

If more than one programmer is working on a project, version control is a necessity. Even for a single programmer, version control is useful. We will take a look at it in this video.

Using Version Control
04:47

In this video, we will see how writing a program can take a while, and it's best that external changes to the development system do not impact the process.

Using venv to Create a Stable and Isolated Work Area
04:40

Properly formatted docstrings can be automatically used by IDEs and transformed into HTML. Let's take a peek into it in this video.

Getting the Most Out of docstrings 1: PEP 257 and docutils
08:00

The goal of this video is to understand why it's important that examples in the documentation stay consistent with the code.

Getting the Most Out of docstrings 2: doctest
04:04

Writing Python code packages is all well and good, but how to we make a program? We will take a look at it in this video.

Preview 05:51

It's useful to be able to read data from the program command line. The argparse package makes it easy. Let's see it in action in this video.

Handling Command-Line Arguments with argparse
06:21

What do we do when we need information to flow both ways with the user?

Interacting with the User
04:38

Running other programs from within a program is often useful, especially, for system automation. We'll look at how to do it.

Executing Other Programs with Subprocess
09:09

It's often useful to have a launcher file for a program, which can be double-clicked in a GUI or used a shorthand from the command line. A simple script or batch file does the trick, let's see how.

Using Shell Scripts or Batch Files to Run Our Programs
03:00

Parallel processing has pitfalls, but Python's high-level parallel processing framework makes it easy to dodge them. Let's look at it in this video.

Preview 13:52

When our program doesn't fit the conceptual model of concurrent.futures, we can use multiprocessing to define our own model. Let's see how.

Using Multiprocessing
11:22

At first glance, Python's coroutine scheduling looks a lot like multiprocessing or multithreading. What's the difference? Let's get to know this better.

Preview 08:01

The goal of this video is to set up and run the asyncio asyncio coroutine scheduler

Using the asyncio Event Loop and Coroutine Scheduler
06:52

In this video we will see how do we actually use asyncio's Future objects.

Waiting for Data to Become Available
03:29

The goal of this video is to understand how to keep coroutines from jamming each other up and locking the program.

Synchronizing Multiple Tasks
06:17

In this video, we will see how do asyncio's actual I/O facilities work

Communicating Across the Network
03:45

Functions are very useful, but it would be nice to be able to tweak them to suit our specific needs. Enter function decorators.

Preview 06:45

If we're going to be using functions as data, it would be nice to have metadata for the functions too. Function annotations give us that.

Function Annotations
07:08

Class objects are basically data structures, so it would be useful to be able to rewrite them as they're defined. Class decorators let us do that.

Class Decorators
05:52

Class decorators take effect after Python has created a class object. If we want our code involved before the class object is created, we need to use a metaclass.

Metaclasses
05:35

Pieces of code often come in matched pairs, with one piece needing to run before something happens and the matching piece after. Context managers make sure the pieces match up.

Context Managers
05:52

We can plug code into Python's attribute access mechanism to control what it means to read, write, or delete a member variable.

Descriptors
05:37

Testing is critical, but it can feel like a burden. Automated unit testing and test-driven development can solve this problem.

Preview 05:07

The unittest package provides a framework for writing automatic tests; let's check it out.

Using the unittest Package
07:27

We need to separate the code we're testing from everything else. When the code interacts with other objects, we can replace them with mock objects. Let's see how.

Using unittest.mock
06:12

As a test suite grows, running the tests individually becomes impractical. We need the system to find and run them in large swaths.

Using unittest's Test Discovery
04:30

Sometimes we want a more flexible test runner than the one built in to unittest. Nose to the rescue.

Using Nose for Unified Test Discover and Reporting
03:42

For the newcomer, it can be difficult to figure out exactly what other people are talking about when they say "reactive programming".

Preview 02:49

Many of the discussions of reactive programming are highly theoretical. Building a reactive programming system for ourselves will help show how simple the basic ideas are.

Building a Simple Reactive Programming Framework
07:21

Creating a complete and correct reactive programming framework takes a lot of time and effort. Since somebody's already done it, let's take a look at the result.

Using the Reactive Extensions for Python (RxPY)
10:21

We need our web server to scale up and maintain high availability. Let's see how we can do that.

Preview 04:12

We need a microservice that works well with the web infrastructure or perhaps is even directly accessible to JavaScript running in web browsers.

Building a High-Level Microservice with Flask
09:59

Sometimes, we'd rather have all of the protocol-level stuff handled automatically for our microservice.

Building a Low-Level Microservice with nameko
06:24

Sometimes we need to access or create compiled code and sometimes we don't need it as much as we think. How do we know which is which?

Preview 04:41

There's a lot of useful code out that wasn't written for Python, but most of it is accessible to C code.

Accessing a Dynamic Library Using ctypes
07:59

Sometimes we just need to write a code that runs close to the metal. Cython gives us that option.

Interfacing with C Code Using Cython
12:34
+
Deep Learning with Python
19 Lectures 01:45:43

This video will provide an overview of the course.

Preview 03:51

What is Deep Learning, and when is it the way to go?

What Is Deep Learning?
04:08

How to avoid programming Deep Learning from scratch? Let’s take a look at it in this video.

Open Source Libraries for Deep Learning
04:30

How to get our first deep neural network trained?

Deep Learning Hello World! Classifying the MNIST Data
07:57

How are neural networks trained?

Preview 05:23

How can we avoid making a differentiation of functions and make backpropagation easier?

Understanding Deep Learning with Theano
05:04

How do Keras and other libraries use Theano work behind the scenes?

Optimizing a Simple Model in Pure Theano
07:53

How does Keras work?

Preview 05:24

How does Keras work? How does one write a basic, fully connected neural network layer in Keras?

Fully Connected or Dense Layers
04:46

Understand what convolutional neural networks are and how to use them. How can we write convolutional layers with Python?

Convolutional and Pooling Layers
06:40

How can we solve complex image datasets (for example, cats versus dogs) without training a full model from scratch?

Preview 05:17

How does Keras work?

Loading Pre-trained Models with Theano
05:15

We will solve complete image datasets with pretrained models: classifying cats versus dogs.

Reusing Pre-trained Models in New Applications
07:22

How to write a loop in Theano?

Preview 05:18

How can one define neural network layers with internal states?

Recurrent Layers
06:28

Recurrent or convolutional: How can one know which layer they should use?

Recurrent Versus Convolutional Layers
03:42

How can we classify sentiments from text?

Recurrent Networks –Training a Sentiment Analysis Model for Text
06:50

How can we automatically describe an image in English?

Preview 04:40

What is TensorFlow?

Captioning TensorFlow – Google's Machine Learning Library
05:15
+
Deep Learning with TensorFlow
22 Lectures 02:00:12

This video gives an overview of the entire course.

Preview 02:59

TensorFlow is a new machine library that is probably not installed on our operating system by default. This video will guide you through installing TensorFlow locally or remotely.

Installing TensorFlow
05:33

Before we can use TensorFlow for deep learning, we need to understand how TensorFlow handles basic objects and operations. This video will walk you through a few computations.

Simple Computations
05:31

Learning any library from documentation can be challenging, so we're going to build a practical machine learning classifier with TensorFlow. We'll start with a simple logistic regression classifier and build up from there.

Logistic Regression Model Building
06:58

Though we have a classifier, we need to compute weights so that our model is accurate. For this, we can use TensorFlow to specify and optimize a loss function. TensorFlow will then use this to find good weights.

Logistic Regression Training
04:53

Using single pixels as features limits us to model essentially linear phenomena. To model non-linear things such as font styles involving several pixels, we will use neural networks to transform our inputs into non-linear combinations for use in a logistic regression classifier.

Preview 05:14

Now that we understand neural networks, we can see how TensorFlow makes them easy to implement and train.

Single Hidden Layer Model
05:05

Now that we've trained a neural network, we should inspect it closely to understand the accuracy and weights.

Single Hidden Layer Explained
04:32

A single hidden layer is good, but you may find the number of neurons growing prohibitive in order to model very complex features. To combine features more easily, we expand the network in depth rather than width. It's true deep learning with multiple hidden layers.

Multiple Hidden Layer Model
05:22

With our deep neural net trained, we should take time to check its accuracy and understand the features it's extracting.

Multiple Hidden Layer Results
04:43

Particularly in images, the features that we want to find can occur anywhere among the pixels. Convolutional neural nets allow us to train one set of weights to search small windows of an image for a feature.

Preview 05:03

Understanding the theory of convolutional layers is useless without learning the tools to actually use them. This video walks through a simple example with TensorFlow.

Convolutional Layer Application
06:55

Convolutions can find a feature anywhere in an image, but with all the overlap, we need to make sure we don't find the same feature in the same place multiple times. A pooling layer reduces the size of our input, taking only relevant information.

Pooling Layer Motivation
03:58

Having learned how Max Pooling works in theory, it's time to put it into practice by adding it to our simple example in TensorFlow.

Pooling Layer Application
04:17

We've learned about convolutional layers and used them in an example, but now let's use them for real by adding a convolutional layer to the font classification model.

Deep CNN
06:28

Convolutional layers often work well when chained together. Let's add another to our font classification model.

Deeper CNN
04:08

After our deep model has trained for a model, it's time to see how well it performs.

Wrapping Up Deep CNN
04:55

Some problems have time-based inputs. Features from the recent past might matter to the current prediction. To address these, researchers have developed recurrent neural networks. TensorFlow natively supports these.

Preview 09:02

TensorFlow models can be cumbersome to specify, yet follow a common pattern. skflow provides a simple interface for typical models.

skflow
09:19

RNNs can be hard to specify, but skflow will let us quickly build a model.

RNNs in skflow
04:04

After learning so many methods and building all these models, it's helpful to look back and see how far we've come.

Preview 06:55

TensorFlow is changing very quickly and is being adopted by more researchers and professionals. But at its core are the contributions submitted by new users.

The Future of TensorFlow
04:18
+
Machine Learning with TensorFlow
19 Lectures 01:14:31

This video gives an overview of the entire course.

Preview 03:48

Get the user excited about ML; a quick view of various platforms and key products using the ML tools (photo search, Siri, and so on).

Introducing Deep Learning
03:59

We will install the TensorFlow platform and associated prerequisites on the Mac OS X operating system.

Installing TensorFlow on Mac OSX
03:50

Since TensorFlow does not function natively on Windows, we will cover Virtual Machine setup so Windows users can run Linux on a VM.

Installation on Windows – Pre-Reqeusite Virtual Machine Setup
02:49

We will cover TensorFlow installation on Linux. This also covers installation on Windows via a Virtual Machine running Linux.

Installation on Windows/Linux
04:00

Which dataset do we use for our first classifier, and what attributes do we consider? Let's use a dataset of letters in numerous typefaces.

Preview 03:01

We just spent a good amount of time obtaining and preparing data, are we expected to do this for each run? No, you'll now learn to automate the initial steps used to feed the machine learning process.

Automating Data Preparation
03:20

How do we represent images internally within the machine learning environment? We'll hold image data in a stack of matrices.

Understanding Matrix Conversions
05:34

So now that we have looked upon the major concepts, the question remains how do we actually train the classifier in code? We are now going to code and train a classifier using TensorFlow.

The Machine Learning Life Cycle
01:51

Once training is complete, how are the results interpreted and measured? We'll use the training set, with known labels to measure how well our trained system performs.

Reviewing Outputs and Results
02:51

How do we monitor the internals of our training setup and execution? We'll use TensorBoard to view our network architecture and probe values through the training.

Preview 05:08

How do we monitor the scalars and tensors on TensorBoard? We'll set up code for log specific variables and TensorBoard reads these structured logs.

TensorBoard Events and Histograms
05:21

How do we view the network architecture we've built for our training? We'll push the graph to a TensorBoard readable log and view it on Graph Explorer.

The Graph Explorer
05:08

How do we actually apply what you've just learned to our own project? You'll learn to go through individual changes to our previous project.

Our Previous Project on TensorBoard
05:02

How do we process images with more complex and better suited neural networks? For this purpose, we will use the well-known convolutional neural networks also known as CNNs.

Preview 04:44

How do CNNs work and what does their model look like? We are going to talk about the basic model architecture of CNN.

Convolutional Neural Networks
04:58

How to implement a basic CNN? We will look into the coding of a CNN.

Programming a CNN
05:01

How does it look after coding? We will visualize the implemented CNN in TensorFlow.

Using TensorBoard on Our CNN
01:58

How much better CNNs are as compared to normal fully connected networks? We will compare the performances of the two models on CIFAR-10 dataset.

CNN Versus Fully Connected Network Performance
02:08
About the Instructor
Packt Publishing
3.9 Average rating
8,175 Reviews
58,737 Students
686 Courses
Tech Knowledge in Motion

Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.

With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.

From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.

Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.