Deep Learning from Scratch. Building with Python from First Principles Seth Weidman

Deep Learning from Scratch. Building with Python from First Principles Seth Weidman - okladka książki

Autor:: Seth Weidman
Wydawnictwo:: O'Reilly Media (Z chęcią przeczytam książkę w języku polskim)
Ocena:: Bądź pierwszym, który oceni tę książkę
Stron:: 252
Dostępne formaty:: ePub

Mobi

Ebook 186,15 zł najniższa cena z 30 dni

~~229,00 zł~~ (-15%)
194,65 zł

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

186,15 zł najniższa cena z 30 dni

Poleć tę książkę znajomemu Poleć tę książkę znajomemu!!

Przenieś na półkę

Do przechowalni

Najczęściej kupowane razem

Deep Learning from Scratch. Building with Python from First Principles Seth Weidman

Hands-On Prescriptive Analytics Walter R. Paczkowski

Uczenie głębokie od zera. Podstawy implementacji w Pythonie Seth Weidman

Cena zestawu: 423.80 zł

Zyskujesz: 103.18 zł (-20%)

Dodaj do koszyka

With the resurgence of neural networks in the 2010s, deep learning has become essential for machine learning practitioners and even many software engineers. This book provides a comprehensive introduction for data scientists and software engineers with machine learning experience. You’ll start with deep learning basics and move quickly to the details of important advanced architectures, implementing everything from scratch along the way.

Author Seth Weidman shows you how neural networks work using a first principles approach. You’ll learn how to apply multilayer neural networks, convolutional neural networks, and recurrent neural networks from the ground up. With a thorough understanding of how neural networks work mathematically, computationally, and conceptually, you’ll be set up for success on all future deep learning projects.

This book provides:

Extremely clear and thorough mental models—accompanied by working code examples and mathematical explanations—for understanding neural networks
Methods for implementing multilayer neural networks from scratch, using an easy-to-understand object-oriented framework
Working implementations and clear-cut explanations of convolutional and recurrent neural networks
Implementation of these neural network concepts using the popular PyTorch framework

Wybrane bestsellery

O autorze książki

Seth Weidman - specjalizuje się w nauce o danych (ang. data science). Przez wiele lat prowadził szkolenia w zakresie uczenia maszynowego. Obecnie buduje modele uczenia maszynowego dla zespołu odpowiedzialnego za infrastrukturę w Facebooku. Pasjonuje go objaśnianie złożonych zagadnień w możliwie prosty sposób. Uważa, że po drugiej stronie złożoności znajduje się prostota.

Kup polskie wydanie:

Uczenie głębokie od zera. Podstawy implementacji w Pythonie

Autor:: Seth Weidman

41,40 zł ~~69,00 zł~~ (44.85 zł najniższa cena z 30 dni)

Druk

Ebook

Ebooka "Deep Learning from Scratch. Building with Python from First Principles" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Audiobooka "Deep Learning from Scratch. Building with Python from First Principles" posłuchasz:

w aplikacji Ebookpoint na Android, iOS, HarmonyOs
na systemach Windows, MacOS i innych

na dowolonych urządzeniach
i aplikacjach obsługujących format MP3
(pliki spakowane w ZIP)

Masz pytania? Zajrzyj do zakładki Pomoc »

Kurs Video "Deep Learning from Scratch. Building with Python from First Principles" zobaczysz:

Oceny i opinie klientów: Deep Learning from Scratch. Building with Python from First Principles Seth Weidman (0)

Szczegóły książki

ISBN Ebooka:: 978-14-920-4136-8, 9781492041368
Data wydania ebooka :: 2019-09-09 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
Język publikacji:: 1
Rozmiar pliku ePub:: 4.9MB
Rozmiar pliku Mobi:: 11.9MB

Zgłoś erratę

Kategorie

Kliknij, aby zgłosić błędnie przypisaną kategorię »

Informatyka » Programowanie » Python

Spis treści książki

Preface
- Understanding neural networks requires multiple mental models
- Chapter outlines
- Conventions Used in This Book
- Using Code Examples
- OReilly Online Learning
- How to Contact Us
- Acknowledgments
1. Foundations
- Functions
  - Math
  - Diagram
  - Code
    - Code caveat #1: Numpy
    - Code caveat #2: Type checked functions
    - Basic functions in Numpy
- Derivatives
  - Math
  - Diagram(s)
  - Code
- Nested Functions
  - Diagram
  - Math
  - Code
  - Another diagram
- The Chain Rule
  - Math
    - Diagram
  - Code
- A slightly longer example
  - Math
  - Diagram
  - Code
- Functions With Multiple Inputs
  - Math
  - Diagram
  - Code
- Derivatives of Functions with Multiple Inputs
  - Diagram
  - Math
  - Code
- Functions with multiple vector inputs
  - Math
- Creating new features from existing features
  - Math
  - Diagram
  - Code
- Derivatives of functions with multiple vector inputs
  - Diagram
  - Math
  - Code
- Vector functions and their derivatives - one step further
  - Diagram
  - Math
  - Code
  - Vector functions and their derivatives: the backward pass
    - Math
    - Diagram
    - Code
    - Is this right?
- Computational Graph with Two 2D Matrix Inputs
  - Math
  - Diagram
  - Code
- The fun part: the backward pass
  - Diagram
  - Math
    - The ?
    - The Answer
  - Code
    - Describing these gradients visually
- Conclusion
2. Fundamentals
- Supervised Learning Overview
- Supervised Learning models
- Linear regression
  - Linear regression: a diagram
    - Training this model
  - Linear regression: a more helpful diagram (and the math)
  - Adding in the intercept
  - Linear regression: the code
- Training the model
  - Calculating the gradients: a diagram
  - Calculating the gradients: the math (and some code)
  - Calculating the gradients: the (full) code
  - Using these gradients to train the model
- Assessing our model: training set vs. testing set
- Assessing our model: the code
  - Analyzing the most important feature
- Neural networks from scratch
  - Step 1: a bunch of linear regressions
  - Step 2: a non-linear function
  - Step 3: another linear regression
  - Diagram(s)
    - Another diagram?
  - Code
  - Neural networks: the backward pass
    - Diagram
    - Math (and code)
    - The overall loss gradient
- Training and assessing our first neural network
  - Two reasons why this is happening
- Conclusion
3. Deep Learning From Scratch
- Deep Learning definition: a first pass
- The building blocks of neural networks: Operations
  - Diagram
  - Code
- The building blocks of neural networks: Layers
  - Diagrams
    - Connection to the brain
- Building blocks on building blocks
  - The Layer blueprint
  - The Dense Layer
- The NeuralNetwork class, and maybe others
  - Diagram
  - Code
  - Loss class
- Deep Learning From Scratch
  - Implementing batch training
  - NeuralNetwork: code
- Trainer and Optimizer
  - Optimizer
    - Description and code
  - Trainer
    - Trainer code
- Putting everything together
  - Our first Deep Learning model (from scratch)
- Conclusion and next steps
4. Extensions
- Some Intuition about Neural Networks
- The softmax cross entropy loss function
  - Component #1: the softmax function
    - Math
    - Intuition
  - Component #2: the cross entropy loss
    - Math
    - Intuition
    - Code
  - A note on activation functions
    - The other extreme: the Rectified Linear Unit
    - A happy medium: Tanh
- Experiments
  - Data preprocessing
  - Model
  - Experiment: softmax cross entropy loss
- Momentum
  - Intuition for momentum
  - Implementing momentum in the Optimizer class
    - Math
    - Code
  - Experiment: stochastic gradient descent with momentum
- Learning rate decay
  - Types of learning rate decay
  - Experiments: learning rate decay
- Weight initialization
  - Math and code
  - Experiments: weight initialization
- Dropout
  - Dropout: definition
  - Dropout: implementation
    - Adjusting the rest of our framework to accommodate Dropout
  - Experiments: dropout
- Conclusion
5. Convolutional Neural Networks
- Neural networks and representation learning
  - A different architecture for image data
  - The convolution operation
  - The multi-channel convolution operation
- Convolutional Layers
  - Implementation implications
  - The differences between convolutional and fully connected layers
  - Making predictions with convolutional layers: the Flatten layer
  - Pooling layers
    - Applying CNNs beyond images
- Implementing the multi-channel convolution operation
  - The forward pass
    - Diagrams and math
    - Padding
    - Code
    - A note on stride
  - Convolutions: the backward pass
    - What should the gradient be?
    - Computing the gradient of a 1D convolution
    - Whats the general pattern?
    - Computing the parameter gradient
    - Coding this up
  - Batches, 2D Convolutions, and Multiple Channels
    - 1D convolutions with batches: forward pass
    - 1D convolution with batches: backward pass
  - 2D convolutions
    - 2D convolutions: coding the forward pass
    - 2D convolutions: coding the backward pass
  - The last element: adding channels
    - Forward pass
    - Backward pass
- Using this Operation to Train a CNN
  - The Flatten Operation
  - The full Conv2D Layer
    - A note on speed, and an alternative implementation
  - Experiments
- Conclusion
6. Recurrent Neural Networks
- The Key Limitation: handling branching
- Automatic differentiation
  - Coding up gradient accumulation
    - Automatic differentiation illustration
    - Explaining what happened
- Motivation for recurrent neural networks
- Introduction to Recurrent Neural Networks
  - The first class for RNNs: RNNLayer
  - The second class for RNNs: RNNNode
  - Putting these two classes together
  - The backward pass
    - Accumulating gradients for the weights in an RNNs
- RNNs: the code
  - The RNNLayer class
    - Initialization
    - The forward method
    - The backward method
  - The essential elements of RNNNodes
  - Vanilla RNNNodes
    - RNNNode: the code
    - RNNNodes: the backward pass
  - Limitations of vanilla RNNNodes
  - One solution: GRUNodes
    - GRUNodes: a diagram
    - GRUNodes: the code
  - LSTMNodes
    - LSTMNode: diagram
    - LSTMs: the code
  - Data representation for a character-level RNN-based language model
  - Other language modeling tasks
  - Combining RNNLayer variants
  - Putting this all together
- Conclusion
7. PyTorch
- PyTorch Tensors
- Deep Learning with PyTorch
  - PyTorch elements: Model, Layer Optimizer, and Loss
    - The inference flag
  - Implementing neural network building blocks using PyTorch: DenseLayer
  - Example: Boston Housing Prices Model in PyTorch
  - PyTorch elements: Optimizer and Loss
  - PyTorch elements: Trainer
  - Tricks to optimize learning in PyTorch
- Convolutional neural networks in PyTorch
  - DataLoader and transforms
  - LSTMs in PyTorch
- Postscript: Unsupervised Learning via Autoencoders
  - Representation Learning
  - An approach for situations with no labels whatsoever
    - Diagram
  - Implementing an autoencoder in PyTorch
  - A stronger test for unsupervised learning, and a solution
- Conclusion
A. Appendix
- Matrix chain rule
- Gradient of the loss with respect to the bias terms
- Convolutions via matrix multiplication