Book Image

Machine Learning with PyTorch and Scikit-Learn

By : Sebastian Raschka, Yuxi (Hayden) Liu, Vahid Mirjalili

5 (7)

Book Image

Machine Learning with PyTorch and Scikit-Learn

5 (7)

By: Sebastian Raschka, Yuxi (Hayden) Liu, Vahid Mirjalili

Overview of this book

Machine Learning with PyTorch and Scikit-Learn is a comprehensive guide to machine learning and deep learning with PyTorch. It acts as both a step-by-step tutorial and a reference you'll keep coming back to as you build your machine learning systems. Packed with clear explanations, visualizations, and examples, the book covers all the essential machine learning techniques in depth. While some books teach you only to follow instructions, with this machine learning book, we teach the principles allowing you to build models and applications for yourself. Why PyTorch? PyTorch is the Pythonic way to learn machine learning, making it easier to learn and simpler to code with. This book explains the essential parts of PyTorch and how to create models using popular libraries, such as PyTorch Lightning and PyTorch Geometric. You will also learn about generative adversarial networks (GANs) for generating new data and training intelligent agents with reinforcement learning. Finally, this new edition is expanded to cover the latest trends in deep learning, including graph neural networks and large-scale transformers used for natural language processing (NLP). This PyTorch book is your companion to machine learning with Python, whether you're a Python developer new to machine learning or want to deepen your knowledge of the latest developments.

Preface

Who this book is for

What this book covers

To get the most out of this book

Share your thoughts

Free Chapter

Giving Computers the Ability to Learn from Data

Giving Computers the Ability to Learn from Data

Building intelligent machines to transform data into knowledge

The three different types of machine learning

Introduction to the basic terminology and notations

A roadmap for building machine learning systems

Using Python for machine learning

Training Simple Machine Learning Algorithms for Classification

Training Simple Machine Learning Algorithms for Classification

Artificial neurons – a brief glimpse into the early history of machine learning

Implementing a perceptron learning algorithm in Python

Adaptive linear neurons and the convergence of learning

A Tour of Machine Learning Classifiers Using Scikit-Learn

A Tour of Machine Learning Classifiers Using Scikit-Learn

Choosing a classification algorithm

First steps with scikit-learn – training a perceptron

Modeling class probabilities via logistic regression

Maximum margin classification with support vector machines

Solving nonlinear problems using a kernel SVM

Decision tree learning

K-nearest neighbors – a lazy learning algorithm

Building Good Training Datasets – Data Preprocessing

Building Good Training Datasets – Data Preprocessing

Dealing with missing data

Handling categorical data

Partitioning a dataset into separate training and test datasets

Bringing features onto the same scale

Selecting meaningful features

Assessing feature importance with random forests

Compressing Data via Dimensionality Reduction

Compressing Data via Dimensionality Reduction

Unsupervised dimensionality reduction via principal component analysis

Supervised data compression via linear discriminant analysis

Nonlinear dimensionality reduction and visualization

Learning Best Practices for Model Evaluation and Hyperparameter Tuning

Learning Best Practices for Model Evaluation and Hyperparameter Tuning

Streamlining workflows with pipelines

Using k-fold cross-validation to assess model performance

Debugging algorithms with learning and validation curves

Fine-tuning machine learning models via grid search

Looking at different performance evaluation metrics

Combining Different Models for Ensemble Learning

Combining Different Models for Ensemble Learning

Learning with ensembles

Combining classifiers via majority vote

Bagging – building an ensemble of classifiers from bootstrap samples

Leveraging weak learners via adaptive boosting

Gradient boosting – training an ensemble based on loss gradients

Applying Machine Learning to Sentiment Analysis

Applying Machine Learning to Sentiment Analysis

Preparing the IMDb movie review data for text processing

Introducing the bag-of-words model

Training a logistic regression model for document classification

Working with bigger data – online algorithms and out-of-core learning

Topic modeling with latent Dirichlet allocation

Predicting Continuous Target Variables with Regression Analysis

Predicting Continuous Target Variables with Regression Analysis

Introducing linear regression

Exploring the Ames Housing dataset

Implementing an ordinary least squares linear regression model

Fitting a robust regression model using RANSAC

Evaluating the performance of linear regression models

Using regularized methods for regression

Turning a linear regression model into a curve – polynomial regression

Dealing with nonlinear relationships using random forests

Working with Unlabeled Data – Clustering Analysis

Working with Unlabeled Data – Clustering Analysis

Grouping objects by similarity using k-means

Organizing clusters as a hierarchical tree

Locating regions of high density via DBSCAN

Implementing a Multilayer Artificial Neural Network from Scratch

Implementing a Multilayer Artificial Neural Network from Scratch

Modeling complex functions with artificial neural networks

Classifying handwritten digits

Training an artificial neural network

About convergence in neural networks

A few last words about the neural network implementation

Parallelizing Neural Network Training with PyTorch

Parallelizing Neural Network Training with PyTorch

PyTorch and training performance

First steps with PyTorch

Building input pipelines in PyTorch

Building an NN model in PyTorch

Choosing activation functions for multilayer neural networks

Going Deeper – The Mechanics of PyTorch

Going Deeper – The Mechanics of PyTorch

The key features of PyTorch

PyTorch’s computation graphs

PyTorch tensor objects for storing and updating model parameters

Computing gradients via automatic differentiation

Simplifying implementations of common architectures via the torch.nn module

Project one – predicting the fuel efficiency of a car

Project two – classifying MNIST handwritten digits

Higher-level PyTorch APIs: a short introduction to PyTorch-Lightning

Classifying Images with Deep Convolutional Neural Networks

Classifying Images with Deep Convolutional Neural Networks

The building blocks of CNNs

Putting everything together – implementing a CNN

Implementing a deep CNN using PyTorch

Smile classification from face images using a CNN

Modeling Sequential Data Using Recurrent Neural Networks

Modeling Sequential Data Using Recurrent Neural Networks

Introducing sequential data

RNNs for modeling sequences

Implementing RNNs for sequence modeling in PyTorch

Transformers – Improving Natural Language Processing with Attention Mechanisms

Transformers – Improving Natural Language Processing with Attention Mechanisms

Adding an attention mechanism to RNNs

Introducing the self-attention mechanism

Attention is all we need: introducing the original transformer architecture

Building large-scale language models by leveraging unlabeled data

Fine-tuning a BERT model in PyTorch

Generative Adversarial Networks for Synthesizing New Data

Generative Adversarial Networks for Synthesizing New Data

Introducing generative adversarial networks

Implementing a GAN from scratch

Improving the quality of synthesized images using a convolutional and Wasserstein GAN

Other GAN applications

Graph Neural Networks for Capturing Dependencies in Graph Structured Data

Graph Neural Networks for Capturing Dependencies in Graph Structured Data

Introduction to graph data

Understanding graph convolutions

Implementing a GNN in PyTorch from scratch

Implementing a GNN using the PyTorch Geometric library

Other GNN layers and recent developments

Reinforcement Learning for Decision Making in Complex Environments

Reinforcement Learning for Decision Making in Complex Environments

Introduction – learning from experience

The theoretical foundations of RL

Reinforcement learning algorithms

Implementing our first RL algorithm

A glance at deep Q-learning

Chapter and book summary

Other Books You May Enjoy

Other Books You May Enjoy

Index

Customer Reviews

5 (7)

5 star

100%

4 star

0

3 star

0

2 star

0

1 star

0

PyTorch’s computation graphs

PyTorch performs its computations based on a directed acyclic graph (DAG). In this section, we will see how these graphs can be defined for a simple arithmetic computation. Then, we will see the dynamic graph paradigm, as well as how the graph is created on the fly in PyTorch.

Understanding computation graphs

PyTorch relies on building a computation graph at its core, and it uses this computation graph to derive relationships between tensors from the input all the way to the output. Let’s say that we have rank 0 (scalar) tensors a, b, and c and we want to evaluate z = 2 × (a – b) + c.

This evaluation can be represented as a computation graph, as shown in Figure 13.1:

Figure 13.1: How a computation graph works

As you can see, the computation graph is simply a network of nodes. Each node resembles an operation, which applies a function to its input tensor or tensors...