Home > Store

Machine Learning with scikit-learn LiveLessons (Video Training)

Machine Learning with scikit-learn LiveLessons (Video Training)

Your browser doesn't support playback of this video. Please download the file to view it.

Online Video

Register your product to gain access to bonus material or receive a coupon.

Description

  • Copyright 2019
  • Edition: 1st
  • Online Video
  • ISBN-10: 0-13-547430-2
  • ISBN-13: 978-0-13-547430-3

6+ Hours of Video Instruction

Learn the main concepts and techniques used in modern machine learning through numerous examples written in scikit-learn

"Good introduction and overview (without a deep-dive) of APIs of scikit-learn library with accompanying Jupyter notebook material. It’s good for grasping the structure of the techniques available in data science process." 5 out 5 stars.

- mazurkrzysztofk, O'Reilly Online Learning Reviewer


Overview


Machine Learning with scikit-learn LiveLessons is your guide to the scikit-learn library, which provides a wide range of algorithms in machine learning that are unified under a common and intuitive Python API. Most of the dozens of classes provided for various kinds of models share the large majority of the same calling interface. Quite often you can easily substitute one algorithm for another with very little or no change in your underlying code. This enables you to explore the problem space quickly and often to arrive at an optimal—or at least satisficing—approach to your problem domain or datasets.

The scikit-learn library is built on the foundations of the numeric Python stack. It uses NumPy for its fundamental data structures and optimized performance, and it plays well with pandas and matplotlib. It is free software under a BSD license. The great bulk of machine learning programming in Python is done with scikit-learn–at least outside the specialized domain of deep neural networks.

About the Instructor

David Mertz has been involved with the Python community for 20 years, with data science, (under various previous names) and with machine learning since way back when it was more likely to be called “artificial intelligence.” He was a director of the Python Software Foundation for six years and continues to serve on, or chair, a variety of PSF working groups.

He has also written quite a bit about Python: the column Charming Python for IBM developerWorks, for many years; Text Processing in Python (Addison-Wesley, 2003); and two short books for O’Reilly. He created the data science training program for Anaconda, Inc., and was a senior trainer for them.

Skill Level

  • Intermediate

Learn How To

  • Use various machine learning techniques
  • Explore a dataset
  • Perform various types of classification
  • Use regression, clustering, and hyperparameters
  • Use feature engineering and feature selection
  • Implement data pipelines
  • Develop robust train/test splits

Who Should Take This Course

  • Programmers and statisticians interested in using Python and the scikit-learn library to implement machine learning

Course Requirements

  • Programming experience

Table of Contents


Introduction

Lesson 1: What Is Machine Learning?

Lesson 2: Exploring a Dataset

Lesson 3: Classification

Lesson 4: Regression

Lesson 5: Clustering

Lesson 6: Hyperparameters

Lesson 7: Feature Engineering and Feature Selection

Lesson 8: Pipelines

Lesson 9: Robust Train/Test Splits

Summary


Lesson Descriptions

Lesson 1: What Is Machine Learning?

The first lesson addresses many of the essential concepts in machine learning. The main tasks that can be accomplished with ML are addressed. It then turns to issues of dimensionality, of feature engineering and selection, and of feature/variable types. Finally, the lesson delves into concerns practical in working with machine learning libraries and systems.

At the end of this lesson you have a broad understanding of all the main concepts used in machine learning.

Lesson 2: Exploring a Dataset

The second lesson covers preparation of a dataset for machine learning models. In the real world, data always arrives messy and flawed. Before you can get to applying machine learning techniques, it is almost always necessary to massage, filter, and generally to clean up your data.

Exploration and cleaning of datasets typically utilizes Pandas, which is a rich library for exactly those tasks. This lesson does most of its work using that tool. Pandas is not a requirement for scikit-learn per se, but they play very well together.

At the end of this lesson you have an initial sense of how to get a “feel” for your data and are able to think about likely problems and anomalies within novel datasets. After many years of practice as a working data scientist, you will be highly skilled at these same judgements.

Lesson 3: Classification

One of the main techniques used within machine learning–specifically within what we call supervised machine learning–is classification. That is the subject matter of Lesson 3. As discussed in Lesson 1, classification is trying to match a collection of multiple features to a categorical target–that is, the prediction is that a newly observed item belongs to one of n known classes.

There are many algorithms for performing classification; a large number of them are available in scikit-learn. This lesson covers a number of different classifiers and some features of each are compared. This lesson provides a first exposure to the scikit-learn APIs, which are mostly similar across its numerous classes, both for classifiers and for other models and transformations.

At the end of this lesson you have a sense of the range of classifiers available and some context for choosing among them in your own datasets and for your own goals.

Lesson 4: Regression

Within supervised machine learning, the two basic types of models are classifiers and regressors. Both have precedent in standard statistics, but machine learning techniques go beyond the “closed form” mathematical techniques that precede them. The lesson includes a number of regressors, starting from the linear regression family that is common in general statistics.

This lesson also introduces some of the sample datasets that are bundled with scikit-learn, and that can often be a useful starting point for exploring techniques and coding styles.

By the end of this lesson, you have an understanding of most of the regression models available in scikit-learn.

Lesson 5: Clustering

As well as supervised learning–i.e., classification and regression, which have been covered in prior lessons–there are various models of unsupervised learning as well. When we do not have any a priori idea about what the target of an algorithm is, an approach we can still take is to look at how complex multi-dimensional features cluster into distinct categories. This is very common to find in datasets.

This lesson provides an overview of a number of clustering algorithms and uses them to create synthetic classifications of several datasets. It gives you some hands-on experience with the minor differences in the scikit-learn API needed to work in an unsupervised rather than supervised domain. For clustering, it is especially useful to try to visualize or explore the classifications produced by models since they do not necessarily have obvious names for the classes. Such visualization is explored in this lesson.

Lesson 6: Hyperparameters

Most of the models in scikit-learn–or indeed, in any other machine learning library–utilize what are called “hyperparameters” in the domain. This concept was explored in Lesson 1 but explored in more depth here.

When a model is trained, it gains configuration data, often called “parameters.” These are the data that define what it means for a model to be trained on one dataset versus another and are attached to the model object. However, almost all algorithms in machine learning also utilize hyperparameters to control exactly what variation of the basic algorithm is used (or cut-offs assumed), constants that are utilized in underlying formulae, or other algorithmic variations.  These hyperparameters are usually used in creating model instances and before any actual training is performed. In many cases, their values can dramatically change the effectiveness and success of a model.

It is often, even usually, difficult to judge in advance the best choice of hyperparameters. Therefore, performing what is called a “grid search” over the parametric space of hyperparameters is often desirable. Scikit-learn contains wrapper classes that both emulate the APIs of underlying models and provide easy access to the basic operation of a grid search.

Lesson 7: Feature Engineering and Feature Selection

Prior lessons approached choosing and training models using relatively naive feature sets drawn from the underlying datasets. However, when you need to work on problems with real-world complexity, often the features you are initially provided by a dataset are not powerful enough to achieve the model effectiveness you need.

Of course, some data simply does not contain the necessary intrinsic force. But most of the time it requires extra work to tease out the “features of the features” that are actually most useful for your purposes. These initial steps are called “feature engineering” and “feature selection.” The former involves constructing synthetic features based on the raw features you are given by various combinations of scaling them, combining them, handling outliers, or transforming the representation of features. The latter, feature selection, involves reducing the number of features you utilize, often subsequent to multiplying that number in feature engineering steps, to select only those that are most predictive. Sometimes feature selection is needed simply to make training a model computationally tractable.

Lesson 8: Pipelines

Prior lessons have illustrated a variety of techniques for preparing and transforming data and for selection of models and hyperparameters of models. Very often, when you have combined and refined these steps in a particular way relevant to your domain, you would like to be able to encapsulate those steps.

The scikit-learn abstraction and classes, called pipelines, enable this combination of steps while maintaining the same APIs that have now become familiar. There are a variety of components that you can combine using pipelines, but producing a combined object that follows the same API as those components is a very useful programming style, which this lesson covers.

Lesson 9: Robust Train/Test Splits

Earlier lessons utilized the simple train_test_split() function to divide data that was used in training models. This function is perfectly sufficient for exploratory purposes, but at a final stage when you are interested in more rigorous validation of models in preparation for production, you probably want to consider more robust train/test split strategies.

This lesson covers the numerous classes provided by scikit-learn for robust train/test splits.

  

About Pearson Video Training

Pearson publishes expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. These professional and personal technology videos feature world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, Pearson IT Certification, Prentice Hall, Sams, and Que Topics include: IT Certification, Network Security, Cisco Technology, Programming, Web Development, Mobile Development, and more.  Learn more about Pearson Video training at http://www.informit.com/video.

Updates

Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership