Learning Path: From Python Programming to Data Science
3.4 (5 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.
68 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Learning Path: From Python Programming to Data Science to your Wishlist.

Add to Wishlist

Learning Path: From Python Programming to Data Science

Unleash the true potential of Python by learning basic programming and high-end data science techniques.
3.4 (5 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.
68 students enrolled
Created by Packt Publishing
Last updated 5/2017
English
Current price: $10 Original price: $200 Discount: 95% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 21 hours on-demand video
  • 1 Supplemental Resource
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • Familiarize yourself with Python
  • Learn data analysis using modern processing techniques with NumPy, SciPy, and Pandas
  • Determine different approaches to data visualization, and how to choose the most appropriate one for your needs
  • Make 3D visualizations mainly using mplot3d
  • Work with image data and build systems for image recognition and biometric face recognition
  • Grasp how to use deep neural networks to build an optical character recognition system
View Curriculum
Requirements
  • Basic knowledge of any programming language (preferably Python)
  • Some knowledge of linear algebra and statistics would be helpful, but is not mandatory
Description

Python has become the language of choice for most data analysts/data scientists to perform various tasks of data science. If you’re looking forward to implementing Python in your data science projects to enhance data discovery, then this is the perfect Learning Path is for you. Starting out at the basic level, this Learning Path will take you through all the stages of data science in a step-by-step manner.

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.

We begin this journey with nailing down the fundamentals of Python. You’ll be introduced to basic and advanced programming concepts of Python before moving on to data science topics. Then, you’ll learn how to perform data analysis by taking advantage of the core data science libraries in the Python ecosystem. You’ll also understand the data visualization concepts better, learn how to apply them and  overcome any challenges that you might face while implementing them. Moving ahead, you’ll learn to use a wide variety of machine learning algorithms to solve real-world problems. Finally, you’ll learn deep learning along with a brief  introduction to TensorFlow.

By the end of the Learning Path, you’ll be able to improve the efficiency of your data science projects using Python.

Meet Your Experts:

We have combined the best works of the following esteemed authors to ensure that your learning journey is smooth:

Daniel Arbuckle got his Ph.D. in Computer Science from the University of Southern California.

Benjamin Hoff spent 3 years working as a software engineer and team leader doing graphics processing, desktop application development, and scientific facility simulation using a mixture of C++ and Python.

Dimitry Foures is a data scientist with a background in applied mathematics and theoretical physics.

Giuseppe Vettigli is a data scientist who has worked in the research industry and academia for many years.

Igor Milovanović is an experienced developer, with strong background in Linux system knowledge and software engineering education.

Prateek Joshi is an artificial intelligence researcher, published author of five books, and TEDx speaker.

Eder Santana is a PhD candidate on Electrical and Computer Engineering. His thesis topic is on Deep and Recurrent neural networks.

Who is the target audience?
  • If you are a developer, a data analyst, or a data scientist who is familiar with the basics of Python and want to broaden your knowledge to develop data science projects efficiently, then this Learning Path is for you.
  • Even if you are not very familiar with Python but want to establish your career in the data science field, this Learning Path will help you as it starts with the basics and takes you on a journey to become an expert in the technology.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
240 Lectures
20:55:03
+
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

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
+
Learning Python Data Analysis
24 Lectures 05:55:11

This video provides an overview of the entire course.

Preview 03:55

The aim of this video is to introduce us to Python.

Getting started with Python
26:22

We will learn how to collect and store the data.

Getting Data using the Twitter API
20:47

We will explore how to collect and store twitter tweets.

Collecting and Storing Tweets
09:26

We will talk about database design.

Database Design
10:30

We will explore Pandas and other databases.

Pandas and Databases
05:55

We will explore the concepts of Panda series, data frames and columnar operations.

Preview 21:21

We will take a look operations and how to exactly work with columns.

Grouping Operations and Working with Date Columns
17:01

We will explore how to merge various operations and learn how to export data to JSON/CSV.

Merging Operations and Exporting data to JSON/CSV
14:54

We will take a look at what exactly arrays are, their different types, and histogram functions.

Preview 21:02

See exactly what simple aggregations are.

Simple Aggregations
21:23

We will explore the concept of linear algebra.

Linear Algebra
04:29

We will learn how to present stories via simple visualizations and representations.

Preview 31:47

We will learn the different types of graphical representations.

Creating Charts
07:35

We will learn how to create Simple XY plots and axis scales.

Simple XY Plots with Axis Scales
04:47

We will learn how to handle text data.

Preview 18:53

Bag of Words
21:33

We will learn how to classify words.

Classification of Words
09:26

We will take a look at stemming of words.

Stemming
11:53

We will use the simple sentiment analysis using scrapped tweets.

Simple Sentiment Analysis
05:42

We will learn how to group dimensions and also take a look at the different types of data that is generated.

Preview 25:04

We will take a look at New metrics and dimensions will be derived to get hidden insights.

Trend Analysis and Deriving New Metrics
20:28

We will take a look at the concept of co-relation analysis.

Correlation Analysis
17:28

We will briefly go over what we covered in the course and also take a glimpse at what the future holds for us.

Course Summary
03:30
+
Python Data Visualization Solutions
50 Lectures 03:26:54

This section gives an overview of the entire course.

Preview 03:38

Importing data from csv into Python can be a bit tricky. It needs careful inspection and appropriate functions. Let's see how we can do that.

Importing Data from CSV
04:32

When we are automating a data pipe for many files, we are not in a position to convert an Excel file into CSV and then import it. This video shows us how to import data directly from an Excel file.

Importing Data from Microsoft Excel Files
04:45

We've learned how to import data from CSV and Excel. But how do we do that with a file that has fixed-width data? Let's explore.

Importing Data from Fix-Width Files
03:05

Although tab-delimited format is simple to read as csv files, we need to ensure that certain parameters are there to keep the reading process accurate. Let's explore how we can do that.

Importing Data from Tab Delimited Files
02:23

Let's explore how we can import data from a JSON resource like GitHub, and How to get it and process it later.

Importing Data from a JSON Resource
05:17

Modern applications often hold different datasets inside relational databases or other databases like MongoDB, and we have to use these databases to produce beautiful graphs. This video will show us how to use SQL drivers from Python to access data.

Importing Data from a Database
05:08

Data coming from the real world needs cleaning before processing or even visualization. It's not fully automated and we need to understand outliers in order to clean the data. Let's see how we can do that.

Cleaning Up Data from Outliers
05:54

In scientific computing, images are often represented as NumPy array data structures. We can import images using various techniques. In this video, we will take a look at using image processing in Python, mainly related to scientific processing and less on the artistic side of image manipulation.

Importing Image Data into NumPy Arrays
06:01

In this video, we will see different ways of generating random number sequences and word sequences. Some of the examples use standard Python modules, and others use NumPy/SciPy functions.

Generating Controlled Random Datasets
06:36

Data that comes from different real-life sensors is not smooth; it contains some noise that we don't want to show on diagrams and plots. In this video, we introduce a few advanced algorithms to help with cleaning of data coming from real-world sources.

Smoothing Noise in Real-World Data
04:45

There are different plots used for representing data differently. In this video, we'll compare them and understand advanced concepts in data visualization. We would also plot sine and cosine plots and customize them.

Preview 07:53

Now that we've learned the concepts of basic plotting and customizing, this video will show us a variety of useful axis properties that we can configure in matplotlib to define axis lengths and limits.

Defining Axis Lengths and Limits
05:16

There are different kinds of audiences to whom the data is presented. Having lines set up distinct enough for target audiences for example, vivid colors for young audience leaves a great impact on the viewer. This video shows how we can change various line properties such as styles, colors, or width.

Defining Plot Line Styles, Properties, and Format Strings
01:58

As we now know how to change various line properties such as styles, colors, and width, this video will guide us with adding more data to our figure and charts by setting axis and line properties.

Setting Ticks, Labels, and Grids
02:42

Legends and annotations explain data plots clearly and in context. By assigning each plot a short description about what data it represents, we enable an easier model for the viewer. This video will show how to annotate specific points on our figures and how to create and position data legends.

Adding Legends and Annotations
02:33

Spines define data area boundaries; they connect the axis tick marks. There are four spines. We can place them wherever we want. As they are placed on the border of the axis, we see a box around our data plot. This video will demonstrate how to move spines to the center.

Moving Spines to Center
01:21

Histograms are often used in image manipulation software as a way to visualize image properties such as distribution of light in a particular color channel. This video will help us create histograms in 2D.

Making Histograms
03:59

To visualize the uncertainty of measurement in our dataset or to indicate the error, we can use error bars. Error bars can easily give an idea of how error free the dataset is. In this video, we will see how to create bar charts and how to draw error bars.

Making Bar Charts with Error Bars
03:23

Pie charts are special in many ways, the most important being that the dataset they display must sum up to 100 percent or they are just not valid. Let's explore how we can create pie charts to represent data in a better way.

Making Pie Charts Count
01:58

The matplotlib library allows us to fill areas in between and under the curves with color so that we can display the value of that area to the viewer. In this video, we will learn how to fill the area under a curve or in between two different curves.

Plotting with Filled Areas
01:56

If you have two variables and want to spot the correlation between those, a scatter plot may be the solution to spot patterns. This type of plot is also very useful as a start for more advanced visualizations of multidimensional data. Let's see how to create a scatter plot.

Drawing Scatter Plots with Colored Markers
02:12

To be able to distinguish one particular plot line in the figure, we need to add a shadow effect.

Preview 03:55

Adding a data table beside our chart helps to visualize information.

Adding a Data Table to the Figure
02:26

You can create custom subplot configurations on your plots in this video.

Using Subplots
03:57

To spot differences in patterns and compare plots visually in the figure, we need to customize our grids.

Customizing Grids
03:04

To display isolines, we create contour plots.

Creating Contour Plots
03:23

To distinguish clearly between two different plots, we fill the areas with different patterns.

Filling an Under-Plot Area
02:01

When the information is radial in nature, we need a polar plot to display information.

Drawing Polar Plots
02:56

You will learn how to visualize a real-world task in this video.

Visualizing the filesystem Tree Using a Polar Bar
03:02

You must be curious to plot 3D data after getting your hands on 2D. Python provides a toolkit called mplot3d in matplotlib for this. Let's go ahead and explore its working!

Preview 05:32

Similar to 3D bars, you might want to create 3D histograms since these are useful for easily spotting correlations between three independent variables. Let us now dive into it!

Creating 3D Histograms
03:12

This video will walk you through graphics rendering with OpenGL. So let's go ahead and do it!

Animating with OpenGL
06:01

Images can be used to highlight the strengths of your visualization in addition to pure data values. It maps deeper into the viewer's mental model, thereby helping the viewer to remember the visualizations better and for a longer time. Let's see how we could use them in Python!

Preview 06:17

This video will walk you through how you can make simple yet effective usage of the Python matplotlib library to process image channels and display the per-channel histogram of an external image.

Displaying Images with Other Plots in the Figure
03:52

The best geospatial visualizations are done by overlaying data on the map. This video will show you how to project data on a map using matplotlib's Basemap toolkit. Let's dive into it!

Plotting Data on a Map Using Basemap
05:22

This video will take you through the generation of random images to tell humans and computers apart. Let's do it!

Generating CAPTCHA
06:36

With the logarithmic scale, the ratio of consecutive values is constant. This is important when we are trying to read log plots. Let us step ahead and see how to perform it!

Preview 05:18

In this video we will discuss how to create a stem plot which will display data as lines extending from a baseline along the x-axis.

Creating a Stem Plot
04:17

In this video we will visualize wind patterns or liquid flow, and we will use uniform representation of the vector field for this. So, let's go ahead and do it!

Drawing Streamlines of Vector Flow
03:27

Color-coding the data can have great impact on how your visualizations are perceived by the viewer, as they come with assumptions about colors and what colors represent. This video will walk you through the steps showing the use of colormaps!

Using Colormaps
05:16

If we want to take a quick look at the data and see if there is any correlation, we would draw a quick scatter plot.Iin this video, you will understand scatter plots.

Using Scatter Plots and Histograms
04:28

If you have two different datasets from two different observations, you want to know if those two event sets are correlated. You want to cross-correlate them and see if they match in any way. This video will let you achieve this goal!

Plotting the Cross Correlation Between Two Variables
03:27

How you could predict the growth of stock dividends? In this video we will dive into some interesting steps which will let you understand the importance of autocorrelation for this prediction!

The Importance of Autocorrelation
04:11

Let's look into how to visualize two-dimensional vector quantities such as speed and direction of wind!

Preview 06:23

How will you visually compare several similar data series? This video will walk you through making a box-and-whisker plot which achieves this goal!

Making a Box-and-Whisker Plot
03:36

One form of very widely used visualization of time-based data is a Gantt chart. Let us see how to work with it!

Making Gantt Charts
03:49

Error bars are useful to display the dispersion of data on a plot. So, let's explore their use in Python for data visualization.

Making Error Bars
04:40

This video will let you explore more features of text manipulation in matplotlib, giving a powerful toolkit for even advanced typesetting needs. Let's dive into it.

Making Use of Text and Font Properties
03:59

This video will explain some of the programming interfaces in matplotlib and make a comparison of pyplot and object-oriented API. Let us now explore it!

Understanding the Difference between pyplot and OO API
05:12
+
Python Machine Learning Solutions
96 Lectures 04:26:32

Machine learning algorithms need processed data for operation. Let’s explore how to process raw data in this video.

Preview 06:38

Algorithms need data in numerical form to use them directly. But we often label data with words. So, let’s see how we transform word labels into numerical form.

Label Encoding
02:25

Linear regression uses a linear combination of input variables to estimate the underlying function that governs the mapping from input to output. Our aim would be to identify that relationship between input data and output data.

Building a Linear Regressor
04:25

There are some cases where there is difference between actual values and values predicted by regressor. We need to keep a check on its accuracy. This video will enable us to do that.

Regression Accuracy and Model Persistence
03:41

Linear regressors tend to be inaccurate sometimes, as outliers disrupt the model. We need to regularize this. We will see that in this video.

Building a Ridge Regressor
02:41

Linear model fails to capture the natural curve of datapoints, which makes it quite inaccurate. So, let’s go through polynomial regressor to see how we can improve that.

Building a Polynomial Regressor
02:33

Applying regression concepts to solve real-world problems can be quite tricky. We will explore how to do it successfully.

Estimating housing prices
03:45

We don’t really have an idea on which feature contributes to the output and which doesn’t. It becomes critical to know that, in case we’ve to omit one. This video will help you compute their relative importance.

Computing relative importance of features
01:54

There might be some problems where the basic regression methods we’ve learned won’t help. One such problem is bicycle demand distribution. You will see how to solve that here.

Estimating bicycle demand distribution
04:35

Evaluating the accuracy of a classifier is an important step in the world of machine learning. We need to learn how to use the available data to get an idea as to how this model will perform in the real world. This is what we are going to learn in this section.

Preview 03:40

Despite the word regression being present in the name, logistic regression is actually used for classification purposes. Given a set of datapoints, our goal is to build a model that can draw linear boundaries between our classes. It extracts these boundaries by solving a set of equations derived from the training data.

Building a Logistic Regression Classifier
04:50

Bayes’ Theorem, which has been widely used in probability to determine the outcome of an event, enables us to classify the data in a smarter way. Let us use its concept to make our classifier more amazing.

Building a Naive Bayes’ Classifier
02:11

While working with data, splitting data correctly and logically is an important task. Let’s see how we can achieve this in Python.

Splitting the Dataset for Training and Testing
01:23

In order to make splitting of dataset more robust, we repeat the process of splitting with different subsets. If we just fine-tune it for a particular subset, we may end up over fitting the model, which may fail to perform well on unknown data. Cross validation ensures accuracy in such a situation.

Evaluating the Accuracy Using Cross-Validation
04:06

When we want to fine-tune our algorithms, we need to understand how the data gets misclassified before we make these changes. Some classes are worse than others, and the confusion matrix will help us understand this.

Visualizing the Confusion Matrix and Extracting the Performance Report
04:14

Let's see how we can apply classification techniques to a real-world problem. We will use a dataset that contains some details about cars, such as number of doors, boot space, maintenance costs, and so on, to analyze this problem.

Evaluating Cars based on Their Characteristics
05:12

Let’s see how the performance gets affected as we change the hyperparameters. This is where validation curves come into the picture. These curves help us understand how each hyperparameter influences the training score.

Extracting Validation Curves
02:49

Learning curves help us understand how the size of our training dataset influences the machine learning model. This is very useful when you have to deal with computational constraints. Let's go ahead and plot the learning curves by varying the size of our training dataset.

Extracting Learning Curves
01:37

Let’s see how we can build a classifier to estimate the income bracket of a person based on 14 attributes.

Extracting the Income Bracket
03:36

Building regressors and classifiers can be a bit tedious. Supervised learning models like SVM help us to a great extent. Let’s see how we can work with SVM.

Preview 04:23

There are various kernels used to build nonlinear classifiers. Let’s explore some of them and see how we can build a nonlinear classifier.

Building Nonlinear Classifier Using SVMs
01:47

A classifier often gets biased when there are more datapoints in a certain class. This can turn out to be a big problem. We need a mechanism to deal with this. Let’s explore how we can do that.

Tackling Class Imbalance
02:53

Let’s explore how we can train SVM to compute the output confidence level of a new datapoint when it is classified into a known category.

Extracting Confidence Measurements
02:36

It’s critical to evaluate the performance of a classifier. We need certain hyper parameters to do so. Let’s explore how to find those parameters.

Finding Optimal Hyper-Parameters
02:16

Now that we’ve learned the concepts of SVM thoroughly, let’s see if we can apply them to real-world problems.

Building an Event Predictor
03:45

We’ve already used SVM as a classifier to predict events. Let’s explore whether or not we can use it as a regressor for estimating traffic.

Estimating Traffic
02:39

The k-means algorithm is one of the most popular clustering algorithms, which is used to divide the input data into k subgroups using various attributes of the data. Let’s see how we can implement it in Python for Clustering data.

Preview 03:07

Vector quantization is popularly used in image compression, where we store each pixel using fewer bits than the original image to achieve compression.

Compressing an Image Using Vector Quantization
03:37

The Mean Shift is a powerful unsupervised learning algorithm that's used to cluster datapoints. It considers the distribution of datapoints as a probabilitydensity function and tries to find the modes in the feature space. Let’s see how to use it in Python.

Building a Mean Shift Clustering
02:35

Many a times, we need to segregate data and group them for the purpose of analysis and much more. We can achieve this in Python using theagglomerative clustering. Let’s see how we can do it.

Grouping Data Using Agglomerative Clustering
03:04

In supervised learning, we just compare the predicted values with the original labels to compute their accuracy. In unsupervised learning, we don't have any labels. Therefore, we need a way to measure the performance of our algorithms. Let’s see how we could evaluate their performance.

Evaluating the Performance of Clustering Algorithms
02:55

Wouldn't it be nice if there were a method that can just tell us the number of clusters in our data? This is where Density-Based Spatial Clustering of Applications with Noise (DBSCAN) comes into the picture. Let us see how we can work with it.

Automatically Estimating the Number of Clusters Using DBSCAN
03:34

How will we operate with the assumption that we don't know how many clusters there are. As we don't know the number of clusters, we can use an algorithm called Affinity Propagation to cluster. Let's see how we can use unsupervised learning for stock market analysis with this.

Finding Patterns in Stock Market Data
02:34

What could we do when wedon't have labeled data available all the time but it's important to segment the market so that people can target individual groups? Let’s learn to build a customer segmentation model for this situation.

Building a Customer Segmentation Model
02:21

One of the major parts of any machine learning system is the data processing pipeline. Instead of calling functions in a nested way, it's better to use the functional programming paradigm to build the combination. Let's take a look at how to combine functions to form a reusable function composition.

Preview 03:25

The scikit-learn library has provisions to build machine learning pipelines. We just need to specify the functions, and it will build a composed object that makes the data go through the whole pipeline. Let’s see how to build it in Python.

Building Machine Learning Pipelines
03:54

While working with the training dataset, we need to make a decision based on the number of nearest neighbors in it. This can be achieved with the help of the NearestNeighbor method in Python. Let’s see how to do it.

Finding the Nearest Neighbors
01:56

When we want to find the class to which an unknown point belongs, we find the k-nearest neighbors and take a majority vote. Let's take a look at how to construct this.

Constructing a k-nearest Neighbors Classifier
04:18

A good thing about the k-nearest neighbors algorithm is that it can also be used as a regessor. Let’s see how to do this!

Constructing a k-nearest Neighbors Regressor
02:43

In order to find users in the database who are similar to a given user we need to define a similarity metric. Euclidean distance score is one such metric that we can use to compute the distance between data points. Let’s look at this in more detail in this video.

Computing the Euclidean Distance Score
02:08

The Euclidean distance score is a good metric, but it has some shortcomings. Hence, Pearson correlation score is frequently used in recommendation engines. Let's see how to compute it.

Computing the Pearson Correlation Score
01:55

One of the most important tasks in building a recommendation engine is finding users that are similar. Let's see how to do this in this video.

Finding Similar Users in a Dataset
01:35

Now that we’ve built all the different parts of a recommendation engine, we are ready to generate movie recommendations. Let’s see how to do that in this video.

Generating Movie Recommendations
02:34

With tokenization we can define our own conditions to divide the input text into meaningful tokens. This gives us the solution for dividing a chunk of text into words or into sentences. Let's take a look at how to do this.

Preview 03:00

During text analysis, it's useful to extract the base form of the words to extract some statistics to analyze the overall text. This can be achieved with stemming, which uses a heuristic process to cut off the ends of words. Let's see how to do this in Python.

Stemming Text Data
02:22

Sometimes the base words that we obtained using stemmers don't really make sense. Lemmatization solves this problem by doing things using a vocabulary and morphological analysis of words and removes inflectional word endings. Let's take a look at how to do this in this video.

Converting Text to Its Base Form Using Lemmatization
02:11

When you deal with a really large text document, you need to divide it into chunks for further analysis. In this video, we will divide the input text into a number of pieces, where each piece has a fixed number of words.

Dividing Text Using Chunking
02:03

When we deal with text documents that contain millions of words, we need to convert them into some kind of numeric representation so as to make them usable for machine learning algorithms. A bag-of- words model is what helps us achieve this task quite easily.

Building a Bag-of-Words Model
02:58

The goal of text classification is to categorize text documents into different classes. This is an extremely important analysis technique in NLP. Let us see how we can build a text classifier for this purpose.

Building a Text Classifier
04:43

Identifying the gender of a name is an interesting task in NLP. Also gender recognition is a part of many artificial intelligence technologies. Let us see how to identify gender in Python.

Identifying the Gender
02:17

How could we discover the feelings or sentiments of different people about a particular topic? This video helps us to analyze that.

Analyzing the Sentiment of a Sentence
03:09

With topic modeling, we can uncover some hidden thematic structure in a collection of documents. This will help us in organizing our documents in a better way so that we can use them for analysis. Let’s see how we can do it!

Identifying Patterns in Text Using Topic Modelling
04:52

Reading an audio file and visualizing the signal is a good starting point that gives us a good understanding of the basic structure of audio signals. So let us see in this video how we could do it!

Preview 02:34

Audio signals consist of a complex mixture of sine waves of different frequencies, amplitudes and phases. There is a lot of information that is hidden in the frequency content of an audio signal. So it’s necessary to transform the audio signal into a frequency domain. Let’s see how to do this.

Transforming Audio Signals into the Frequency Domain
02:09

We can use NumPy to generate audio signals. As we know, audio signals are complex mixtures of sinusoids. Let’s see how we can generate audio signals with custom parameters.

Generating Audio Signals with Custom Parameters
01:45

Music has been explored since centuries and technology has set new horizons to play with it. We can also create music notes in Python. Let’s see how we can do this.

Synthesizing Music
02:10

When we deal with signals and we want to use them as input data and perform analysis, we need to convert them into frequency domain. So, let’s get hands-on with it!

Extracting Frequency Domain Features
02:06

A hidden Markov Model represents probability distributions over sequences of observations. It allows you to find the hidden states so that you can model the signal. Let us explore how we can use it to perform speech recognition.

Building Hidden Markov Models
02:19

This video will walk you through building a speech recognizer by using the audio files in a database. We will use seven different words, where each word has 15 audio files. Let’s go ahead and do it!

Building a Speech Recognizer
03:12

Let’s understand how to convert a sequence of observations into time series data and visualize it. We will use a library called pandas to analyze time series data. At the end of this video, you will be able to transform data into the time series format.

Preview 03:07

Extracting information from various intervals in time series data and using dates to handle subsets of our data are important tasks in data mining. Let’s see how we can slice time series data using Python.

Slicing Time Series Data
01:31

You can filter the data in many different ways. The pandas library allows you to operate on time series data in any way that you want. Let's see how to operate on time series data.

Operating on Time Series Data
01:42

One of the main reasons that we want to analyze time series data is to extract interesting statistics from it. This provides a lot of information regarding the nature of the data. Let’s see how to extract these stats.

Extracting Statistics from Time Series
02:29

Hidden Markov Models are really powerful when it comes to sequential data analysis. They are used extensively in finance, speech analysis, weather forecasting, sequencing of words, and so on. We are often interested in uncovering hidden patterns that appear over time. Let’s see how we can use it.

Building Hidden Markov Models for Sequential Data
04:15

The Conditional Random Fields (CRFs) are probabilistic models used to analyze structured data and also to label and segment sequential data. Let us see how we can use it to work on our input dataset!

Building Conditional Random Fields for Sequential Text Data
04:27

This video will get you hands-on with analyzing stock market data and understanding the fluctuations in the stocks of different companies. So let’s see how to do this!

Analyzing Stock Market Data with Hidden Markov Models
02:25

OpenCV is the world's most popular library for computer vision. It enables us to analyze images and do a lot of stuff with it. Let’s see how to operate it!

Preview 03:07

When working with images, it is essential to detect the edges to process the image and perform different operations with it. Let’s see how to detect edges of the input image in Python.

Detecting Edges
02:47

The human eye likes contrast! This is the reason that almost all camera systems use histogram equalization to make images look nice. This video will walk you through the use of histogram equalization in Pyhton.

Histogram Equalization
02:30

One of the essential steps in image analysis is to identify and extract the salient features for the purpose of computer vision. This can be achieved with a corner detection technique and SIFT feature point in Python. This video will enable you to achieve this goal!

Detecting Corners and SIFT Feature Points
03:46

When we build object recognition systems, we may want to use a different feature detector before we extract features using SIFT; that will give us the flexibility to cascade different blocks to get the best possible performance. Let’s see how to do it with Star feature detector.

Building a Star Feature Detector
01:34

Have you ever wondered how you could build image signatures? If yes, this video will take you through creating features by using visual codebook, which will enable you to achieve this goal. So, let’s dive in and watch it!

Creating Features Using Visual Codebook and Vector Quantization
04:10

We can construct a bunch of decision trees that are based on our image signatures, and then train the forest to make the right decision. Extremely Random Forests (ERFs) are used extensively for this purpose. Let’s dive in and see how to do it!

Training an Image Classifier Using Extremely Random Forests
02:30

While dealing with images, we tend to tackle problems with the contents of unknown images. This video will enable you to build an object recognizer which allows you to recognize the content of unknown images. So, let’s see it!

Building an object recognizer
01:53

Webcams are widely used for real-time communications and for biometric data analysis. This video will walk you through capturing and processing video from your webcam.

Preview 01:58

Haar cascade extracts a large number of simple features from the image at multiple scales. The simple features are basically edge, line, and rectangle features that are very easy to compute. It is then trained by creating a cascade of simple classifiers. Let’s see how we can detect a face with it!

Building a Face Detector using Haar Cascades
02:40

The Haar cascades method can be extended to detect all types of objects. Let's see how to use it to detect the eyes and nose in the input video.

Building Eye and Nose Detectors
01:54

Principal Components Analysis (PCA) is a dimensionality reduction technique that's used very frequently in computer vision and machine learning. It’s used to reduce the dimensionality of the data before we can train a system. This video will take you through the use of PCA.

Performing Principal Component Analysis
02:17

What if you need to reduce the number of dimensions in unorganized data? PCA, which we used in the last video, is inefficient in such situations. Let us see how we can tackle this situation.

Performing Kernel Principal Component Analysis
02:02

When we work with data or signals, they are generally received in a raw form. Or rather we can say they are a mixture of some unwanted stuff. It is essential for us to segregate them, so as to work on these signals. This video will enable you to achieve this goal.

Performing Blind Source Separation
02:16

We are now finally ready to build a face recognizer! Let’s see how to do it!

Building a Face Recognizer Using a Local Binary Patterns Histogram
04:14

Let’s start our neural network adventure with a perceptron, which is a single neuron that performs all the computations.

Preview 02:40

Now that we know how to create a perceptron, let's create a single-layer neural network which will consist of multiple neurons in a single layer.

Building a Single-Layer Neural Network
01:37

Let’s build a deep neural network, which will have multiple layers. There will be some hidden layers between the input and output layers. So, let us explore it.

Building a deep neural network
02:18

Let us see how we can use vector quantization in machine learning and computer vision.

Creating a Vector Quantizer
01:40

This video will walk you through analyzing sequential and time series data and enable you to extend generic models for them.

Building a Recurrent Neural Network for Sequential Data Analysis
02:23

Let us look at how to use neural networks to perform optical character recognition to identify handwritten characters in images.

Visualizing the Characters in an Optical Character Recognition Database
01:48

Let's build a neural-network-based optical character recognition system.

Building an Optical Character Recognizer Using Neural Networks
02:28

3D visualization is very important in data representation. So we need to learn the simple yet effective method of plotting 3D plots.

Preview 02:42

You are going to learn to plot bubble plots in this video.

Plotting Bubble Plots
01:16

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

Animating Bubble Plots
01:56

When there are distribution tables and various labels, pie charts are handy to express data.

Drawing Pie Charts
01:33

To keep a track of data with respect to time, we need to plot date-formatted time series data.

Plotting Date-Formatted Time Series Data
01:33

When we need to compare data of two different entities, we need to plot histograms. This video is going to help you do that.

Plotting Histograms
01:04

Heat maps are useful when data in two groups is associated point by point.

Visualizing Heat Maps
01:15

When we visualize real-time signals, it becomes imperative to animate the dynamic signals so that they are updated continuously. This video will help you do that.

Animating Dynamic Signals
02:06
+
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
About the Instructor
Packt Publishing
3.9 Average rating
7,282 Reviews
51,860 Students
616 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.