Deep Learning Fundamentals
Deep learning trains neural networks with many layers to learn hierarchical representations from data. It powers image recognition, language understanding, speech synthesis, and generative models by automatically discovering the features that traditional machine learning requires engineers to design 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 - Deep Learning Fundamentals
Deep learning is the part of machine learning that lets a network of layers turn data into progressively more useful representations. It is not a box of architecture names, although the box has acquired an impressive collection of labels. The useful question is what each transformation represents, what the loss rewards, and whether the evidence says the resulting behavior works on relevant new data.
The machinery is less mystical than its vocabulary. A tensor is the container for inputs, outputs, parameters, and intermediate values. A layer transforms one representation into another. Its weights and biases are parameters, and an activation adds nonlinearity, because a tower of linear layers remains a linear function no matter how tall it feels.
A training step has five chores: run examples forward, calculate loss, propagate gradients backward, update parameters, and repeat. The loss is a score for the objective, not a certificate of usefulness. A network can become very accomplished at reducing training loss while becoming notably unhelpful on the data it has not seen.
That is why generalization matters. Training data updates parameters. Validation data guides choices such as architecture and learning rate. Test data estimates performance after those choices. If information leaks across those jobs, the metric can look reassuring while describing a world that the deployed system will never meet. Statistics can be polite like that.
Different architectures put their bets in different places. Convolution shares local filters for spatial patterns. Recurrent networks carry state through sequences. A transformer uses attention to relate sequence positions. None is automatically the right answer. The task, data, latency, memory, cost, privacy, security, and consequences of errors all get a vote.
The Intro gives the full map from representation through monitoring. Slides compress the relationships into a shape you can keep in your head. Cheatsheet is where the training loop, data roles, architecture anchors, and diagnostic signals wait when memory has taken a short holiday. The practice reference and exercise make one update observable. Then the Reference tab leads from foundations toward more detailed work.
Keep the durable model nearby: representation plus objective plus optimization plus evidence. Adding layers cannot repair a weak part of that arrangement. It can only make the disappointment more computationally expensive.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.deeplearningbook.org/
Supports
- Deep learning as representation learning with multilayer neural networks
- Machine learning foundations, feedforward networks, regularization, optimization, convolutional networks, sequence modeling, and practical methodology
- Parameters, loss functions, gradient-based optimization, generalization, overfitting, and data-split roles
- Limits of training objectives and the need to compare model choices through evaluation
- https://developers.google.com/machine-learning/crash-course/neural-networks
Supports
- Neural networks as architectures for learning nonlinear patterns
- Nodes, hidden layers, activation functions, inference, backpropagation, and multiclass output
- Nonlinear activations as necessary for representing nonlinear relationships with stacked layers
- https://developers.google.com/machine-learning/crash-course/neural-networks/backpropagation
Supports
- Backpropagation as the training process that computes parameter gradients
- Gradient descent and learning rate as parts of iterative parameter updates
- The relationship among forward passes, loss, backward passes, and optimization
- https://developers.google.com/machine-learning/crash-course/overfitting/regularization
Supports
- Generalization and overfitting diagnosed with held-out data and loss curves
- Model complexity and L2 regularization as considerations in controlling overfitting
- Separation of training, validation, and test roles
- https://developers.google.com/machine-learning/crash-course/classification/accuracy-precision-recall
Supports
- Accuracy limitations for imbalanced data
- Precision and recall as class-error measures
- Metric selection based on the consequences of false positives and false negatives
- https://developers.google.com/machine-learning/crash-course/production-ml-systems
Supports
- A model as one component of a production machine-learning system
- Deployment testing, pipeline monitoring, training and inference concerns
- Operational requirements beyond an offline model metric
- https://docs.pytorch.org/tutorials/beginner/basics/intro.html
Supports
- A complete workflow covering tensors, datasets, models, automatic differentiation, optimization, and model persistence
- Tensors as the data structure for model input, output, and parameters
- Training as repeated data, model, loss, gradient, and update operations
- https://docs.pytorch.org/tutorials/beginner/basics/autogradqs_tutorial.html
Supports
- Automatic differentiation over a computation graph
- Backpropagation of loss gradients to parameters with the chain rule
- Gradient tracking for training and its disabling during inference
- https://docs.pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial
Supports
- Neural-network modules, learnable parameters, forward computation, loss functions, backpropagation, and parameter updates
- Mini-batch tensor input and gradient accumulation behavior
- https://doi.org/10.1038/nature14539
Supports
- Representation learning and multilayer neural-network foundations
- Convolutional and recurrent architectures
- Applications in speech recognition, visual recognition, and other domains
- https://arxiv.org/abs/1706.03762
Supports
- The original Transformer architecture based on attention
- Replacement of recurrence and convolution with attention in the paper's sequence-transduction design
- Parallelization benefits of that architecture during training
- https://docs.pytorch.org/docs/stable/optim.html
Supports
- Optimizer zeroing, backward propagation, and parameter-update steps in a PyTorch training loop
- https://github.com/pytorch/pytorch/blob/main/LICENSE
Supports
- PyTorch is distributed under a BSD-style open-source license
- https://www.tensorflow.org/about
Supports
- TensorFlow supports model construction, training, and deployment across server, edge, and web targets
- https://github.com/tensorflow/tensorflow/blob/master/LICENSE
Supports
- TensorFlow is distributed under the Apache License 2.0
- https://docs.jax.dev/en/latest/
Supports
- JAX provides automatic differentiation, vectorization, and compilation transformations for array programs
- https://github.com/jax-ml/jax/blob/main/LICENSE
Supports
- JAX is distributed under the Apache License 2.0
- https://keras.io/about/
Supports
- Keras provides a multi-framework deep learning API for JAX, TensorFlow, and PyTorch
- https://github.com/keras-team/keras/blob/master/LICENSE
Supports
- Keras is distributed under the Apache License 2.0
- https://onnxruntime.ai/docs/
Supports
- ONNX Runtime executes exported models across supported hardware and operating systems
- https://github.com/microsoft/onnxruntime/blob/main/LICENSE
Supports
- ONNX Runtime is distributed under the MIT License
- https://doi.org/10.1037/h0042519
Supports
- Rosenblatt's 1958 perceptron and trainable pattern-recognition model
- https://doi.org/10.1038/323533a0
Supports
- Error derivatives and learning internal representations in layered networks
- https://www.bioinf.jku.at/publications/older/2604.pdf
Supports
- Long short-term memory as a recurrent architecture for long time lags
- http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf
Supports
- Gradient-based learning and convolutional networks for document recognition
- https://doi.org/10.1162/neco.2006.18.7.1527
Supports
- A fast learning algorithm for deep belief nets
- https://papers.nips.cc/paper_files/paper/2012/hash/c399862d3b9d6b76c8436e924a68c45b-Abstract.html
Supports
- Deep convolutional neural networks for ImageNet classification
- https://arxiv.org/abs/1512.03385
Supports
- Residual learning for image recognition
- https://research.google/pubs/hidden-technical-debt-in-machine-learning-systems/
Supports
- Data dependencies, feedback loops, and technical debt in production machine-learning systems
