PyTorch for Deep Learning with Python Bootcamp

Explore NumPy, a numerical processing library for large arrays, learn array creation, indexing, selection, and core operations, plus exercises, before Pandas builds on NumPy.

Import numpy as np, convert lists into arrays, explore 2-D matrices and shape, then use arange, zeros, ones, linspace, and identity matrices.

Learn to generate random numbers with numpy using rand, randn, and randint, set a seed, shape arrays into two dimensional forms, and inspect max, min, argmax, argmin, and dtype.

Master NumPy indexing and selection on one- and two-dimensional arrays, practice slicing, broadcasting, and boolean conditionals, and understand views versus copies for clean deep learning workflows.

Perform element-wise NumPy operations with broadcasting and arithmetic. Explore universal functions like sqrt, log, and trig, and use axis to sum and mean.

Practice numpy basics by completing a notebook of questions, importing numpy as np, and creating arrays of zeros, ones, and fives, noting outputs may vary with randomness.

Explore numpy exercises solutions, creating arrays with zeros and ones, ranges, and a 3x3 identity matrix. Indexing, reshaping, linspace, and basic statistics from arrays and random values.

Explore the Pandas library for data analysis, focusing on series and dataframes, handling missing data, performing groupby operations, indexing, input and output, and NumPy integration.

Explore Pandas series, the basic building block built on NumPy arrays with a named index, enabling index-based data access and operations, including not a number for missing values.

Explore pandas dataframes, including creating named indices and columns, selecting single or multiple rows and columns, adding or dropping columns, and using loc and iloc for subsetting.

Master pandas conditional selection by boolean masking across a DataFrame, filter by columns, combine conditions with ampersand and pipe, and use reset_index, set_index, and describe.

Group data in pandas by a categorical column, then apply aggregates like mean, max, or sum, and view the results with a grouped dataframe index.

Master Pandas operations for series and dataframes, including unique values, value counts, conditional selection, applying functions, and sorting, indexing, and describing data.

Learn how pandas reads and writes data with read_csv, read_excel, and read_html, using csv files and to_csv, and how to manage file paths and index handling.

Explore pandas through practical exercises: import pandas, read bank.csv, display head, compute mean age, analyze marital status and job categories, and create coded columns with map and apply.

Learn pandas basics by loading bank.csv, inspecting with head and iloc, computing mean age, identifying 19-year-olds, and using nunique, value_counts, map, and apply for education and employment insights.

Learn PyTorch basics by exploring tensors, creating and operating on them, and completing exercises; grasp tensors as generalized matrices from 1d to nd for data and images.

Learn the basics of PyTorch tensors by converting numpy arrays with from_numpy and as_tensor, creating tensors with tensor, inspecting dtypes, and understanding memory links vs copies.

Create and manipulate PyTorch tensors from scratch, differentiate torch.tensor from torch.Tensor, reshape, and use zeros, ones, empty, arange, linspace, random tensors, and manual_seed for reproducibility.

Explore tensor operations in PyTorch, including indexing and slicing, reshaping and views, plus in-place and basic arithmetic, and extend to dot products and matrix multiplication in part two.

Explore dot products and true matrix multiplication in PyTorch using a.dot(b), torch.mm, or the @ operator, with compatible shapes, plus Euclidean norms and numel insights.

Practice PyTorch basics with a 10-question exercise: import torch and numpy, set seeds to 42, create and reshape tensors, extract the right-hand column, square values, and compute a matrix product.

Import torch and numpy, set seeds to 42, create six-element array and tensor, reshape to 3 by 2, extract right-hand column, square, then perform a 3x2 by 2x3 matrix product.

Define machine learning and deep learning, compare supervised and unsupervised tasks, and outline evaluating classification and regression performance while noting overfitting, bias, and variance.

Learn how supervised learning uses labeled data to train models, split data into training and test sets, evaluate performance, and adjust hyperparameters before deploying to the real world.

Explore overfitting and underfitting in supervised learning, and learn how training versus validation and test performance reveals whether a model generalizes.

Learn to evaluate classification models using accuracy, recall, precision, and F1-score, and interpret results with confusion matrices, true positives, true negatives, false positives, false negatives, including unbalanced classes.

Evaluate regression models by comparing predicted continuous values to true labels using mean absolute error, mean squared error, and root mean squared error; MAE underplays large errors, RMSE preserves units.

Explore unsupervised learning, including clustering, anomaly detection, and dimensionality reduction, using unlabeled data, and understand why there is no test-train split or predefined labels, making evaluation nuanced.

Explore the theory of artificial neural networks, from perceptron models to activation functions and backpropagation. Implement concepts with PyTorch, addressing regression and classification in supervised learning using neural networks.

Model a biological neuron as a perceptron using inputs, weights, and a bias to produce output. Explore expanding to multi-layer networks and learn activation functions, gradient descent, and back propagation.

Build a multi-layer perceptron using fully connected layers in a feedforward network. Identify input, hidden, and output layers, and note that deep networks have two or more hidden layers.

Explore how inputs, weights, and biases form z = wx + b, then pass through activation functions like step, sigmoid, tanh, and relu to enable binary and multi-class classification.

Explore multi-class activation functions for neural networks, contrast non-exclusive and mutually exclusive settings, learn one-hot encoding, and apply sigmoid or softmax to output probabilities.

Demonstrates automatic differentiation in PyTorch, showing how to compute gradients with backpropagation on tensors with requires_grad, via a dynamic computational graph across simple layered equations.

Explore implementing a simple linear regression in PyTorch, using X and Y with noise to recover Y = 2x + 1 and a single linear layer.

Instantiate a simple PyTorch linear regression model, inspect parameters, run a forward pass, and train with MSE loss and SGD to converge toward weight near 2 and bias near 1.

Load iris.csv with pandas, split with train_test_split, and convert to PyTorch tensors, then use TensorDataset and DataLoader to batch and shuffle for training.

Build a basic PyTorch neural network using the iris dataset to predict species, define a Python class inheriting from nn.Module, and apply relu activations through forward propagation.

Read and visualize the iris dataset, split into train and test sets, convert to tensors, and train a PyTorch model with cross-entropy loss and Adam for 100 epochs, tracking losses.

Evaluate a PyTorch neural network on the test set with no_grad for efficient inference. Save and load the model state_dict to predict on unseen data like a mystery iris.

Apply a full ann to real tabular data with pytorch, using feature engineering, embeddings for categorical data, dropout, and a reusable tabular model for regression and classification.

Engineer features for a neural network regression on NYC taxi fares by computing distance via haversine and extracting time-based features from pickup datetime in eastern time, using 120k records.

Handle categorical and continuous features in a regression setup by converting categoricals with pandas category, using cat.codes, and turning data into PyTorch tensors; compute embedding sizes for a tabular model.

Define a flexible tabular regression model in PyTorch by building embedding layers for categorical features, normalizing continuous data, and stacking dynamic dropout and linear layers in a ModuleList.

Create and train a tabular ANN regression model in PyTorch, using MSE (RMSE), Adam optimizer, 300 epochs, train-test splits for categorical and continuous features, evaluate with RMSE, and save TaxiModel.pt.

Convert an ann from regression to classification by setting the output size to two and using cross entropy loss on the fare class binary target, with train/test splits.

Overview of binary classification exercises on census income with a neural network. Learn to identify continuous and categorical features, set embeddings, train with cross-entropy, and achieve about 85% accuracy.

Navigate neural network exercise solutions in PyTorch, covering data preparation, handling categorical and continuous features, training with cross-entropy loss, and evaluating accuracy.

Explore convolutional neural networks for image data, starting with mnist and comparing a fully connected network to a cnn. Learn filters, convolutions, pooling, and apply cnn to mnist and cifar-10.

Explore MNIST handwritten digits dataset in PyTorch, with 28x28 images normalized to 0–1, 60k training and 10k test images, and flatten to 784 inputs for an ANN across 10 classes.

Load MNIST in PyTorch, convert images to tensors with torchvision transforms, and batch data with DataLoader. Visualize the first batch with labels to link MNIST basics to neural networks.

Build and train a multilayer perceptron for MNIST in PyTorch by flattening 28x28 images to 784, using two hidden layers (120, 84), ReLU, log-softmax, cross-entropy, and Adam.

Set up training and evaluation for a neural network on MNIST, track train and test losses and accuracy across 10 epochs, and time the run.

Evaluate MNIST with an artificial neural network by comparing training and test losses and accuracies, and assess unseen data with a confusion matrix.

Explore how image filters, or image kernels, transform pixels through convolution in a convolutional neural network, and how the network learns weights for edge detection and feature extraction.

convolutional layers use localized filters to reduce parameters and learn hierarchical features from grayscale and color images, with two-dimensional kernels, three-dimensional color filters, and pooling and downsampling.

Explore pooling layers in convolutional neural networks, including max pooling and average pooling with a 2x2 window and stride 2, to reduce parameters while preserving essential patterns.

Revisit how MNIST data is prepared for CNN modeling by framing images as 4-D tensors and using one-hot encoded labels, preserving 2-D structure and channel order.

Explore mnist with a two-convolutional-layer cnn, using 3x3 kernels, 1 input channel, 6 and 16 filters, relu activations, and max pooling, loaded via torchvision and dataloader with batch size 10.

Build and train a two-convolutional neural network for MNIST in PyTorch. Implement the ConvolutionalNetwork with Conv2d, pooling, fully connected layers, softmax output, and cross-entropy loss with Adam.

Evaluate the MNIST CNN by plotting training vs validation losses and accuracies over four epochs, showing about 98% test accuracy and enabling single image predictions and confusion matrix exploration.

Explore CIFAR-10 with a convolutional neural network by loading 32x32 color images with three channels, applying transforms, and creating train and test loaders with class labels for CNN training.

Build a convolutional neural network for the CIFAR-10 dataset with three color channels, using conv layers, pooling, and fully connected layers to classify 10 classes.

Learn to load real image data and prepare it for PyTorch deep learning, applying pre-processing, normalization, and data transformations like resize, crop, flip, and rotate to improve robustness.

Explore loading real image data and applying a suite of PyTorch image transformations, converting images to tensors, resizing, center cropping, flipping, rotating, and normalizing for robust deep learning model training.

Load and augment cats and dogs images with train and test transforms (random rotation and horizontal flip), a two-layer convolutional neural network on 224x224 inputs, and evaluate using pre-trained models.

Train a CNN on custom cat-or-dog images, monitor train and test losses, track accuracy across epochs, save the model, and preview loading pre-trained models.

Download and apply pre-trained Torchvision models, normalize images with the given mean and std, and fine-tune only the final classifier of AlexNet to two classes, achieving strong accuracy.

Explore Fashion-MNIST exercises in PyTorch with torchvision. Build a CNN with two convolutional layers, two pooling layers, and two fully connected layers, train five epochs, and evaluate.

This lecture presents cnn exercise solutions, covering data loader setup, batch inspection of grayscale 28x28 images, cnn construction with conv layers and pooling, and training with cross-entropy loss and Adam.

Explore how recurrent neural networks handle sequence data, from time series to text, and learn about LSTMs and GRUs, plus a basic RNN implementation in PyTorch.

Learn the basic theory of recurrent neural networks for sequence data, including memory of history, unrolling through time, and architectures like sequence-to-sequence, many-to-one, and LSTM.

Explore vanishing and exploding gradients during backpropagation in deep networks, and how sigmoid and ReLU variants, batch normalization, and Xavier initialization mitigate them, with LSTM for time series.

Explains how LSTM and GRU units address vanishing gradients, balance long-term and short-term memory, and use gates such as forget, input, update, and output in Python.

Explore basic recurrent neural networks for time series such as a sine wave by building sequence batches, selecting training sequence lengths and labels, and forecasting step-by-step while highlighting error propagation.

Develop a sine wave time series, split into training and test sets, and build windowed batches with input_data for forecasting with a recurrent neural network.

Build an LSTM model in PyTorch for time series forecasting, understanding long-term and short-term memory, inputs, and outputs. Configure a simple architecture with 50 hidden units and a single output.

Train and forecast a basic recurrent neural network on a sine wave, evaluating on a held-out test range while retraining on all data to forecast into the unknown future.

Load a timestamped series from pandas, clean nulls, and plot trends; normalize training data with MinMaxScaler to avoid data leakage, then create 12-point windowed sequences for an RNN in PyTorch.

Learn to build and train an LSTM time-series model in PyTorch, define loss and optimizer, evaluate on a test set, inverse transform predictions, and forecast into the future.

Master a recurrent neural network exercise using a 1x64 LSTM with a 64-to-1 output for Federal Reserve energy production time-series. Prepare data, train 50 epochs, evaluate, and generate inverse-transformed forecasts.

Build and evaluate an RNN in PyTorch for energy production time series. Prepare data with a 12-step window, scale with MinMaxScaler, and train an LSTM with 64 hidden units.

Learn why GPUs accelerate PyTorch training, and how NVIDIA CUDA enables parallel processing on GPUs, with cloud options from AWS, Google Cloud, and Azure.

Learn how to run PyTorch on a gpu with cuda by checking cuda availability, moving tensors and models with .cuda(), and optimizing data loading with pin_memory for faster training.