Complete Tensorflow 2 and Keras Deep Learning Bootcamp

Explore NumPy basics: what NumPy is and why to use it for arrays and matrices. Learn indexing, slicing, and operations, plus memory efficiency and broadcasting for data science and TensorFlow.

Master NumPy arrays as the core data structure, creating them with np.array, arange, zeros, ones, linspace, and eye, and generating random data with seed for reproducibility, reshaping and inspecting dtype.

Master numpy indexing and selection from single values to slices, broadcast operations, and two-dimensional arrays, then apply conditional selection leveraged in pandas for data cleaning.

Master NumPy operations with element-wise arithmetic, universal array functions, and summary statistics across 1D and 2D arrays, while understanding axis, shape, and handling nan and infinity.

Practice NumPy basics with an exercise notebook that guides you to import NumPy as np, create arrays of zeros, ones, and fives, and compare outputs while avoiding overwriting example results.

Master NumPy basics with zeros, ones, arange, eye, rand, randn; learn indexing, slicing, reshaping, linspace, and reproducible random numbers through seed.

Learn pandas, the Python data handling library built on NumPy, exploring series and data frames, group by methods, missing data handling, and feature engineering before TensorFlow.

Create pandas series from lists, numpy arrays, or dictionaries with a labeled index, access by label or position, and perform additions that may yield not a number for missing labels.

Master pandas DataFrames, learning to create rows and columns, select data with df, loc, and iloc, and perform simple feature engineering by creating new columns.

Learn to handle missing data by three strategies: leave it as missing, drop missing values with dropna, or fill with mean, median, or mode, including per column filling.

Apply the pandas groupby workflow to group rows by a categorical column and compute aggregations such as sum, mean, or describe. Use multi-column grouping and transpose for quick statistics.

Explore essential Pandas operations for data wrangling, including unique values, value counts, duplicates, apply, mapping, max/min indices, and one-hot encoding with get_dummies.

Master Pandas io for data input and output by reading CSV files with read_csv, managing file paths with pwd and full paths, and saving results with to_csv and index options.

Explore pandas exercises using a dataset on financial stability in several African countries, practice dataframe tasks, and identify the first systemic crisis year (1985) for Kenya, with solutions shown later.

Master pandas exercises by loading data with read_csv, inspecting with head, using unique, nunique; then sort, filter, group to analyze crises, inflation, exchange rates for Kenya, Zimbabwe, Algeria.

Explore quick data visualization techniques using Matplotlib and Seaborn, with a brief intro to common plotting syntax for exploratory data analysis, and a glimpse of Pandas plotting later.

Learn to create basic plots with Matplotlib in Python, including simple line and scatter plots, labels, titles, axis limits, and basic styling.

Learn Seaborn basics for creating standard statistical plots with one-line calls, using pandas dataframes, and blending with matplotlib for customization on a heart disease dataset.

Explore data visualization with exercises on scatter plots of price versus carrot, adjusting alpha and edge colors, creating histograms, count plots, and box plots, and ordering visuals by cut types.

Learn data visualization by plotting price versus carat with seaborn, adjusting alpha and edge colors, then create histograms, count plots, and boxplots for diamonds, using the order parameter.

Discover what machine learning is and how it automates model building from data using algorithms that learn, including neural networks and deep learning, with supervised and unsupervised tasks and evaluation.

Explore supervised learning with labeled data, train models on historical features and labels, adjust weights and biases, and evaluate with training, validation, and test splits for neural networks.

Explore overfitting and underfitting in supervised learning, recognizing when a model fits noise with low training error but high validation and test error.

Summarize how to evaluate classification performance using accuracy, recall, precision, and F1 score with a confusion matrix. Explore precision-recall trade-offs, especially for unbalanced data, and connect metrics to real-world contexts.

Evaluate regression performance using mean absolute error, mean squared error, and root mean squared error to compare continuous predictions with true values, considering outliers and unit interpretation.

Explore unsupervised learning with clustering, anomaly detection, and dimensionality reduction on unlabeled data, and note the nuanced evaluation without labels and no test-train split.

Understand the theory of artificial neural networks—from perceptron models to activation functions and backpropagation—and learn to build and train Keras networks with TensorFlow 2 for regression and classification.

Model a biological neuron with a simple perceptron by weighting inputs, adding a bias, and producing a single output, then prepare for multi-layer networks, activation functions, and backpropagation.

Build a multi-layer perceptron with fully connected hidden layers from input to output, enabling learning of complex relationships and setting the stage for activation functions in classification.

Explore activation functions like sigmoid, tanh, and ReLU, where z equals wx plus b and is fed into these functions to shape binary and multi-class outputs, addressing thresholds and backpropagation.

Explore how to handle multi-class problems with one-hot encoding and activation functions: use sigmoid for non-exclusive classes and softmax for mutually exclusive classes, with a per-class output layer.

Understand cost functions and gradient descent, including learning rate and Adam optimization, cross-entropy for classification, and how training evaluation leads toward backpropagation.

Explore backpropagation, from intuition to calculus, and learn how to update weights and biases via gradient descent by applying the chain rule and Hadamard product.

Explore the relationship between TensorFlow and Keras, a high-level API running on top of TensorFlow and other backends, now the official API in TensorFlow 2.0.

Learn Keras syntax basics for TensorFlow with a regression example, preparing data using train_test_split, extracting features and price, and scaling features with MinMaxScaler before building a neural network.

Learn to create and train a Keras model with the sequential API, add dense layers and activations, and generate predictions, preparing for evaluation and saving and loading in later parts.

Explore Keras model evaluation on a test set using mean squared error, mean absolute error, and root mean squared error, and learn to predict, plot, and save or load models.

Tackle a regression project on housing prices using King County data, performing exploratory data analysis and feature engineering. Use Seaborn and Matplotlib to explore correlations and distributions.

Engineer date features by converting to datetime and extracting year and month, then perform exploratory data analysis to assess their impact and decide on zip code, renovation, and basement features.

Separate features from the label, perform a train-test split, scale with a MinMax scaler, then build and train a Keras sequential regression model with validation data.

During a Keras regression code along, evaluate training versus validation loss to guard against overfitting, and compute mean squared error, mean absolute error, and a new house price prediction.

Learn to build a cancer classification model with TensorFlow and Keras, performing exploratory data analysis, preprocessing and scaling, and train-test splitting, while applying early stopping and dropout to prevent overfitting.

learn to build a binary classifier with Keras, address overfitting using early stopping and dropout, train with validation data, and evaluate performance with classification report and confusion matrices.

Choose from solo, exercise guide notebook, or code-along with solutions to build a predictive model for loan repayment using historical data, with emphasis on feature engineering and data preparation.

Overview of a TensorFlow 2.0 Keras project for classifying loan default using a Lending Club dataset, covering feature engineering, data preprocessing, exploratory data analysis, and model evaluation with dropout.

Conduct exploratory data analysis of a loan dataset with seaborn visualizations to assess label balance, distributions, correlations, and repayment predictors, including loan_repaid, grade, and interest rate.

Analyze missing data, quantify per column, and decide to drop or fill; then drop emp_title and emp_length, and assess employment length against loan status to gauge feature usefulness.

Master data preprocessing by handling missing data in a loan dataset, drop the title column, and fill missing mortgage account values using total account group means, then drop remaining rows.

Learn practical preprocessing of categorical data by converting term to 36 or 60 months, dropping grade, and applying one-hot encoding to subgrade and other categorical features.

Drop the loan_status column, set X and y, optionally sample the data, then perform a 0.2 train-test split with random state 101 and normalize with MinMaxScaler on the training set.

Build and train a Keras sequential model for binary classification. Use 78 input features, dropout, halved dense layers, sigmoid output, binary_crossentropy, Adam, and 25 epochs.

Evaluate a trained Keras model by comparing training and validation loss. Use a classification report and confusion matrix to assess accuracy, precision, recall, and f1-score.

Explore Tensorboard, a visualization tool for TensorFlow, to view dashboards in your browser, log training with graphs, histograms, and images, and organize log directories for each model.

Explore the theory and core concepts of convolutional neural networks, including kernels, filters, convolutions, and pooling, and apply them to grayscale and color images like MNIST and CIFAR-10.

Explore image filters and kernels, learn how sliding a 3x3 kernel over images creates blurred and edge-detected outputs, and see how CNNs learn weights in convolutional layers.

Explore how convolutional layers use learned image filters to capture local patterns with localized connections, handling grayscale and color images through multiple filters and setting up pooling layers.

Explore pooling layers in convolutional neural networks to reduce large feature maps and parameters, compare max pooling and average pooling, and learn how dropout and architecture choices affect performance.

Explore the MNIST dataset, a grayscale 28x28 set of handwritten digits used to train CNNs in Keras, with four-dimensional data shaping, normalization to 0–1, and one-hot encoding for 10 classes.

Learn to prepare MNIST data for CNNs by loading with Keras, one-hot encoding labels with to_categorical, visualizing images, normalizing by 255, and reshaping to 28x28x1 for multi-class classification.

Create and train a simple CNN for MNIST with Conv2D, MaxPool2D, Flatten, and Dense layers, using a 10-class softmax output, categorical_crossentropy loss, and early stopping.

Evaluate a trained CNN on MNIST by comparing training and validation loss and accuracy, generating a classification report and confusion matrix, and predicting a single 28 by 28 image.

Learn to work with color data using CIFAR-10, building a two-layer convolutional neural network for 32x32 RGB images, including data loading, preprocessing, and training with early stopping.

Assess CIFAR-10 model performance by reviewing training, plotting accuracy and loss, and using classification reports and confusion matrices to diagnose misclassifications between cats and dogs.

Learn to use TensorFlow's built-in tools to generate image data batches from real image files by downloading, extracting cell_images.zip, and locating the train and test directories with os.listdir.

Learn to apply a convolutional neural network to custom png or jpeg images by reading data from train and test folders, handling file paths and resizing images to 130x130x3.

Leverage the image data generator to create batches from a directory, apply rotations, shifts, zooms, and flips, and organize data into one folder per class for training and testing.

Develop and train a convolutional neural network for custom color images using Keras Sequential, Conv2D, MaxPool, and dropout, with a 130x130x3 input, binary classification, and early stopping.

Explore evaluating a CNN on real image files by generating predictions, interpreting probability outputs, and using confusion matrices and classification reports to balance precision and recall.

Navigate the convolutional neural network exercise with fashion-MNIST data by loading, normalizing, reshaping to a single channel, one-hot encoding, then building, training, and evaluating with a classification report.

Learn to build and train a convolutional neural network on fashion mnist using tensorflow and keras, including data loading, preprocessing, model construction with conv and pooling layers, training, and evaluation.

Explore recurrent neural networks for sequence data, including time series forecasting with RNNs, LSTMs, and GRUs. Build an RNN on a sine wave and apply forecasting to real-life time series.

Explore the basic theory of recurrent neural networks for sequence data, showing how memory and time unrolling enable sequence-to-sequence, many-to-one, and long short-term memory architectures to tackle vanishing gradients.

Learn how vanishing and exploding gradients affect deep networks, and how activation choices (sigmoid, ReLU variants, ELU), batch normalization, and Xavier initialization mitigate them, with LSTM for RNNs.

Explore how LSTM and GRU units address vanishing gradients in recurrent networks by managing long-term and short-term memory with forget, input, update, and output gates.

Learn to prepare time series data for recurrent neural networks by forming training sequences and labels in batches, selecting sequence length and batch size, and forecasting beyond the last point.

Learn to train and evaluate a basic recurrent neural network on a sine wave, using a time-series train-test split, scaling, and preparing batches with the time-series generator in Keras.

Leverage the TimeseriesGenerator to create input-target batches from your data, setting length and batch_size to capture sine-wave seasonality; this prepares for RNN versus LSTM in the next lecture.

Create a time series generator and train a Sequential RNN, starting with a SimpleRNN and expanding to an LSTM, to forecast sine-wave data with a 25-point window and evaluate predictions.

Compare RNN and LSTM performance on a sine wave, apply EarlyStopping with dual training and validation generators, and forecast future points with scaled data and inverse transform.

Forecast a real-time series with a datetime-index using a recurrent neural network in Keras, leveraging pandas timestamps, MinMaxScaler, and TimeseriesGenerator for sequence prediction.

Build and train an LSTM time-series model on scaled sales data with early stopping and a validation generator. Forecast future values after full-data retraining using a pandas monthly forecast index.

Practice a recurrent neural network exercise on the FRED ice cream production time series by building an LSTM model with a time-series generator, seasonality handling, and train-test split.

Apply a recurrent neural network approach to forecast frozen dessert production using a time series dataset, including data loading, scaling, time series generation, LSTM modeling, training, and evaluation.

Learn to forecast multivariate time series with LSTM RNNs, adjust input shapes and outputs for multiple features, and compare performance with interpretable ARIMA-based models like SARIMAX and VARMAX.

Explore text data with deep learning by building a character-based recurrent neural network that writes text from the Shakespeare corpus, using embedding, GRU, and temperature-tuned dense outputs in TensorFlow.

In part one of NLP for text generation, import core libraries and load Shakespeare text from Gutenberg to analyze character-level data and prepare for a TensorFlow 2 and Keras RNN.

Advance text processing by vectorizing text data through a character-to-index dictionary and its inverse, encoding the full text as integers with numpy, and preparing for batch creation.

Create shuffles and batches for a character-based text generator in TensorFlow, using 120-character sequences and a 128-sample batch, mapping inputs to targets by shifting one step.

Create a simple three-layer text generation model with an embedding layer, a GRU, and a dense output. Build a custom sparse categorical cross entropy loss with from_logits set to true.

train a 3 million-parameter nlp model on a gpu, use Google Colab with TensorFlow 2.x, test random predictions, and prepare to load the saved shakespeare model.