**Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow: Concepts, Tools, and Techniques to Build Intelligent Systems 3rd Edition by Aurélien Géron, ISBN-13: 978-1098125974**

[PDF eBook eTextbook] – **Available Instantly**

- Publisher: O’Reilly Media; 3rd edition (November 8, 2022)
- Language: English
- 861 pages
- ISBN-10: 1098125975
- ISBN-13: 978-1098125974

Through a recent series of breakthroughs, * deep learning* has boosted the entire field of machine learning. Now, even programmers who know close to nothing about this technology can use simple, efficient tools to implement programs capable of learning from data. This bestselling book uses concrete examples, minimal theory, and production-ready

*frameworks (Scikit-Learn, Keras, and TensorFlow) to help you gain an intuitive understanding of the concepts and tools for building intelligent systems.*

**Python**With this updated third edition, author Aurélien Géron explores a range of techniques, starting with simple linear regression and progressing to deep neural networks. Numerous code examples and exercises throughout the book help you apply what you’ve learned. Programming experience is all you need to get started.

- Use Scikit-learn to track an example ML project end to end
- Explore several models, including support vector machines, decision trees, random forests, and ensemble methods
- Exploit unsupervised learning techniques such as dimensionality reduction, clustering, and anomaly detection
- Dive into neural net architectures, including convolutional nets, recurrent nets, generative adversarial networks, autoencoders, diffusion models, and transformers
- Use TensorFlow and Keras to build and train neural nets for computer vision, natural language processing, generative models, and deep reinforcement learning

**Table of Contents:**

Preface

The Machine Learning Tsunami

Machine Learning in Your Projects

Objective and Approach

Code Examples

Prerequisites

Roadmap

Changes Between the First and the Second Edition

Changes Between the Second and the Third Edition

Other Resources

Conventions Used in This Book

O’Reilly Online Learning

How to Contact Us

Acknowledgments

I. The Fundamentals of Machine Learning

1. The Machine Learning Landscape

What Is Machine Learning?

Why Use Machine Learning?

Examples of Applications

Types of Machine Learning Systems

Training Supervision

Batch Versus Online Learning

Instance-Based Versus Model-Based Learning

Main Challenges of Machine Learning

Insufficient Quantity of Training Data

Nonrepresentative Training Data

Poor-Quality Data

Irrelevant Features

Overfitting the Training Data

Underfitting the Training Data

Stepping Back

Testing and Validating

Hyperparameter Tuning and Model Selection

Data Mismatch

Exercises

2. End-to-End Machine Learning Project

Working with Real Data

Look at the Big Picture

Frame the Problem

Select a Performance Measure

Check the Assumptions

Get the Data

Running the Code Examples Using Google Colab

Saving Your Code Changes and Your Data

The Power and Danger of Interactivity

Book Code Versus Notebook Code

Download the Data

Take a Quick Look at the Data Structure

Create a Test Set

Explore and Visualize the Data to Gain Insights

Visualizing Geographical Data

Look for Correlations

Experiment with Attribute Combinations

Prepare the Data for Machine Learning Algorithms

Clean the Data

Handling Text and Categorical Attributes

Feature Scaling and Transformation

Custom Transformers

Transformation Pipelines

Select and Train a Model

Train and Evaluate on the Training Set

Better Evaluation Using Cross-Validation

Fine-Tune Your Model

Grid Search

Randomized Search

Ensemble Methods

Analyzing the Best Models and Their Errors

Evaluate Your System on the Test Set

Launch, Monitor, and Maintain Your System

Try It Out!

Exercises

3. Classification

MNIST

Training a Binary Classifier

Performance Measures

Measuring Accuracy Using Cross-Validation

Confusion Matrices

Precision and Recall

The Precision/Recall Trade-off

The ROC Curve

Multiclass Classification

Error Analysis

Multilabel Classification

Multioutput Classification

Exercises

4. Training Models

Linear Regression

The Normal Equation

Computational Complexity

Gradient Descent

Batch Gradient Descent

Stochastic Gradient Descent

Mini-Batch Gradient Descent

Polynomial Regression

Learning Curves

Regularized Linear Models

Ridge Regression

Lasso Regression

Elastic Net Regression

Early Stopping

Logistic Regression

Estimating Probabilities

Training and Cost Function

Decision Boundaries

Softmax Regression

Exercises

5. Support Vector Machines

Linear SVM Classification

Soft Margin Classification

Nonlinear SVM Classification

Polynomial Kernel

Similarity Features

Gaussian RBF Kernel

SVM Classes and Computational Complexity

SVM Regression

Under the Hood of Linear SVM Classifiers

The Dual Problem

Kernelized SVMs

Exercises

6. Decision Trees

Training and Visualizing a Decision Tree

Making Predictions

Estimating Class Probabilities

The CART Training Algorithm

Computational Complexity

Gini Impurity or Entropy?

Regularization Hyperparameters

Regression

Sensitivity to Axis Orientation

Decision Trees Have a High Variance

Exercises

7. Ensemble Learning and Random Forests

Voting Classifiers

Bagging and Pasting

Bagging and Pasting in Scikit-Learn

Out-of-Bag Evaluation

Random Patches and Random Subspaces

Random Forests

Extra-Trees

Feature Importance

Boosting

AdaBoost

Gradient Boosting

Histogram-Based Gradient Boosting

Stacking

Exercises

8. Dimensionality Reduction

The Curse of Dimensionality

Main Approaches for Dimensionality Reduction

Projection

Manifold Learning

PCA

Preserving the Variance

Principal Components

Projecting Down to d Dimensions

Using Scikit-Learn

Explained Variance Ratio

Choosing the Right Number of Dimensions

PCA for Compression

Randomized PCA

Incremental PCA

Random Projection

LLE

Other Dimensionality Reduction Techniques

Exercises

9. Unsupervised Learning Techniques

Clustering Algorithms: k-means and DBSCAN

k-means

Limits of k-means

Using Clustering for Image Segmentation

Using Clustering for Semi-Supervised Learning

DBSCAN

Other Clustering Algorithms

Gaussian Mixtures

Using Gaussian Mixtures for Anomaly Detection

Selecting the Number of Clusters

Bayesian Gaussian Mixture Models

Other Algorithms for Anomaly and Novelty Detection

Exercises

II. Neural Networks and Deep Learning

10. Introduction to Artificial Neural Networks with Keras

From Biological to Artificial Neurons

Biological Neurons

Logical Computations with Neurons

The Perceptron

The Multilayer Perceptron and Backpropagation

Regression MLPs

Classification MLPs

Implementing MLPs with Keras

Building an Image Classifier Using the Sequential API

Building a Regression MLP Using the Sequential API

Building Complex Models Using the Functional API

Using the Subclassing API to Build Dynamic Models

Saving and Restoring a Model

Using Callbacks

Using TensorBoard for Visualization

Fine-Tuning Neural Network Hyperparameters

Number of Hidden Layers

Number of Neurons per Hidden Layer

Learning Rate, Batch Size, and Other Hyperparameters

Exercises

11. Training Deep Neural Networks

The Vanishing/Exploding Gradients Problems

Glorot and He Initialization

Better Activation Functions

Batch Normalization

Gradient Clipping

Reusing Pretrained Layers

Transfer Learning with Keras

Unsupervised Pretraining

Pretraining on an Auxiliary Task

Faster Optimizers

Momentum

Nesterov Accelerated Gradient

AdaGrad

RMSProp

Adam

AdaMax

Nadam

AdamW

Learning Rate Scheduling

Avoiding Overfitting Through Regularization

ℓ1 and ℓ2 Regularization

Dropout

Monte Carlo (MC) Dropout

Max-Norm Regularization

Summary and Practical Guidelines

Exercises

12. Custom Models and Training with TensorFlow

A Quick Tour of TensorFlow

Using TensorFlow like NumPy

Tensors and Operations

Tensors and NumPy

Type Conversions

Variables

Other Data Structures

Customizing Models and Training Algorithms

Custom Loss Functions

Saving and Loading Models That Contain Custom Components

Custom Activation Functions, Initializers, Regularizers, and Constraints

Custom Metrics

Custom Layers

Custom Models

Losses and Metrics Based on Model Internals

**Computing** Gradients Using Autodiff

Custom Training Loops

TensorFlow Functions and Graphs

AutoGraph and Tracing

TF Function Rules

Exercises

13. Loading and Preprocessing Data with TensorFlow

The tf.data API

Chaining Transformations

Shuffling the Data

Interleaving Lines from Multiple Files

Preprocessing the Data

Putting Everything Together

Prefetching

Using the Dataset with Keras

The TFRecord Format

Compressed TFRecord Files

A Brief Introduction to Protocol Buffers

TensorFlow Protobufs

Loading and Parsing Examples

Handling Lists of Lists Using the SequenceExample Protobuf

Keras Preprocessing Layers

The Normalization Layer

The Discretization Layer

The CategoryEncoding Layer

The StringLookup Layer

The Hashing Layer

Encoding Categorical Features Using Embeddings

Text Preprocessing

Using Pretrained Language Model Components

Image Preprocessing Layers

The TensorFlow Datasets Project

Exercises

14. Deep Computer Vision Using Convolutional Neural Networks

The Architecture of the Visual Cortex

Convolutional Layers

Filters

Stacking Multiple Feature Maps

Implementing Convolutional Layers with Keras

Memory Requirements

Pooling Layers

Implementing Pooling Layers with Keras

CNN Architectures

LeNet-5

AlexNet

GoogLeNet

VGGNet

ResNet

Xception

SENet

Other Noteworthy Architectures

Choosing the Right CNN Architecture

Implementing a ResNet-34 CNN Using Keras

Using Pretrained Models from Keras

Pretrained Models for Transfer Learning

Classification and Localization

Object Detection

Fully Convolutional Networks

You Only Look Once

Object Tracking

Semantic Segmentation

Exercises

15. Processing Sequences Using RNNs and CNNs

Recurrent Neurons and Layers

Memory Cells

Input and Output Sequences

Training RNNs

Forecasting a Time Series

The ARMA Model Family

Preparing the Data for Machine Learning Models

Forecasting Using a Linear Model

Forecasting Using a Simple RNN

Forecasting Using a Deep RNN

Forecasting Multivariate Time Series

Forecasting Several Time Steps Ahead

Forecasting Using a Sequence-to-Sequence Model

Handling Long Sequences

Fighting the Unstable Gradients Problem

Tackling the Short-Term Memory Problem

Exercises

16. Natural Language Processing with RNNs and Attention

Generating Shakespearean Text Using a Character RNN

Creating the Training Dataset

Building and Training the Char-RNN Model

Generating Fake Shakespearean Text

Stateful RNN

Sentiment Analysis

Masking

Reusing Pretrained Embeddings and Language Models

An Encoder–Decoder Network for Neural Machine Translation

Bidirectional RNNs

Beam Search

Attention Mechanisms

Attention Is All You Need: The Original Transformer Architecture

An Avalanche of Transformer Models

Vision Transformers

Hugging Face’s Transformers Library

Exercises

17. Autoencoders, GANs, and Diffusion Models

Efficient Data Representations

Performing PCA with an Undercomplete Linear Autoencoder

Stacked Autoencoders

Implementing a Stacked Autoencoder Using Keras

Visualizing the Reconstructions

Visualizing the Fashion MNIST Dataset

Unsupervised Pretraining Using Stacked Autoencoders

Tying Weights

Training One Autoencoder at a Time

Convolutional Autoencoders

Denoising Autoencoders

Sparse Autoencoders

Variational Autoencoders

Generating Fashion MNIST Images

Generative Adversarial Networks

The Difficulties of Training GANs

Deep Convolutional GANs

Progressive Growing of GANs

StyleGANs

Diffusion Models

Exercises

18. Reinforcement Learning

Learning to Optimize Rewards

Policy Search

Introduction to OpenAI Gym

Neural Network Policies

Evaluating Actions: The Credit Assignment Problem

Policy Gradients

Markov Decision Processes

Temporal Difference Learning

Q-Learning

Exploration Policies

Approximate Q-Learning and Deep Q-Learning

Implementing Deep Q-Learning

Deep Q-Learning Variants

Fixed Q-value Targets

Double DQN

Prioritized Experience Replay

Dueling DQN

Overview of Some Popular RL Algorithms

Exercises

19. Training and Deploying TensorFlow Models at Scale

Serving a TensorFlow Model

Using TensorFlow Serving

Creating a Prediction Service on Vertex AI

Running Batch Prediction Jobs on Vertex AI

Deploying a Model to a Mobile or Embedded Device

Running a Model in a Web Page

Using GPUs to Speed Up Computations

Getting Your Own GPU

Managing the GPU RAM

Placing Operations and Variables on Devices

Parallel Execution Across Multiple Devices

Training Models Across Multiple Devices

Model Parallelism

Data Parallelism

Training at Scale Using the Distribution Strategies API

Training a Model on a TensorFlow Cluster

Running Large Training Jobs on Vertex AI

Hyperparameter Tuning on Vertex AI

Exercises

Thank You!

A. Machine Learning Project Checklist

Frame the Problem and Look at the Big Picture

Get the Data

Explore the Data

Prepare the Data

Shortlist Promising Models

Fine-Tune the System

Present Your Solution

Launch!

B. Autodiff

Manual Differentiation

Finite Difference Approximation

Forward-Mode Autodiff

Reverse-Mode Autodiff

C. Special Data Structures

Strings

Ragged Tensors

Sparse Tensors

Tensor Arrays

Sets

Queues

D. TensorFlow Graphs

TF Functions and Concrete Functions

Exploring Function Definitions and Graphs

A Closer Look at Tracing

Using AutoGraph to Capture Control Flow

Handling Variables and Other Resources in TF Functions

Using TF Functions with Keras (or Not)

Index

About the Author

* Aurélien Géron* is a Machine Learning consultant. A former Googler, he led the YouTube video classification team from 2013 to 2016. He was also a founder and CTO of Wifirst from 2002 to 2012, a leading Wireless ISP in France, and a founder and CTO of Polyconseil in 2001, the firm that now manages the electric car sharing service Autolib’.

Before this he worked as an engineer in a variety of domains: finance (JP Morgan and Société Générale), defense (Canada’s DOD), and healthcare (blood transfusion). He published a few technical books (on C++, WiFi, and Internet architectures), and was a Computer Science lecturer in a French engineering school.

A few fun facts: he taught his 3 children to count in binary with their fingers (up to 1023), he studied microbiology and evolutionary genetics before going into software engineering, and his parachute didn’t open on the 2nd jump.

**What makes us different?**

• Instant Download

• Always Competitive Pricing

• 100% Privacy

• FREE Sample Available

• 24-7 LIVE Customer Support

## Reviews

There are no reviews yet.