Artificial Intelligence III - Deep Learning in Java

Explore why artificial intelligence and machine learning matter for optimization, robotics navigation, and game strategy, including genetic algorithms, A* search, deep learning, and reinforcement learning.

Explore the three main types of learning in artificial intelligence: supervised learning with labeled data, unsupervised clustering, and reinforcement learning through interaction and rewards, illustrated with practical examples.

Install the Java Development Kit 23 (JDK 23) from Oracle on Windows 64-bit. Update the system path to include the JDK 23 bin folder and verify the Java C version.

Install IntelliJ community edition to develop Java applications and microservices, configure the path, create a test project, and run a hello world program to verify setup.

Download Gradle 8.7 from gradle.org, unzip the binaries, update PATH and JAVA_HOME to the JDK root, then verify Gradle on the command line and enable the daemon for faster builds.

Explore how artificial neural networks mimic the nervous system to solve problems that lack exact algorithms, using feed-forward architectures with input, hidden, and output layers and trainable weights.

Explore the architecture of feedforward neural networks, with layers of neurons and learnable weights updated by backpropagation, and how inputs are converted for object classification with convolutional neural networks.

Understand why activation functions introduce non-linearity to neural networks, enabling non-linear decision boundaries and the universal approximation theorem, compare sigmoid and hyperbolic tangent, and discuss vanishing gradients and zero-centered outputs.

Demonstrate how a feedforward neural network learns the xor operator on a two-input data set using sigmoid activation and dense connections, with forward passes and backpropagation.

Add bias nodes in the input and hidden layers to shift the activation function horizontally and improve data fit, with bias weights learned by backpropagation.

Measure the network's error using a loss function, specifically mean squared error, by comparing predictions to known training labels. Minimize this loss through weight updates to improve predictions.

Apply gradient descent to minimize the neural network loss, tune weights with a learning rate and momentum, while avoiding overshooting and local minima.

Explore how gradient descent updates neural network weights through backpropagation, using node deltas and activation derivatives to adjust output and hidden layers via forward and backward passes.

Demonstrate backpropagation in a feedforward network by deriving weight updates from the mean squared error using the chain rule, detailing activations, net input, and deltas for output and hidden layers.

Explore a simple feedforward neural network implementation in Java using deep learning for j library, covering project setup, dependencies, and representing the XOR training data.

Create a data set with two inputs and one output, and build a two-layer feed-forward network (two-input first layer, four-hidden neurons, one-output) using sigmoid activation and mean squared error.

Train a simple feed-forward neural network by looping 50,000 iterations, updating randomly initialized weights with stochastic gradient descent, mean squared error, and a small learning rate, then evaluate predictions.

Train a simple feed-forward neural network with one input, a hidden layer, and an output layer using sigmoid and tanh activations, updating weights. Compare 50,000 and 10,000 iterations for accuracy.

Explore deep neural networks, which extend standard feedforward nets with multiple hidden layers, activation functions such as sigmoid or tanh, and backpropagation, while discussing vanishing gradients, overfitting, and regularization.

Examine vanishing and exploding gradients in deep networks, showing how sigmoid derivatives and the chain rule shrink or explode gradients, and how Xavier initialization mitigates them.

Explore the ReLU activation, leaky ReLU, and their impact on gradients. Use normal weight initialization with variance 1/n_input for ReLU, unlike Xavier for sigmoid/tanh.

the softmax activation function generalizes the sigmoid for multi-class classification, converting inputs into a probability distribution that sums to one, enabling one-hot encoded outputs and class prediction by highest probability.

Learn mean squared error for regression with a single continuous value, and cross-entropy for multi-class classification, plus how sigmoid, softmax, one-hot encoding, and negative log-likelihood connect to gradient descent.

Compare gradient descent and stochastic gradient descent. Contrast updates over the entire data set with a single sample, noting accuracy and speed.

Understand epochs, iterations, and batches, and how mini-batch gradient descent updates weights; apply min-max normalization on a column-wise basis to scale features and improve gradient flow.

Explore underfitting and overfitting in deep learning and learn how dropout regularization distributes learning across hidden neurons (0.2–0.5 dropout) to reduce overfitting.

Build a deep neural network with multiple hidden layers to solve the xor problem, using a dataset iterator, batch processing, and stochastic gradient descent with ReLU and sigmoid outputs.

Train a multilayer neural network with ReLU to solve XOR, monitor loss every 100 epochs, and inspect weight matrices and bias terms.

Explore classification with deep neural networks on the iris dataset in Java, using four features, three one-hot output classes, and an 80/20 train-test split with a multi-layer ReLU model.

Train a multi-layer deep neural network on the iris dataset with softmax output and negative log likelihood loss, using training and test splits and epoch-based learning.

Discover why convolutional neural networks are the state-of-the-art approach for image processing, using kernels, feature maps, and pooling to capture spatial structure.

Explore how convolutional neural networks learn crucial features through kernels and feature detectors, using edge, sharpen, and blur filters, and optimize kernels with gradient descent to improve image classification.

Explore how convolution uses kernels to detect features in images, initialize weights with Xavier methods, and generate multiple feature maps across layers using stride and ReLU activations.

Explore how maximum pooling in convolutional neural networks achieves spatial invariance by selecting the maximum values in non-overlapping 2x2 regions, reducing dimensionality and overfitting.

Explore convolutional neural networks, employing kernels to form feature maps, apply relu and max pooling, then flatten for a fully connected network trained with cross-entropy loss and softmax outputs.

Demonstrate how a convolutional neural network processes 32 by 32 input through multiple convolutional and max-pooling layers to form feature maps, then flattening and a densely connected network classify digits.

Shows how to update convolutional kernel weights during training using backpropagation, gradient descent, and mean squared error, by computing feature maps from image subregions.

Explore how colored images with red, green, and blue channels form tensors for convolutional networks, using depth-matched kernels and stride one to produce feature maps.

Trace the evolution of convolutional neural networks from early models to AlexNet, VGG16, and ResNet, noting accuracy growth to 99.5% and three by three kernels with average and max pooling.

Explore handwritten digit classification with convolutional neural networks on the mnist dataset (60,000 training, 10,000 test), using one-hot labels, 28x28 images flattened to 784 features, and softmax outputs.

Develop a cnn-based handwritten digit classifier trained on 60,000 mnist samples with batch size 64 and ten epochs, featuring conv layers, max pooling, dense 500, and softmax with cross-entropy.

Build a multi-layer convolutional neural network with convolutional, subsampling, and max pooling layers plus a dense softmax output for digit classification, train it, and note accuracy in the model summary.

Compare batch normalization with min-max normalization, then normalize within batches using mean and variance, apply x_hat with learnable alpha and beta to speed up training and stabilize gradients.

Apply batch normalization after convolutional layers and before activation, usually with identity prior to normalization and ReLU after, to boost accuracy on the handwritten digit classification data set.