Neural Networks
Neural networks are computing systems inspired by biological brains, built from layers of interconnected nodes that learn patterns from data. They power image recognition, language translation, recommendation engines, and many other tasks where traditional programming rules would be impractical to write by hand.
itArtificial intelligence and machine learning | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic: Neural Networks
A neural network is a mathematical mapping that learns from examples rather than waiting for someone to write every rule by hand. Traditional programs work well when the rules can be named. Images, language, speech, and messy sensor readings tend to respond by producing more cases than anyone wanted to name. The network takes the hint and adjusts its internal numbers instead.
Those numbers are weights and biases. A small unit, called a neuron, combines its inputs with them and then applies an activation function. That last part is the escape hatch from a very large but still linear spreadsheet. Stack enough layers, and the network can turn pixels into edges, edges into shapes, and shapes into a prediction. It is less mystical than it sounds, although the number of parameters can make the invoice feel philosophical.
Training has a repeating rhythm. A forward pass makes a prediction. A loss function measures the miss. Backpropagation traces the miss through the layers and calculates how each weight helped cause it. An optimizer changes the weights. Repeat across batches and epochs until the network becomes less wrong in a useful way. The learning rate sets the size of each change, which is why it can turn either into glacial progress or a lively journey away from the answer.
The surprise is that a low training loss is not a medal. It only proves the model got good at the examples it has already seen. Overfitting appears when that skill does not carry to validation data, often because the network has memorized detail rather than learned a pattern. Dropout, weight decay, early stopping, and more representative data are ways to argue with that tendency. The argument is necessary because neural networks have no built-in common sense, explanation, or guarantee outside their training distribution.
Architecture follows the shape of the data. CNNs use filters for spatial patterns in images. RNNs carry state through sequences, though long sequences make gradients troublesome. Transformers use self-attention so positions can relate in parallel, which is why they became central to language and increasingly to vision. Transfer learning changes the starting point: rather than train every feature from scratch, a pretrained model can be fine-tuned for a related task.
For the map, read the Intro and Slides. Keep the Cheatsheet nearby when terms and failure signals blur together. The Reference tab moves from foundations to PyTorch implementation and deeper study. Field Notes covers the awkward operational fact that the trained network is only part of the system. The exercise then makes the loss curves tell their own small, stubborn story.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://developers.google.com/machine-learning/crash-course/neural-networks
Supports
- Neural networks learn to map inputs to outputs by adjusting internal parameters through training on examples
- https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html
Supports
- A neuron computes a weighted sum of inputs, adds a bias, and applies a nonlinear activation function
- https://developers.google.com/machine-learning/crash-course/neural-networks
Supports
- Without nonlinear activation functions, multiple layers collapse to a single linear transformation
- https://developers.google.com/machine-learning/crash-course/neural-networks/backpropagation
Supports
- Backpropagation computes gradients of the loss with respect to each weight using the chain rule
- https://developers.google.com/machine-learning/crash-course/neural-networks
Supports
- ReLU is the default activation for hidden layers because it avoids the vanishing gradient problem
- https://pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html
Supports
- CNNs use learned convolutional filters that slide across spatial dimensions to detect local patterns
- https://arxiv.org/abs/1512.03385
Supports
- ResNet introduced skip connections enabling training of networks with 100+ layers (2015)
- https://arxiv.org/abs/1706.03762
Supports
- The Transformer architecture uses self-attention to process sequences in parallel, introduced in 2017
- https://ocw.mit.edu/courses/6-7960-deep-learning-fall-2024/
Supports
- LSTM and GRU add gating mechanisms to address vanishing gradients in recurrent networks
- https://pytorch.org/tutorials/beginner/basics/buildmodel_tutorial.html
Supports
- Transfer learning reuses pretrained models to reduce data and compute requirements for specific tasks
- https://developers.google.com/machine-learning/crash-course/neural-networks
Supports
- Adam optimizer combines momentum and adaptive per-parameter learning rates
- https://developers.google.com/machine-learning/crash-course/neural-networks
Supports
- Dropout randomly zeroes neuron activations during training to prevent overfitting
- https://ocw.mit.edu/courses/6-7960-deep-learning-fall-2024/
Supports
- Batch normalization normalizes layer inputs, reducing internal covariate shift and enabling higher learning rates
- https://ocw.mit.edu/courses/6-7960-deep-learning-fall-2024/
Supports
- AlexNet (2012) demonstrated deep CNNs trained on GPUs could win ImageNet classification
- https://ocw.mit.edu/courses/6-7960-deep-learning-fall-2024/
Supports
- Vision Transformer (ViT, 2020) applies the Transformer architecture to image patches
- https://doi.org/10.1007/BF02478259
Supports
- McCulloch and Pitts formalized a threshold-neuron model in 1943.
- https://doi.org/10.1037/h0042519
Supports
- Rosenblatt introduced the perceptron in 1958.
- https://doi.org/10.1038/323533a0
Supports
- Rumelhart, Hinton, and Williams described learning internal representations through back-propagating errors in 1986.
- http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf
Supports
- LeCun and colleagues applied gradient-based learning to document recognition with convolutional networks in 1998.
- https://proceedings.neurips.cc/paper_files/paper/2012/hash/c399862d3b9d6b76c8436e924a68c45b-Abstract.html
Supports
- AlexNet won the ImageNet 2012 classification challenge with a deep convolutional network trained on GPUs.
- https://arxiv.org/abs/1409.3215
Supports
- Sequence-to-sequence learning encoded variable-length input sequences and decoded output sequences in 2014.
- https://arxiv.org/abs/1512.03385
Supports
- Residual learning made substantially deeper visual networks easier to optimize in 2015.
- https://arxiv.org/abs/1706.03762
Supports
- The Transformer architecture replaced recurrence with attention mechanisms in 2017.
- https://arxiv.org/abs/2010.11929
Supports
- Vision Transformer applied a pure Transformer directly to sequences of image patches in 2020.
- https://pytorch.org/tutorials/beginner/basics/quickstart_tutorial.html
Supports
- PyTorch provides the tensors, automatic differentiation, modules, and training components used in the exercise.
- https://research.google/pubs/the-ml-test-score-a-rubric-for-ml-production-readiness-and-technical-debt-reduction/
Supports
- Production ML systems need testing and monitoring beyond offline experiments.
- https://research.google/pubs/machine-learning-the-high-interest-credit-card-of-technical-debt/
Supports
- ML systems incur ongoing maintenance costs through data dependencies, feedback loops, and system-level coupling.
- https://developers.google.com/machine-learning/crash-course/overfitting/dividing-datasets
Supports
- Repeated use of validation and test sets can reduce confidence that results generalize to new data.
- https://pytorch.org/docs/stable/index.html
Supports
- PyTorch, TensorFlow, JAX, Keras, ONNX Runtime, Triton Inference Server, and Hugging Face Hub documentation describe their roles in neural-network development and deployment.
