The Multilayer Artificial Neural Network Course with Python

Explore neural networks and their TensorFlow implementation, including propagation and nonlinear activations for image and speech recognition, text understanding, image segmentation, dialogue systems, and autonomous driving.

Build a one-layer neural network with a single hidden layer using the iris dataset, load libraries, and normalize features with min-max scaling while preparing a train-test split.

Implement a multilayer neural network by building one-dimensional data, initializing numpy-based layers, adding a convolutional layer followed by an activation, a max-pooling layer, and a fully connected layer.

Continue building a multilayer neural network in Python, wiring convolutional layers, activation, and max pooling to a fully connected layer. Explore one-dimensional data for series signal processing and text embedding.

Build a two-dimensional neural network segment by implementing a 5x5 convolution on a 10x10 input, using valid padding, followed by 2x2 max pooling and an activation.

Build a multilayer neural network with convolutional and max pooling layers in TensorFlow, handling 1D and 2D data, and connect to a fully connected output for a complete model.

Implement a multilayer neural network for the birth weights project in Python, building multiple layers with specified shapes. Train with absolute loss and data shuffling through iterations.

Analyze the birth weights regression project in the final part, evaluating train and test accuracy, addressing overfitting, and discussing how the multilayer neural network predicts birth weight.

Learn how to improve a linear model with a neural network approach, using absolute value loss, batch training, gradient updates, and plotting training and test accuracy to balance overfitting.

Explore the perceptron, a single-layer linear neuron with -1 and 1 outputs. Implement a from-scratch Python version using numpy, and study small learning rates, epoch-based training, and convergence.

Explore how the multilayer perceptron overcomes perceptron linearity with a hidden layer and a three-layer architecture. Understand how activation functions enable nonlinearity and how forward and backpropagation train the network.

Implement a multilayer perceptron in Python with a single hidden layer and activation, compile with an optimizer and categorical cross-entropy, and train/test split with one-hot labels.

Explore overfitting as a common problem where deep networks memorize training data instead of generalizing to unseen samples, even with large data sets.

Apply dropout to prevent overfitting and explore multiple sub-networks, especially in very deep networks, while dropout on input layers augments data with random noise.

Implement dropout in a multilayer neural network by loading and normalizing the handwritten digits dataset, reshaping images to 784 features, building a sequential model, and training to evaluate performance.

Analyze plotted training results of a multilayer perceptron, noting overfitting as training accuracy hits 1.0 while validation loss rises, applying dropout to 25% of inputs with 0.1 learning rate.

Explore dropout implementation in a multilayer artificial neural network using Python and a sequential mlp. Train, test, and compare validation accuracy to understand how dropout prevents overfitting and improves generalization.

Learn batch normalization and its role in stabilizing deep neural network training, using mini-batch normalization, data normalization, and a practical mnist dataset implementation with model building and evaluation.

Process a 70,000 image handwritten digit dataset (60k training, 10k test), reshape 28x28 images to 784 features, normalize to -1 to 1, and split into train, validation, and test sets.

Build a multilayer neural network from scratch in Python, creating MLP with one hidden layer to classify images using a sigmoid activation, one-hot encoding of labels, and forward and backpropagation.

Continue building a multilayer neural network by implementing backpropagation, a gradient-based update, and a training loop with mini-batches, data loading, and validation.

Explore the forward pass and activation choices in a multilayer neural network, convert labels to one-hot, compute loss and accuracy, and discuss practical training with mini-batch data and memory limits.

Build and train a multilayer neural network by implementing a train_model function, looping over epochs and mini-batches, and tracking loss and accuracy.

Evaluate the model by plotting training loss and accuracy and validation accuracy across epochs, then report test accuracy around 94–95%, noting mild overfitting on the training data.

Celebrate your progress in deep learning and commit to ongoing practice to become a successful deep learning engineer, then download the Cargo and UCI respiratory datasets to develop a model.