Oreilly – Deep Learning with PyTorch video edition 2021-7
Oreilly – Deep Learning with PyTorch video edition 2021-7

Deep Learning with PyTorch video edition. This course teaches you how to build neural networks and deep learning systems using the PyTorch library. This hands-on book quickly walks you through building a real-world example from scratch: a tumor image classifier. Along the way, it covers best practices for the entire deep learning pipeline, including the PyTorch tensor API, loading data into Python, supervising training, and visualizing results. After covering the basics, the book takes you on a journey through larger projects. The main focus of the book is a neural network designed to detect cancer. You will explore methods for training networks with limited inputs and begin processing data to obtain some results. You will examine unreliable initial results and focus on how to detect and fix problems in your neural network. Finally, you will explore ways to improve your results by training with augmented data, making improvements to the model architecture, and performing other fine-tuning.
What you will learn:
- Training deep neural networks
- Implementing loss modules and functions
- Using pre-trained models from PyTorch Hub
- Review code samples in Jupyter Notebooks
This course is suitable for people who:
- Python programmers are passionate about machine learning.
Course details: Deep Learning with PyTorch video edition
- Publisher: Oreilly
- Instructor: Eli Stevens , Luca Antiga, Thomas Viehmann
- Training level: Beginner to advanced
- Training duration: 15 hours and 32 minutes
Course headings
- Part 1. Core PyTorch
- Chapter 1. Introducing deep learning and the PyTorch Library
- Chapter 1. Why PyTorch?
- Chapter 1. An overview of how PyTorch supports deep learning projects
- Chapter 1. Hardware and software requirements
- Chapter 2. Pretrained networks
- Chapter 2. Obtaining a pretrained network for image recognition
- Chapter 2. Ready, set, almost run
- Chapter 2. A pretrained model that fakes it until it makes it
- Chapter 2. A network that turns horses into zebras
- Chapter 2. A pretrained network that describes scenes
- Chapter 3. It starts with a tensor
- Chapter 3. Indexing tensors
- Chapter 3. The tensor API
- Chapter 3. Tensor metadata: Size, offset, and stride
- Chapter 3. NumPy interoperability
- Chapter 4. Real-world data representation using tensors
- Chapter 4. 3D images: Volumetric data
- Chapter 4. Representing scores
- Chapter 4. Working with time series
- Chapter 4. Ready for training
- Chapter 4. One-hot encoding whole words
- Chapter 4. Text embeddings as a blueprint
- Chapter 5. The mechanics of learning
- Chapter 5. Gathering some data
- Chapter 5. Down along the gradient
- Chapter 5. Normalizing inputs
- Chapter 5. Optimizers a la carte
- Chapter 5. Generalizing to the validation set
- Chapter 6. Using a neural network to fit the data
- Chapter 6. More activation functions
- Chapter 6. The PyTorch nn module
- Chapter 6. Finally a neural network
- Chapter 7. Telling birds from airplanes: Learning from images
- Chapter 7. Distinguishing birds from airplanes
- Chapter 7. Representing the output as probabilities
- Chapter 7. Training the classifier
- Chapter 7. The limits of going fully connected
- Chapter 8. Using convolutions to generalize
- Chapter 8. Convolutions in action
- Chapter 8. Looking further with depth and pooling
- Chapter 8. Subclassing nn.Module
- Chapter 8. Training our convnet
- Chapter 8. Helping our model to converge and generalize: Regularization
- Chapter 8. Going deeper to learn more complex structures: Depth
- Chapter 8. Comparing the designs from this section
- Part 2. Learning from images in the real world: Early detection of lung cancer
- Chapter 9. Using PyTorch to fight cancer
- Chapter 9. What is a CT scan, exactly?
- Chapter 9. In more detail, we will do the following
- Chapter 9. Why can’t we just throw data at a neural network until it works?
- Chapter 9. What is a nodule?
- Chapter 10. Combining data sources into a unified dataset
- Chapter 10. Training and validation sets
- Chapter 10. Loading individual CT scans
- Chapter 10. Locating a nodule using the patient coordinate system
- Chapter 10. A straightforward dataset implementation
- Chapter 10. Constructing our dataset in LunaDataset.__init__
- Chapter 11. Training a classification model to detect suspected tumors
- Chapter 11. Pretraining setup and initialization
- Chapter 11. Our first-pass neural network design
- Chapter 11. The full model
- Chapter 11. Outputting performance metrics
- Chapter 11. Needed data for training
- Chapter 11. Running TensorBoard
- Chapter 11. Why isn’t the model learning to detect nodules?
- Chapter 12. Improving training with metrics and augmentation
- Chapter 12. Graphing the positives and negatives
- Chapter 12. Our ultimate performance metric: The F1 score
- Chapter 12. What does an ideal dataset look like?
- Chapter 12. Samplers can reshape datasets
- Chapter 12. Revisiting the problem of overfitting
- Chapter 12. Seeing the improvement from data augmentation
- Chapter 13. Using segmentation to find suspected nodules
- Chapter 13. Semantic segmentation: Per-pixel classification
- Chapter 13. Updating the model for segmentation
- Chapter 13. Updating the dataset for segmentation
- Chapter 13. Building the ground truth data
- Chapter 13. Implementing Luna2dSegmentationDataset
- Chapter 13. Designing our training and validation data
- Chapter 13. Updating the training script for segmentation
- Chapter 13. Getting images into TensorBoard
- Chapter 13. Results
- Chapter 14. End-to-end nodule analysis, and where to go next
- Chapter 14. Bridging CT segmentation and nodule candidate classification
- Chapter 14. Did we find a nodule? Classification to reduce false positives
- Chapter 14. Quantitative validation
- Chapter 14. Reusing preexisting weights: Fine-tuning
- Chapter 14. What we see when we diagnose
- Chapter 14. Beyond a single best model: Ensembling
- Chapter 14. Conclusion
- Part 3. Deployment
- Chapter 15. Deploying to production
- Chapter 15. Request batching
- Chapter 15. Exporting models
- Chapter 15. Interacting with the PyTorch JIT
- Chapter 15. TorchScript
- Chapter 15. LibTorch: PyTorch in C++
- Chapter 15. C++ from the beginning: The C++ API
- Chapter 15. Going mobile
- Chapter 15. Improving efficiency: Model design and quantization
Course images
Sample course video
Installation Guide
After Extract, view with your favorite player.
Subtitles: None
Quality: 720p
Download link
File(s) password: www.downloadly.ir
File size
1.8 GB