Python Machine Learning Cookbook - Second Edition

By : Giuseppe Ciaburro, Prateek Joshi

Python Machine Learning Cookbook - Second Edition

By: Giuseppe Ciaburro, Prateek Joshi

Overview of this book

This eagerly anticipated second edition of the popular Python Machine Learning Cookbook will enable you to adopt a fresh approach to dealing with real-world machine learning and deep learning tasks. With the help of over 100 recipes, you will learn to build powerful machine learning applications using modern libraries from the Python ecosystem. The book will also guide you on how to implement various machine learning algorithms for classification, clustering, and recommendation engines, using a recipe-based approach. With emphasis on practical solutions, dedicated sections in the book will help you to apply supervised and unsupervised learning techniques to real-world problems. Toward the concluding chapters, you will get to grips with recipes that teach you advanced techniques including reinforcement learning, deep neural networks, and automated machine learning. By the end of this book, you will be equipped with the skills you need to apply machine learning techniques and leverage the full capabilities of the Python ecosystem through real-world examples.

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

Free Chapter

The Realm of Supervised Learning

Technical requirements

Introduction

Array creation in Python

Data preprocessing using mean removal

Building a linear regressor

Computing regression accuracy

Achieving model persistence

Building a ridge regressor

Building a polynomial regressor

Estimating housing prices

Computing the relative importance of features

Estimating bicycle demand distribution

Constructing a Classifier

Technical requirements

Introduction

Building a simple classifier

Building a logistic regression classifier

Building a Naive Bayes classifier

Splitting a dataset for training and testing

Evaluating accuracy using cross-validation metrics

Visualizing a confusion matrix

Extracting a performance report

Evaluating cars based on their characteristics

Extracting validation curves

Extracting learning curves

Estimating the income bracket

Predicting the quality of wine

Predictive Modeling

Technical requirements

Introduction

Building a linear classifier using SVMs

Building a nonlinear classifier using SVMs

Tackling class imbalance

Extracting confidence measurements

Finding optimal hyperparameters

Building an event predictor

Estimating traffic

Simplifying machine learning workflow using TensorFlow

Implementing a stacking method

Clustering with Unsupervised Learning

Technical requirements

Introduction

Clustering data using the k-means algorithm

Compressing an image using vector quantization

Grouping data using agglomerative clustering

Evaluating the performance of clustering algorithms

Estimating the number of clusters using the DBSCAN algorithm

Finding patterns in stock market data

Building a customer segmentation model

Using autoencoders to reconstruct handwritten digit images

Visualizing Data

Technical requirements

An introduction to data visualization

Plotting three-dimensional scatter plots

Plotting bubble plots

Animating bubble plots

Drawing pie charts

Plotting date-formatted time series data

Plotting histograms

Visualizing heat maps

Animating dynamic signals

Working with the Seaborn library

Building Recommendation Engines

Technical requirements

Introducing the recommendation engine

Building function compositions for data processing

Building machine learning pipelines

Finding the nearest neighbors

Constructing a k-nearest neighbors classifier

Constructing a k-nearest neighbors regressor

Computing the Euclidean distance score

Computing the Pearson correlation score

Finding similar users in the dataset

Generating movie recommendations

Implementing ranking algorithms

Building a filtering model using TensorFlow

Analyzing Text Data

Technical requirements

Introduction

Preprocessing data using tokenization

Stemming text data

Converting text to its base form using lemmatization

Dividing text using chunking

Building a bag-of-words model

Building a text classifier

Identifying the gender of a name

Analyzing the sentiment of a sentence

Identifying patterns in text using topic modeling

Parts of speech tagging with spaCy

Word2Vec using gensim

Shallow learning for spam detection

Speech Recognition

Technical requirements

Introducing speech recognition

Reading and plotting audio data

Transforming audio signals into the frequency domain

Generating audio signals with custom parameters

Synthesizing music

Extracting frequency domain features

Building HMMs

Building a speech recognizer

Building a TTS system

Dissecting Time Series and Sequential Data

Technical requirements

Introducing time series

Transforming data into a time series format

Slicing time series data

Operating on time series data

Extracting statistics from time series data

Building HMMs for sequential data

Building CRFs for sequential text data

Analyzing stock market data

Using RNNs to predict time series data

Analyzing Image Content

Technical requirements

Introducing computer vision

Operating on images using OpenCV-Python

Detecting edges

Histogram equalization

Detecting corners

Detecting SIFT feature points

Building a Star feature detector

Creating features using Visual Codebook and vector quantization

Training an image classifier using Extremely Random Forests

Building an object recognizer

Using Light GBM for image classification

Biometric Face Recognition

Technical requirements

Introduction

Capturing and processing video from a webcam

Building a face detector using Haar cascades

Building eye and nose detectors

Performing principal component analysis

Performing kernel principal component analysis

Performing blind source separation

Building a face recognizer using a local binary patterns histogram

Recognizing faces using the HOG-based model

Facial landmark recognition

User authentication by face recognition

Reinforcement Learning Techniques

Technical requirements

Introduction

Weather forecasting with MDP

Optimizing a financial portfolio using DP

Finding the shortest path

Deciding the discount factor using Q-learning

Implementing the deep Q-learning algorithm

Developing an AI-based dynamic modeling system

Deep reinforcement learning with double Q-learning

Deep Q-network algorithm with dueling Q-learning

Deep Neural Networks

Technical requirements

Introduction

Building a perceptron

Building a single layer neural network

Building a deep neural network

Creating a vector quantizer

Building a recurrent neural network for sequential data analysis

Visualizing the characters in an OCR database

Building an optical character recognizer using neural networks

Implementing optimization algorithms in ANN

Unsupervised Representation Learning

Technical requirements

Introduction

Using denoising autoencoders to detect fraudulent transactions

Generating word embeddings using CBOW and skipgram representations

Visualizing the MNIST dataset using PCA and t-SNE

Using word embedding for Twitter sentiment analysis

Implementing LDA with scikit-learn

Using LDA to classify text documents

Preparing data for LDA

Automated Machine Learning and Transfer Learning

Technical requirements

Introduction

Working with Auto-WEKA

Using AutoML to generate machine learning pipelines with TPOT

Working with Auto-Keras

Working with auto-sklearn

Using MLBox for selection and leak detection

Convolutional neural networks with transfer learning

Transfer learning with pretrained image classifiers using ResNet-50

Transfer learning using feature extraction with the VGG16 model

Transfer learning with pretrained GloVe embedding

Unlocking Production Issues

Technical requirements

Introduction

Handling unstructured data

Deploying machine learning models

Keeping track of changes into production

Tracking accuracy to optimize model scaling

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Data preprocessing using mean removal

In the real world, we usually have to deal with a lot of raw data. This raw data is not readily ingestible by machine learning algorithms. To prepare data for machine learning, we have to preprocess it before we feed it into various algorithms. This is an intensive process that takes plenty of time, almost 80 percent of the entire data analysis process, in some scenarios. However, it is vital for the rest of the data analysis workflow, so it is necessary to learn the best practices of these techniques. Before sending our data to any machine learning algorithm, we need to cross check the quality and accuracy of the data. If we are unable to reach the data stored in Python correctly, or if we can't switch from raw data to something that can be analyzed, we cannot go ahead. Data can be preprocessed in many ways—standardization, scaling, normalization, binarization, and one-hot encoding are some examples of preprocessing techniques. We will address them through simple examples.

Getting ready

Standardization or mean removal is a technique that simply centers data by removing the average value of each characteristic, and then scales it by dividing non-constant characteristics by their standard deviation. It's usually beneficial to remove the mean from each feature so that it's centered on zero. This helps us remove bias from features. The formula used to achieve this is the following:

Standardization results in the rescaling of features, which in turn represents the properties of a standard normal distribution:

mean = 0
sd = 1

In this formula, mean is the mean and sd is the standard deviation from the mean.

How to do it...

Let's see how to preprocess data in Python:

Let's start by importing the library:

>> from sklearn import preprocessing

The sklearn library is a free software machine learning library for the Python programming language. It features various classification, regression, and clustering algorithms, including support vector machines (SVMs), random forests, gradient boosting, k-means, and DBSCAN, and is designed to interoperate with the Python numerical and scientific libraries, NumPy and SciPy.

To understand the outcome of mean removal on our data, we first visualize the mean and standard deviation of the vector we have just created:

>> print("Mean: ",data.mean(axis=0))
>> print("Standard Deviation: ",data.std(axis=0))

The mean() function returns the sample arithmetic mean of data, which can be a sequence or an iterator. The std() function returns the standard deviation, a measure of the distribution of the array elements. The axis parameter specifies the axis along which these functions are computed (0 for columns, and 1 for rows).

The following results are returned:

Mean: [ 1.33333333 1.93333333 -0.06666667 -2.53333333]
Standard Deviation: [1.24721913 2.44449495 1.60069429 3.30689515]

Now we can proceed with standardization:

>> data_standardized = preprocessing.scale(data)

The preprocessing.scale() function standardizes a dataset along any axis. This method centers the data on the mean and resizes the components in order to have a unit variance.

Now we recalculate the mean and standard deviation on the standardized data:

>> print("Mean standardized data: ",data_standardized.mean(axis=0))
>> print("Standard Deviation standardized data: ",data_standardized.std(axis=0))

The following results are returned:

Mean standardized data: [ 5.55111512e-17 -1.11022302e-16 -7.40148683e-17 -7.40148683e-17]
Standard Deviation standardized data: [1. 1. 1. 1.]

You can see that the mean is almost 0 and the standard deviation is 1.

How it works...

The sklearn.preprocessing package provides several common utility functions and transformer classes to modify the features available in a representation that best suits our needs. In this recipe, the scale() function has been used (z-score standardization). In summary, the z-score (also called the standard score) represents the number of standard deviations by which the value of an observation point or data is greater than the mean value of what is observed or measured. Values more than the mean have positive z-scores, while values less than the mean have negative z-scores. The z-score is a quantity without dimensions that is obtained by subtracting the population's mean from a single rough score and then dividing the difference by the standard deviation of the population.

There's more...

Standardization is particularly useful when we do not know the minimum and maximum for data distribution. In this case, it is not possible to use other forms of data transformation. As a result of the transformation, the normalized values do not have a minimum and a fixed maximum. Moreover, this technique is not influenced by the presence of outliers, or at least not the same as other methods.

Python Machine Learning Cookbook - Second Edition

By : Giuseppe Ciaburro, Prateek Joshi

Python Machine Learning Cookbook - Second Edition

By: Giuseppe Ciaburro, Prateek Joshi

Overview of this book

Related Content you might be interested in

Current Title:

Python Machine Learning Cookbook - Second Edition

Artificial Intelligence with Python

Artificial Intelligence with Python

Keras Reinforcement Learning Projects