book

Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 2nd Edition

Name: Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 2nd Edition
Author: Aurélien Géron
ISBN: 9781492032649

by Aurélien Géron

September 2019

Intermediate to advanced

848 pages

24h 18m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Preface
The Machine Learning TsunamiMachine Learning in Your ProjectsObjective and ApproachPrerequisitesRoadmapChanges in the Second EditionOther ResourcesConventions Used in This BookCode ExamplesUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments
I. The Fundamentals of Machine Learning
1. The Machine Learning Landscape
What Is Machine Learning?Why Use Machine Learning?Examples of ApplicationsTypes of Machine Learning SystemsSupervised/Unsupervised LearningBatch and Online LearningInstance-Based Versus Model-Based LearningMain Challenges of Machine LearningInsufficient Quantity of Training DataNonrepresentative Training DataPoor-Quality DataIrrelevant FeaturesOverfitting the Training DataUnderfitting the Training DataStepping BackTesting and ValidatingHyperparameter Tuning and Model SelectionData MismatchExercises
2. End-to-End Machine Learning Project
Working with Real DataLook at the Big PictureFrame the ProblemSelect a Performance MeasureCheck the AssumptionsGet the DataCreate the WorkspaceDownload the DataTake a Quick Look at the Data StructureCreate a Test SetDiscover and Visualize the Data to Gain InsightsVisualizing Geographical DataLooking for CorrelationsExperimenting with Attribute CombinationsPrepare the Data for Machine Learning AlgorithmsData CleaningHandling Text and Categorical AttributesCustom TransformersFeature ScalingTransformation PipelinesSelect and Train a ModelTraining and Evaluating on the Training SetBetter Evaluation Using Cross-ValidationFine-Tune Your ModelGrid SearchRandomized SearchEnsemble MethodsAnalyze the Best Models and Their ErrorsEvaluate Your System on the Test SetLaunch, Monitor, and Maintain Your SystemTry It Out!Exercises
3. Classification
MNISTTraining a Binary ClassifierPerformance MeasuresMeasuring Accuracy Using Cross-ValidationConfusion MatrixPrecision and RecallPrecision/Recall Trade-offThe ROC CurveMulticlass ClassificationError AnalysisMultilabel ClassificationMultioutput ClassificationExercises
4. Training Models
Linear RegressionThe Normal EquationComputational ComplexityGradient DescentBatch Gradient DescentStochastic Gradient DescentMini-batch Gradient DescentPolynomial RegressionLearning CurvesRegularized Linear ModelsRidge RegressionLasso RegressionElastic NetEarly StoppingLogistic RegressionEstimating ProbabilitiesTraining and Cost FunctionDecision BoundariesSoftmax RegressionExercises
5. Support Vector Machines
Linear SVM ClassificationSoft Margin ClassificationNonlinear SVM ClassificationPolynomial KernelSimilarity FeaturesGaussian RBF KernelComputational ComplexitySVM RegressionUnder the HoodDecision Function and PredictionsTraining ObjectiveQuadratic ProgrammingThe Dual ProblemKernelized SVMsOnline SVMsExercises
6. Decision Trees
Training and Visualizing a Decision TreeMaking PredictionsEstimating Class ProbabilitiesThe CART Training AlgorithmComputational ComplexityGini Impurity or Entropy?Regularization HyperparametersRegressionInstabilityExercises
7. Ensemble Learning and Random Forests
Voting ClassifiersBagging and PastingBagging and Pasting in Scikit-LearnOut-of-Bag EvaluationRandom Patches and Random SubspacesRandom ForestsExtra-TreesFeature ImportanceBoostingAdaBoostGradient BoostingStackingExercises
8. Dimensionality Reduction
The Curse of DimensionalityMain Approaches for Dimensionality ReductionProjectionManifold LearningPCAPreserving the VariancePrincipal ComponentsProjecting Down to d DimensionsUsing Scikit-LearnExplained Variance RatioChoosing the Right Number of DimensionsPCA for CompressionRandomized PCAIncremental PCAKernel PCASelecting a Kernel and Tuning HyperparametersLLEOther Dimensionality Reduction TechniquesExercises

9. Unsupervised Learning Techniques
ClusteringK-MeansLimits of K-MeansUsing Clustering for Image SegmentationUsing Clustering for PreprocessingUsing Clustering for Semi-Supervised LearningDBSCANOther Clustering AlgorithmsGaussian MixturesAnomaly Detection Using Gaussian MixturesSelecting the Number of ClustersBayesian Gaussian Mixture ModelsOther Algorithms for Anomaly and Novelty DetectionExercises
II. Neural Networks and Deep Learning
10. Introduction to Artificial Neural Networks with Keras
From Biological to Artificial NeuronsBiological NeuronsLogical Computations with NeuronsThe PerceptronThe Multilayer Perceptron and BackpropagationRegression MLPsClassification MLPsImplementing MLPs with KerasInstalling TensorFlow 2Building an Image Classifier Using the Sequential APIBuilding a Regression MLP Using the Sequential APIBuilding Complex Models Using the Functional APIUsing the Subclassing API to Build Dynamic ModelsSaving and Restoring a ModelUsing CallbacksUsing TensorBoard for VisualizationFine-Tuning Neural Network HyperparametersNumber of Hidden LayersNumber of Neurons per Hidden LayerLearning Rate, Batch Size, and Other HyperparametersExercises
11. Training Deep Neural Networks
The Vanishing/Exploding Gradients ProblemsGlorot and He InitializationNonsaturating Activation FunctionsBatch NormalizationGradient ClippingReusing Pretrained LayersTransfer Learning with KerasUnsupervised PretrainingPretraining on an Auxiliary TaskFaster OptimizersMomentum OptimizationNesterov Accelerated GradientAdaGradRMSPropAdam and Nadam OptimizationLearning Rate SchedulingAvoiding Overfitting Through Regularizationℓ1 and ℓ2 RegularizationDropoutMonte Carlo (MC) DropoutMax-Norm RegularizationSummary and Practical GuidelinesExercises
12. Custom Models and Training with TensorFlow
A Quick Tour of TensorFlowUsing TensorFlow like NumPyTensors and OperationsTensors and NumPyType ConversionsVariablesOther Data StructuresCustomizing Models and Training AlgorithmsCustom Loss FunctionsSaving and Loading Models That Contain Custom ComponentsCustom Activation Functions, Initializers, Regularizers, and ConstraintsCustom MetricsCustom LayersCustom ModelsLosses and Metrics Based on Model InternalsComputing Gradients Using AutodiffCustom Training LoopsTensorFlow Functions and GraphsAutoGraph and TracingTF Function RulesExercises
13. Loading and Preprocessing Data with TensorFlow
The Data APIChaining TransformationsShuffling the DataPreprocessing the DataPutting Everything TogetherPrefetchingUsing the Dataset with tf.kerasThe TFRecord FormatCompressed TFRecord FilesA Brief Introduction to Protocol BuffersTensorFlow ProtobufsLoading and Parsing ExamplesHandling Lists of Lists Using the SequenceExample ProtobufPreprocessing the Input FeaturesEncoding Categorical Features Using One-Hot VectorsEncoding Categorical Features Using EmbeddingsKeras Preprocessing LayersTF TransformThe TensorFlow Datasets (TFDS) ProjectExercises
14. Deep Computer Vision Using Convolutional Neural Networks
The Architecture of the Visual CortexConvolutional LayersFiltersStacking Multiple Feature MapsTensorFlow ImplementationMemory RequirementsPooling LayersTensorFlow ImplementationCNN ArchitecturesLeNet-5AlexNetGoogLeNetVGGNetResNetXceptionSENetImplementing a ResNet-34 CNN Using KerasUsing Pretrained Models from KerasPretrained Models for Transfer LearningClassification and LocalizationObject DetectionFully Convolutional NetworksYou Only Look Once (YOLO)Semantic SegmentationExercises
15. Processing Sequences Using RNNs and CNNs
Recurrent Neurons and LayersMemory CellsInput and Output SequencesTraining RNNsForecasting a Time SeriesBaseline MetricsImplementing a Simple RNNDeep RNNsForecasting Several Time Steps AheadHandling Long SequencesFighting the Unstable Gradients ProblemTackling the Short-Term Memory ProblemExercises
16. Natural Language Processing with RNNs and Attention
Generating Shakespearean Text Using a Character RNNCreating the Training DatasetHow to Split a Sequential DatasetChopping the Sequential Dataset into Multiple WindowsBuilding and Training the Char-RNN ModelUsing the Char-RNN ModelGenerating Fake Shakespearean TextStateful RNNSentiment AnalysisMaskingReusing Pretrained EmbeddingsAn Encoder–Decoder Network for Neural Machine TranslationBidirectional RNNsBeam SearchAttention MechanismsVisual AttentionAttention Is All You Need: The Transformer ArchitectureRecent Innovations in Language ModelsExercises
17. Representation Learning and Generative Learning Using Autoencoders and GANs
Efficient Data RepresentationsPerforming PCA with an Undercomplete Linear AutoencoderStacked AutoencodersImplementing a Stacked Autoencoder Using KerasVisualizing the ReconstructionsVisualizing the Fashion MNIST DatasetUnsupervised Pretraining Using Stacked AutoencodersTying WeightsTraining One Autoencoder at a TimeConvolutional AutoencodersRecurrent AutoencodersDenoising AutoencodersSparse AutoencodersVariational AutoencodersGenerating Fashion MNIST ImagesGenerative Adversarial NetworksThe Difficulties of Training GANsDeep Convolutional GANsProgressive Growing of GANsStyleGANsExercises
18. Reinforcement Learning
Learning to Optimize RewardsPolicy SearchIntroduction to OpenAI GymNeural Network PoliciesEvaluating Actions: The Credit Assignment ProblemPolicy GradientsMarkov Decision ProcessesTemporal Difference LearningQ-LearningExploration PoliciesApproximate Q-Learning and Deep Q-LearningImplementing Deep Q-LearningDeep Q-Learning VariantsFixed Q-Value TargetsDouble DQNPrioritized Experience ReplayDueling DQNThe TF-Agents LibraryInstalling TF-AgentsTF-Agents EnvironmentsEnvironment SpecificationsEnvironment Wrappers and Atari PreprocessingTraining ArchitectureCreating the Deep Q-NetworkCreating the DQN AgentCreating the Replay Buffer and the Corresponding ObserverCreating Training MetricsCreating the Collect DriverCreating the DatasetCreating the Training LoopOverview of Some Popular RL AlgorithmsExercises
19. Training and Deploying TensorFlow Models at Scale
Serving a TensorFlow ModelUsing TensorFlow ServingCreating a Prediction Service on GCP AI PlatformUsing the Prediction ServiceDeploying a Model to a Mobile or Embedded DeviceUsing GPUs to Speed Up ComputationsGetting Your Own GPUUsing a GPU-Equipped Virtual MachineColaboratoryManaging the GPU RAMPlacing Operations and Variables on DevicesParallel Execution Across Multiple DevicesTraining Models Across Multiple DevicesModel ParallelismData ParallelismTraining at Scale Using the Distribution Strategies APITraining a Model on a TensorFlow ClusterRunning Large Training Jobs on Google Cloud AI PlatformBlack Box Hyperparameter Tuning on AI PlatformExercisesThank You!
A. Exercise Solutions
Chapter 1: The Machine Learning LandscapeChapter 2: End-to-End Machine Learning ProjectChapter 3: ClassificationChapter 4: Training ModelsChapter 5: Support Vector MachinesChapter 6: Decision TreesChapter 7: Ensemble Learning and Random ForestsChapter 8: Dimensionality ReductionChapter 9: Unsupervised Learning TechniquesChapter 10: Introduction to Artificial Neural Networks with KerasChapter 11: Training Deep Neural NetworksChapter 12: Custom Models and Training with TensorFlowChapter 13: Loading and Preprocessing Data with TensorFlowChapter 14: Deep Computer Vision Using Convolutional Neural NetworksChapter 15: Processing Sequences Using RNNs and CNNsChapter 16: Natural Language Processing with RNNs and AttentionChapter 17: Representation Learning and Generative Learning Using Autoencoders and GANsChapter 18: Reinforcement LearningChapter 19: Training and Deploying TensorFlow Models at Scale
B. Machine Learning Project Checklist
Frame the Problem and Look at the Big PictureGet the DataExplore the DataPrepare the DataShortlist Promising ModelsFine-Tune the SystemPresent Your SolutionLaunch!
C. SVM Dual Problem
D. Autodiff
Manual DifferentiationFinite Difference ApproximationForward-Mode AutodiffReverse-Mode Autodiff
E. Other Popular ANN Architectures
Hopfield NetworksBoltzmann MachinesRestricted Boltzmann MachinesDeep Belief NetsSelf-Organizing Maps
F. Special Data Structures
StringsRagged TensorsSparse TensorsTensor ArraysSetsQueues
G. TensorFlow Graphs
TF Functions and Concrete FunctionsExploring Function Definitions and GraphsA Closer Look at TracingUsing AutoGraph to Capture Control FlowHandling Variables and Other Resources in TF FunctionsUsing TF Functions with tf.keras (or Not)
Index

Content preview from Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 2nd Edition

Preface

The Machine Learning Tsunami

In 2006, Geoffrey Hinton et al. published a paper¹ showing how to train a deep neural network capable of recognizing handwritten digits with state-of-the-art precision (>98%). They branded this technique “Deep Learning.” A deep neural network is a (very) simplified model of our cerebral cortex, composed of a stack of layers of artificial neurons. Training a deep neural net was widely considered impossible at the time,² and most researchers had abandoned the idea in the late 1990s. This paper revived the interest of the scientific community, and before long many new papers demonstrated that Deep Learning was not only possible, but capable of mind-blowing achievements that no other Machine Learning (ML) technique could hope to match (with the help of tremendous computing power and great amounts of data). This enthusiasm soon extended to many other areas of Machine Learning.

A decade or so later, Machine Learning has conquered the industry: it is at the heart of much of the magic in today’s high-tech products, ranking your web search results, powering your smartphone’s speech recognition, recommending videos, and beating the world champion at the game of Go. Before you know it, it will be driving your car.

Machine Learning in Your Projects

So, naturally you are excited about Machine Learning and would love to join the party!

Perhaps you would like to give your homemade robot a brain of its own? Make it recognize faces? Or learn to walk around? ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 3rd Edition

Publisher Resources

ISBN: 9781492032632Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design