Become a TensorFlow Certified Professional Developer

Relate human neuron concepts to activation functions and introduce artificial neurons. Build a neural network in TensorFlow from scratch, study gradient descent, stochastic gradient descent, and backpropagation to reduce loss.

Explore the neuron, activation functions, and the neural network's working to predict housing prices. Learn gradient descent, stochastic gradient descent, and back propagation, and how they drive learning in networks.

Explore how neurons function as the building blocks of deep learning, from input signals and synapses to weighted sums, activation functions, and learning with backpropagation.

Explore how an already trained neural network estimates property prices from input features via input and hidden layers and the output price, driven by weights, synapses, and activation.

Explore four key activation functions—threshold, sigmoid, rectifier, and hyperbolic tangent—and learn how they shape neural network outputs, including binary decisions and probability estimates.

Explore how neural networks learn by training a one-layer perceptron, comparing output to actual values, minimizing a squared error cost function through weight updates, backpropagation, and gradient descent.

Learn how gradient descent optimizes neural network weights by following the cost function’s slope toward the minimum, with one to three dimensional examples, and contrasts with brute-force search.

Explore stochastic gradient descent as a fast, stochastic alternative to batch gradient descent, capable of escaping local minima in non-convex costs while updating weights after each row or in mini-batches.

Learn how backpropagation simultaneously adjusts all neural network weights to minimize the cost function, after forward propagation and error calculation, using learning rate, stochastic gradient descent, and batch gradient descent.

Develop a deep neural network with fully connected layers in TensorFlow 2.0 to predict bank churn, from data preprocessing to deployment, using a real-world multi-feature dataset for binary classification.

Kick off the data preprocessing phase for building an ANN with TensorFlow 2.0 by importing libraries, encoding categorical data, splitting the dataset, and applying feature scaling.

Build a sequential neural network in TensorFlow using dense layers, with an input layer, two hidden layers (six neurons each, ReLU), and a one-neuron sigmoid output for binary prediction.

Compile an artificial neural network with the Adam optimizer, binary cross-entropy loss, and accuracy metric, then train with fit on the training set with batch size 32 for 100 epochs.

Predict a customer's churn by feeding a 2d input with dummy-encoded features and scaling, then convert the probability to a binary outcome and assess 86% accuracy via a confusion matrix.

Explore convolutional neural networks for computer vision and image classification, covering convolution, max pooling, flattening, fully connected layers, and build a TensorFlow CNN from scratch with softmax and cross-entropy.

Explore how convolutional neural networks work, from convolution operations and feature maps to ReLU, pooling, flattening, full connections, and softmax with cross entropy for image classification.

Learn how convolutional neural networks extract features from images, classifying items like a cheetah and a bullet train, and master core steps: convolution, max pooling, flattening, and fully connected layers.

Apply convolution by sliding a 3x3 feature detector over an input image to produce a convolved feature map, while using stride and multiple filters to create several feature maps.

Apply the ReLU rectified linear unit on top of the convolution step to increase non-linearity, converting negative values to zero and shaping feature maps.

Explore max pooling in neural networks, how it achieves spatial invariance, downsamples feature maps with a 2x2 window and stride 2, and reduces parameters to prevent overfitting.

Learn how to flatten pooled feature maps into a single long vector to serve as the input for an artificial neural network, after applying convolution and relu activation and pooling.

Add a fully connected network on top of the CNN, transforming flattened features into dog and cat outputs, trained via backpropagation and gradient descent.

Explain how convolutional neural networks use filters to create feature maps, apply ReLU and max pooling, flatten to a fully connected network, and train with backpropagation for image classification.

Learn how softmax converts neural network outputs to probabilities that sum to one, and how cross-entropy loss guides training in convolutional neural networks.

Launch a practical CNN from scratch in Python using TensorFlow to recognize cats and dogs, implementing convolutional layers, max pooling, flattening, and a final output classifier.

Import TensorFlow and the Keras image preprocessing tools, set up image augmentation with the ImageDataGenerator, and preprocess the training and test sets to prevent overfitting.

Build a convolutional neural network in five steps with TensorFlow Keras, including conv 2d with 32 filters of 3x3, max pool 2d, flatten, dense, and a sigmoid output.

Train a cnn on the training set while evaluating on the test set across 25 epochs, compiling with adam optimizer, binary cross-entropy loss, and accuracy, using fit with validation data.

Deploy a convolutional neural network in TensorFlow by loading an image with load_img, converting with image_to_array, adding a batch dimension, and predicting cat or dog.

Build, train, and test a convolutional neural network for cat and dog image classification using TensorFlow and Keras in a Jupyter Notebook workflow.

Learn the fundamentals of recurrent neural networks, address the vanishing gradient problem with LSTMs and variations, and build a recurrent neural network with TensorFlow from scratch in one notebook.

Outline the plan for understanding recurrent neural networks, conquer the vanishing gradient with LSTM architectures, and explore practical intuition and variations through engaging tutorials and examples.

Explore recurrent neural networks and their short-term memory, including how RNNs unroll temporal loops for many-to-one and many-to-many tasks like image captioning, translation, and subtitles.

Explore the vanishing gradient problem in recurrent neural networks, its impact on training, and practical remedies such as gradient clipping, truncated backpropagation, and the role of LSTMs.

Explore how LSTMs address the vanishing gradient with a memory cell and gates that regulate memory flow. Learn the memory pipeline, gate operations, and vector-based inputs that enable long-range dependencies.

Explore practical applications of LSTMs and recurrent neural networks, including text prediction, memory cells, hidden states, and how the architecture learns to track lines, quotes, and nested expressions.

Explore the main LSTM variations, including peephole connections, combined forget and memory gates, and gated recurrent units that simplify memory and hidden state.

Train a stacked LSTM in TensorFlow to predict Google stock trends using 2012–2016 data and January 2017 tests, with dropout and a Keras optimizer in a three-part RNN workflow.

Import numpy, pandas, and matplotlib.pyplot; load the training set and convert the open Google stock prices to a one-column numpy array for RNN training, then prepare for feature scaling.

Apply normalization using Minmaxscaler from scikit-learn to scale training data between 0 and 1 for an RNN, preparing data and time steps to prevent overfitting.

Build a 60-time-step RNN by creating X_train and Y_train from the past 60 days' stock prices to predict the next day, using NumPy arrays for TensorFlow input.

Reshape X_train to add a new indicator dimension, creating a three-dimensional input (batch size, time steps, indicators) for the forthcoming RNN with a stacked LSTM and dropout to reduce overfitting.

Build a robust stacked LSTM RNN with dropout using Keras, initialize as a sequential regressor to predict the stock price at time t+1, emphasizing regression over classification.

Add a first LSTM layer with dropout regularization to a sequential RNN in TensorFlow, set return_sequences true, and define input shape to prevent overfitting.

Build a four-layer LSTM recurrent neural network in TensorFlow, adding dropout regularization, handle input shapes for the second through fourth LSTM layers, and maintain 50 neurons with return sequences enabled.

Add the final output layer with a dense unit of one to LSTM network for predicting the stock price at time t plus one, then compile with mean squared error.

Compile the RNN with the Adam optimizer and mean squared error loss for a regression problem, then fit the RNN to Xtrain and Ytrain in the next tutorial.

Train the rnn regressor on the training set by fitting x_train and y_train for 100 epochs with a batch size of 32 to forecast Google stock price, observing loss convergence.

Extract the real January 2017 Google stock prices from the test CSV, prepare them as a numpy array, and set up a plot to compare real versus predicted values.

Predict January 2017 Google stock prices using a regressor trained on 60 previous days, concatenating training and test sets, and scale inputs with the sc object for rnn inputs.

Learn how to shape test data for an RNN in TensorFlow by creating a 60-step input window, preparing Xtest, and generating inverse-scaled stock price predictions with a regressor.

Visualize the final RNN results by plotting real versus predicted Google stock prices for January 2017, analyze lag during spikes, and reinforce TensorFlow-based sequence modeling insights.

Introduce computer vision in the TensorFlow course, load training data for a simple vision task, and build a computer vision neural network with training callbacks, including ann, cnn, and rnn.

Train a fashion classifier with fashion-mnist using 70,000 28 by 28 grayscale images in ten classes. Build a neural network with flatten and a 128-neuron hidden layer, with softmax output.

import fashionmnist data, normalize pixel values, and build a neural network with input, hidden, and output layers. train five epochs, evaluate on test data, and tweak parameters to improve accuracy.

Learn to stop training early using callbacks in the training loop by implementing an on_epoch_end Python callback that checks logs and cancels training when loss or accuracy meets criteria.

Apply callbacks to control training, monitor loss, and end training when it drops below 0.4; observe progress within two epochs and achieve around 60% accuracy.

Master deeper convolutions to boost the fashion-mnist classifier and the cat versus dogs dataset results, apply advanced convolution techniques, and explore cropping, supported by two notebooks and detailed explanations.

Explore how 64 three-by-three convolution filters with relu activation and max pooling extract features from 28 by 28 grayscale images, creating progressively smaller feature maps for a dense classifier.

Explore advanced convolutions with two 64-filter 3x3 convolutional layers and 2x2 max pooling, training on 60k images to boost fashion item classification, with feature map visualization.

Explore how convolutions and max pooling process images, implement 3x3 edge-detection filters, test horizontal and vertical line detectors, and see how TensorFlow learns and improves feature extraction for better accuracy.

Explore how the image generator handles complex images, define a ConvNet for efficient processing, and train it with the fit generator function, following a TensorFlow notebook with detailed explanations.

Point the image generator at training and validation directories to auto-label horse and human images. Build a network with three convolution-pooling layers and train with binary cross entropy.

Build a convolutional neural network in Keras using the image generator to classify horses and humans, train for 15 epochs on a 1000-image 300x300 dataset, and test on new images.

Train a ConvNet on real-world images and apply automatic validation to test and improve accuracy, and explore the impact of image compression using TensorFlow.

Build and train a convnet for real-world images using TensorFlow and Keras, employing image generators from labeled folders to classify cats versus dogs with a sigmoid output.

download and unzip a 3000-image cats and dogs dataset, organize training and validation folders, and train a TensorFlow model with generators to reach about 73% accuracy.

Explore image augmentation using the image data generator to boost model performance on cats vs dogs and horses vs humans datasets, with two notebooks and detailed explanations.

Explore how image augmentation combats overfitting in small datasets by expanding training variability with rotations, shifts, shearing, zoom, flips, and fill modes using a Keras image generator.

Explore image augmentation with ImageDataGenerator for a cat-versus-dogs classifier trained on a small dataset, tracking training and validation accuracy over 100 epochs to illustrate overfitting.

Apply image augmentation to the 2000 image, two-class cats versus dogs dataset to reduce overfitting and achieve 86% training and 81% test accuracy, with training and validation curves in step.

Use image augmentation to broaden training data for the horses vs humans dataset, and ensure testing data shares similar randomness to produce reliable validation and enable transfer learning.

Explore transfer learning concepts and code a model using transfer features from inception mode to boost efficiency. Apply dropout to reduce overfitting and use the provided notebook.

Explore transfer learning by using pre-trained convolutional features from models like Inception, freezing layers and retraining dense layers on your data to build robust classifiers with limited data.

Explore transfer learning with inception features and apply dropout to reduce overfitting in neural networks, improving validation accuracy during training.

Apply transfer learning by loading a pre-trained Inception model, using its last convolutional output as input, and training a small dense, dropout, and output layer on cats versus dogs.