Curricular Unit Code: 41010 | Universidade de Aveiro
Professor: Mário Antunes (mario.antunes@ua.pt)
Academic Year: 2026/2027 – 1.º Semestre
FAA is a fundamentals course in machine learning. Before any modern architecture, it builds a solid understanding of three questions:
- Why is learning possible? A model must compress noisy data into a reliable, computable pattern.
- How is a model fitted? Finding that pattern is an optimization problem.
- How do we know it worked? Every result must be evaluated with statistical care, knowing the pitfalls.
The classic model families (supervised, unsupervised, semi- and self-supervised, reinforcement learning) are then studied on these foundations.
Class format: each week has one 3-hour class: 2 hours of exposition (slides and live Jupyter demos) followed by 1 hour of practical work with the lab guide (every class, Class 01 included).
A topic may span more than one class.
| # | Topic | Classes | Main contents |
|---|---|---|---|
| 1 | Learning as Compression and Optimization | 01, 02 | Entropy, Kolmogorov complexity, MDL; evaluation and pitfalls; blind (population-based) and gradient-based optimization, JAX |
| 2 | Learning Taxonomies | 01 | Supervised, unsupervised, semi-supervised, self-supervised, and reinforcement learning |
| 3 | Supervised: Linear and Probabilistic Models | 03, 04 | Perceptron, linear and logistic regression, polynomial features, regularization, splits and metrics; MLE/MAP, Naive Bayes for classification and regression (discrete and continuous features), calibration, cost-based decisions |
| 4 | Supervised: SVM and Neural Networks | 05 | Maximum margin, kernels, SVR; perceptron, MLP, backpropagation |
| 5 | Supervised: Decision Trees and KNN | 06 | Impurity, pruning, regression trees; distances, scaling, choosing |
| 6 | Supervised: Ensemble Models | 07 | Bagging, random forests, boosting, stacking |
| 7 | Unsupervised: Blind Signal Separation | 09 | PCA, ICA, NMF |
| 8 | Unsupervised: Soft/Hard Clustering | 10 |
|
| 9 | Semi-Supervised and Self-Supervised Learning | 11, 12 | Pseudo-labelling, AutoEncoders, Transformers, JEPA |
| 10 | Reinforcement Learning | 13 | MDPs, exploration vs. exploitation, Q-learning, policy-based methods |
Classes run from 14 September to 22 December 2026. TP1 meets on Thursdays and TP2 on Fridays.
| Class | TP1 | TP2 | Topic | Milestone |
|---|---|---|---|---|
| 01 | 17 Sep | 18 Sep | T1 + T2: Learning as Compression, Pitfalls, and Taxonomies | Course presentation |
| 02 | 24 Sep | 25 Sep | T1: Blind vs. Gradient-Based Optimization | |
| 03 | 01 Oct | 02 Oct | T3: Linear Models | Project 1 released |
| 04 | 08 Oct | 09 Oct | T3: Probabilistic Models | |
| 05 | 15 Oct | 16 Oct | T4: SVM and Neural Networks | |
| 06 | 22 Oct | 23 Oct | T5: Decision Trees and KNN | |
| 07 | 29 Oct | 30 Oct | T6: Ensemble Models | |
| 08 | 05 Nov | 06 Nov | Test 1 (Topics 1–6) + Project 1 synthesis | Project 1 due |
| 09 | 12 Nov | 13 Nov | T7: Blind Signal Separation | Project 2 released |
| 10 | 19 Nov | 20 Nov | T8: Soft/Hard Clustering | |
| 11 | 26 Nov | 27 Nov | T9: AutoEncoders and Semi-Supervised Learning | |
| 12 | 03 Dec | 04 Dec | T9: Transformers and JEPA | |
| 13 | 10 Dec | 11 Dec | T10: Reinforcement Learning | Project 2 clinic |
| 14 | 17 Dec | 18 Dec | Test 2 (Topics 7–10) + Project 2 presentations | Project 2 due |
Slides: slides/01_foundations.pdf · Lab guide: practice/01_foundations.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| Course introduction | Professor, topics, schedule, evaluation, class format, environment setup | — |
| What is learning? | Task/experience/performance; pattern vs. noise; notation; sum, mean, error, MSE; memorization vs. generalization | 01_learning_as_compression.ipynb — D1 |
| Learning as compression | Information, entropy, Kolmogorov complexity, MDL/BIC, likelihood and regularization as code length | 01_learning_as_compression.ipynb — D2, D3 |
| From model to search | Finding the model as an optimization problem (argmin), why not try every value | — |
| Evaluating a model | Why evaluate; train/validation/test; cross-validation; variance and confidence intervals; hypothesis testing; baselines and metrics; comparing two models (corrected resampled t-test, McNemar's test) | 02_evaluation_validation.ipynb — D4a–D4d live, D4e–D4g read in the lab |
| Why models fail | Under/overfitting and bias–variance; No Free Lunch; data leakage; correlation vs. causation; shortcuts, distribution shift, sampling bias | 03_pitfalls.ipynb — D5–D9 |
| Kinds of learning | Supervised, unsupervised, semi-supervised, self-supervised, and reinforcement learning | 04_taxonomies.ipynb — D10 |
Data: breast cancer and heart disease (in datasets/), plus synthetic noise.
Lab: lab01_foundations.ipynb (helpers in lab01_utils.py): evaluation methodology on breast cancer, written with NumPy and compared with its scikit-learn or SciPy twin: a stratified hold-out and the majority baseline, solutions/lab01_foundations_solution.ipynb.
Slides: slides/02_optimization.pdf · Lab guide: practice/02_optimization.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| What is optimization? | Formal problem, numerical example, local/global minima, optimality conditions, curvature, eigenvalues and conditioning, convexity, common landscapes | — |
| Optimization in ML | Training as empirical risk minimization with regularization, common losses, parameters vs. hyperparameters | — |
| Gradient-based | Gradient descent and the learning rate, local minima, Newton's method, momentum, RMSProp, Adam, SGD | 01_gradient_based.ipynb — G1–G5 |
| Automatic differentiation | JAX grad/jit/vmap/hessian, custom models and losses, differentiating through an ODE solver |
01_gradient_based.ipynb — G6 |
| Blind optimization | Random search, hill climbing, simulated annealing; initialization (LHS, Sobol, OBL, QOBL, OBLESA); GA, DE, GWO/EGWO with pyBlindOpt | 02_blind_optimization.ipynb — B1–B3 |
| Comparing optimizers | Equal budgets, many seeds, noise, No Free Lunch, hybrid (memetic) search | 02_blind_optimization.ipynb — B4–B5 |
Lab: lab02_optimization.ipynb (helpers in lab02_utils.py); solved and explained in solutions/lab02_optimization_solution.ipynb. Three problems (line fit, Rosenbrock, sinusoid fit): gradient descent by hand and with JAX, a genetic algorithm from scratch, pyBlindOpt initializations and optimizers, Newton's method, and a challenge that trains a classifier on the 0/1 loss.
Tools: pyOptViewer animates every pyBlindOpt algorithm; blindgame lets students play the black-box optimizer (GECCO 2025 Fun Competition).
Slides: slides/03_linear_models.pdf · Lab guide: practice/03_linear_models.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| Data visualization, cleaning, preprocessing, splitting | Look at the data first (histograms, scatter, correlations, maps); missing values and categories; why scaling and the logarithm matter; hold-out, stratified, k-fold, grouped, temporal splits |
01_linear_regression.ipynb — R1
|
| Linear regression | The pipeline (preprocessing + model); least squares, normal equation, gradient descent with jax.grad, curvature and the learning rate, the probabilistic view |
01_linear_regression.ipynb — R2
|
| Regression metrics | MSE, RMSE, MAE, sMAPE, |
01_linear_regression.ipynb — R3
|
| Polynomial features and regularization | Feature expansion and overfitting; ridge ( |
01_linear_regression.ipynb — R4–R5
|
| Perceptron | Update rule as a subgradient, convergence, XOR |
02_perceptron.ipynb — P1
|
| Generalized linear models | Linear predictor, link and distribution; the canonical-link gradient | slides only (see the logistic notebook) |
| Logistic regression | Sigmoid and log-odds, cross-entropy, regularization, non-linear boundaries, one class against the rest |
03_logistic_regression.ipynb — L1–L3
|
| Classification metrics | Confusion matrix, accuracy, precision, recall, |
04_classification_metrics.ipynb — C1
|
Data: Spambase (spam detection) and California housing (house prices), stored in datasets/ with the other datasets of the course (compressed CSV, see below).
Lab: lab03_linear_models.ipynb (helpers in lab03_utils.py): every model is a loss written with jax.numpy, trained with jax.grad and compared with its scikit-learn twin; solved and explained in solutions/lab03_linear_models_solution.ipynb.
Slides: slides/04_probabilistic_models.pdf · Lab guide: practice/04_probabilistic_models.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| Probability and maximum likelihood | Probability by counting, Bayes' rule, likelihood and NLL, Bernoulli and Gaussian MLE, losses as negative log-likelihoods | 01_mle_map.ipynb — M0–M3 |
| MAP | Beta prior and Laplace smoothing, Gaussian prior and ridge, the posterior of the weights | 01_mle_map.ipynb — M4–M5 |
| Naive Bayes, classification | Bayes' rule, independence, Bernoulli/categorical (discrete) and Gaussian or other (continuous) features, floats and log space, generative vs. discriminative | 02_naive_bayes_classification.ipynb — N1–N4 |
| Naive Bayes, regression | Binned target with expected value; continuous target (linear-Gaussian, closed-form posterior); discrete features; correlated evidence | 03_naive_bayes_regression.ipynb — R1–R4 |
| Probabilities and decisions | Log-loss, Brier score, reliability; Platt and isotonic calibration; cost-based thresholds | 02_naive_bayes_classification.ipynb — N5–N6 |
Lab: lab04_probabilistic_models.ipynb (helpers in lab04_utils.py): probability, MLE/MAP with jax.grad, Naive Bayes by counting, Naive Bayes regression, calibration and costs, each compared with its scikit-learn twin; solved and explained in solutions/lab04_probabilistic_models_solution.ipynb.
Slides: slides/05_svm_neural_networks.pdf · Lab guide: practice/05_svm_neural_networks.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| Support vector machines | Distance and margin, the maximum-margin line, support vectors, the slack and the soft margin, hinge loss + |
01_svm.ipynb — V1–V2
|
| Kernels | New features and the kernel trick, polynomial and RBF kernels, the Gram matrix, the representer form trained with jax.grad, |
01_svm.ipynb — V3
|
| SVM in practice |
|
01_svm.ipynb — V4–V5
|
| Neurons and networks | The neuron, layers as matrix products, non-linear activations, XOR, hidden units, universal approximation, the output layer and the loss by task |
02_neural_networks.ipynb — H1
|
| Backpropagation | The chain rule, a worked forward and backward pass, matrix form, vanishing gradients, cost |
02_neural_networks.ipynb — H2
|
| Training networks | Initialization, learning rate, optimizers, batch size, overfitting, weight decay, early stopping, dropout, seeds, Keras on JAX, regression |
02_neural_networks.ipynb — H3–H5
|
| Choosing a learner | Linear models, SVM and MLP on five datasets with the corrected resampled |
02_neural_networks.ipynb — H6
|
Data: breast cancer, digits, concrete, spam, wine quality, heart disease, abalone, auto-mpg, diabetes, German credit and California housing (all in datasets/), plus synthetic moons, circles and blobs.
Lab: lab05_svm_neural_networks.ipynb (helpers in lab05_utils.py): the SVM, the kernel SVM and the SVR as losses trained with jax.grad, a multilayer perceptron written in JAX with its backward pass by hand and compared with scikit-learn's MLPClassifier and a Keras network, and networks with Keras (JAX backend); solved and explained in solutions/lab05_svm_neural_networks_solution.ipynb.
Slides: slides/06_trees_knn.pdf · Lab guide: practice/06_trees_knn.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| Models without a formula | Linear model, tree, 1-NN and k-NN as sets of cells (half-planes, boxes, Voronoi cells), approximation of a circle, the price in dimension |
01_decision_trees.ipynb — B1
|
| Decision trees, classification | A tree as questions and as rules, impurity (Gini, entropy, error), the gain, the greedy algorithm, numeric thresholds by one sorted scan |
01_decision_trees.ipynb — T1–T2
|
| Feature types and encoding | Numeric, ordinal and nominal columns, encodings, questions on a category, distances between categories, many levels, missing values |
01_decision_trees.ipynb — T6
|
| Computational limits | Growth of the cost, P, NP, NP-complete, NP-hard, counting the trees, greedy against exhaustive search |
01_decision_trees.ipynb — T7
|
| Overfitting and pruning | Stopping rules, depth and leaf size on validation data, cost-complexity pruning |
01_decision_trees.ipynb — T3
|
| Regression trees | Variance reduction, the staircase, no extrapolation, trees against linear models |
01_decision_trees.ipynb — T4
|
| Instability and importances | Bootstrap trees, impurity against permutation importance, correlated and noise features |
01_decision_trees.ipynb — T5
|
| k-nearest neighbours | The algorithm, a worked example, distances, scaling, the choice of |
02_knn.ipynb — K1–K2
|
| KNN limits | The curse of dimensionality, irrelevant features, KNN for regression, cost of prediction (kd-tree, ball tree) |
02_knn.ipynb — K3–K5
|
| Faster KNN | Prototype selection (Hart, Wilson), approximate nearest neighbours with FAISS (IVF, HNSW, product quantization) |
02_knn.ipynb — K6
|
| Choosing a learner | Logistic regression, naive Bayes, SVM, tree and KNN on six data sets, with the corrected resampled |
02_knn.ipynb — K5
|
Data: breast cancer, German credit, heart disease, wine quality, digits, spam, concrete, abalone, auto-mpg and California housing (all in datasets/), plus synthetic moons.
Lab: lab06_trees_knn.ipynb (helpers in lab06_utils.py): Parts A to C in class (60 minutes), Parts D to H at home; impurity and the best split, a classification tree and a regression tree from scratch, pruning on validation data, KNN with jax.numpy for classification and regression, and a comparison on repeated splits; solved and explained in solutions/lab06_trees_knn_solution.ipynb.
Slides: slides/07_ensembles.pdf · Lab guide: practice/07_ensembles.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| Shallow models | MCC and MAE; frontiers of six shallow models on six planes, curves on six function families, the tables, bias, variance and overlapping errors | 01_shallow_models.ipynb — E1 |
| Why combining helps, voting | Condorcet, the variance of an average of correlated errors, the ambiguity identity, hard, soft and weighted votes, k-NN as a vote, failure cases | 02_voting.ipynb — E2 |
| Bagging | Bootstrap (63.2 %), out-of-bag score, random forests, max_features and the correlation of trees, bias and variance, importances, a stable learner |
03_bagging_forests.ipynb — E3 |
| Boosting | AdaBoost (weights, member weight), margins, gradient boosting by residuals, shrinkage, early stopping, HistGB, XGBoost, LightGBM, label noise | 04_boosting.ipynb — E4 |
| Meta models | Stacking, out-of-fold predictions, the leak, blending; neural stacking (two frozen networks and a head) | 05_stacking_neural.ipynb — E5 |
| Tuning | Parameters and hyperparameters, grid, random and TPE search with Optuna, pruning, hyperparameter importance, nested cross-validation | 06_tuning.ipynb — E6 |
| Real tables | Every family tuned on 11 real tables at full size, mean ranks, Friedman test, gain per family | 07_real_tables.ipynb — E7 |
| Is the gain real? | McNemar and Cochran's Q, paired permutation test and bootstrap interval, sign test and Wilcoxon for regression, corrected t-test, Friedman, Holm, Bayesian signed-rank | 08_significance.ipynb — E8 |
Data: generated planes, curves and tables from sklearn.datasets and faa.synthetic; spambase, wine quality, German credit, breast cancer, heart disease, California housing, abalone, concrete, diabetes and auto mpg (datasets/).
Lab: lab07_ensembles.ipynb (helpers in lab07_utils.py): Parts A to D in class (60 minutes), Parts E and F at home; hard and soft vote, bagging with the out-of-bag error, AdaBoost with stumps, gradient boosting with early stopping, stacking with out-of-fold predictions and pseudo-residuals with jax.grad; solved and explained in solutions/lab07_ensembles_solution.ipynb.
Slides: slides/09_blind_signal_separation.pdf · Lab guide: practice/09_blind_signal_separation.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| Mixtures and PCA | Two microphones, two sources; PCA on the cloud, EVR, reconstruction, why orthogonal directions cannot separate | 01_mixtures_pca.ipynb — B1 |
| ICA | Centring, whitening, kurtosis and negentropy, FastICA, permutation and sign with match, SNR |
02_ica.ipynb — C1 |
| NMF | Non-negative parts of a digit, multiplicative updates, MU and HALS, NNDSVD init, KL and Itakura–Saito | 03_nmf.ipynb — D1 |
| LSI and CF | Term-document matrix, tf-idf, latent topics, collaborative filtering with missing values (rwnmf), rank sweep |
04_lsi_cf.ipynb — E2 |
| Audio | Two-sine mixtures as signals, PCA, ICA and NMF compared by correlation and SNR | 05_audio.ipynb — E1 |
| Use cases | One task, three methods: spectrogram notes, digit strokes, denoising, classifier features, topics, soft clusters, blink removal, anomaly scores, imputation with every pyNNMF solver | 06_usecases.ipynb — E3 |
| Imputation | Collaborative filtering with baselines, rank and regularisation, cold start and ranking; LSI and NMF topics on BBC news, queries in the latent space; time series with block gaps and gap alignment; nine NMF starts on four problems | 07_imputation.ipynb — E4 |
Data: two-sine mixtures and the ratings toy from faa.bss; digits, MovieLens 100K, BBC news and the indoor climate series from datasets/.
Lab: lab09_bss.ipynb (helpers in lab09_utils.py): Parts A to D in class (60 minutes), Parts E and F at home; PCA by hand on the cloud and the digits, ICA by one kurtosis ascent, NMF multiplicative updates with the learned parts, collaborative filtering with missing values, LSI, and the use-case tournament (PCA, ICA and NMF on the same task); solved and explained in solutions/lab09_bss_solution.ipynb.
Slides: slides/10_clustering.pdf · Lab guide: practice/10_clustering.pdf
| Block | Contents | Demo notebook |
|---|---|---|
| Hard and soft | One-hot |
01_hard_soft.ipynb — A1
|
|
|
Lloyd's loop, |
02_kmeans_hier.ipynb — B1
|
| DBSCAN | Core, border and noise, min_samples sweeps, the kneeliverse), varying densities, high dimension |
03_dbscan.ipynb — C1
|
| Mixtures and fuzzy |
EM by hand, one E-step, four covariance structures, the fuzzifier, FCM against GMM against NMF, bad starts, collapsing components |
04_gmm_fcm.ipynb — D1
|
| Benchmark | Seven methods on six toy sets (moons, rings, blobs, stretched, unequal, noise), ten seeds, noise and scale |
05_benchmark.ipynb — E1
|
| Choosing |
Elbow with the Kneedle and L-method detectors of kneeliverse, silhouette, Calinski–Harabasz, Davies–Bouldin, gap statistic, AIC and BIC, stability over draws |
06_choosing_k.ipynb — F1
|
| Use cases | Wine segments, news topics, indoor-climate anomalies, a digit taxonomy |
07_usecases.ipynb — G1
|
Data: the six toy sets and fcm from faa.clustering; wine quality, BBC news, digits and the indoor climate series from datasets/.
Lab: lab10_clustering.ipynb (helpers in lab10_utils.py): Parts A to D in class (60 minutes), Parts E and F at home; NMF memberships, solutions/lab10_clustering_solution.ipynb.
Students choose one of two modes.
| Component | Weight | When |
|---|---|---|
| Theoretical Test 1 | 25% | Class 08 (05/06 Nov 2026), Topics 1–6 |
| Theoretical Test 2 | 25% | Class 14 (17/18 Dec 2026), Topics 7–10 |
| Project 1: the five classes of learners | 25% | Released Class 03 (01/02 Oct), due Class 08 (05/06 Nov) |
| Project 2: a game-playing agent | 25% | Released Class 09 (12/13 Nov), due Class 14 (17/18 Dec) |
| Component | Weight | When |
|---|---|---|
| Final Exam | 50% | Regular exam season (Época Normal) |
| Comprehensive Project | 50% | Project delivery and defense |
The notebooks run in a local virtual environment named venv/ at the repository root, created with make venv. Use the Makefile rather than installing packages by hand, so that everyone has the same environment. The dependencies are declared in pyproject.toml; the repository is not a Python package, so the install step only pulls the dependencies.
git clone https://github.com/detiuaveiro/faa.git && cd faa
export KERAS_BACKEND=jax # add this line to ~/.bashrc
make venv # NumPy against the system OpenBLAS if available, else the wheel
source venv/bin/activate
jupyter lab notebooks/make venv works on any system. If pkg-config finds OpenBLAS and a C/C++ compiler is installed, it builds NumPy from source against the system OpenBLAS, tuned to the local CPU (cpu-baseline=native); otherwise, or if that build fails, it falls back to the prebuilt NumPy wheel (bundled OpenBLAS, slightly slower on some CPUs). It then installs everything else. To enable the source build:
| System | Prerequisites |
|---|---|
| Debian/Ubuntu/WSL | sudo apt install python3-venv build-essential pkg-config libopenblas-dev |
| macOS | brew install openblas pkg-config (Xcode command-line tools for the compiler) |
| Slackware | openblas package |
make venv NUMPY_SOURCE=no forces the wheel; NUMPY_SOURCE=yes forces the source build and fails if it does not work. Plain python3 -m venv venv && source venv/bin/activate && pip install -e . is equivalent to the wheel path.
If make venv fails or the notebooks do not run, notify the professor (mario.antunes@ua.pt) with your operating system, the output of python3 --version and the last lines of the error.
Software stack
| Role | Libraries |
|---|---|
| Acceleration | NumPy (OpenBLAS; compiled locally by make venv when possible), JAX |
| Machine learning | scikit-learn; Keras 3 on the JAX backend (no TensorFlow or PyTorch) |
| Parallelization | joblib |
| Data handling | polars |
| Plotting | matplotlib, seaborn |
| Group libraries | pyBlindOpt, EmptySpaceSearch, kneeliverse, pyUTSAlgorithms, pyNNMF |
| Presentation | JupyterLab |
Linters, type checkers and hook tools (ruff, basedpyright, vulture, pre-commit, nbstripout) are expected to be installed system-wide (e.g. uv tool install nbstripout) and are not listed in pyproject.toml.
| Path | Contents |
|---|---|
slides/ |
Lectures in Pandoc Markdown with inline TikZ figures, compiled to Beamer PDFs (moloch theme) |
notebooks/ |
Jupyter notebooks, one folder per class |
src/faa/ |
The small package every notebook imports (pip install -e .): notebook setup (demo), plot style and plotlib.save (shows a figure in the notebook and stores the transparent PDF of the slide), data loaders, generated sets, model galleries, boundary and curve panels |
datasets/ |
Real, small datasets as zstd-compressed CSV (*.csv.zst, read directly with polars.read_csv); sources and columns in datasets/README.md |
practice/ |
Lab guides in Pandoc Markdown, compiled to A4 PDFs |
solutions/ |
Solved lab notebooks with step-by-step explanations (try the lab first) |
projects/ |
Project specifications |
assets/ |
Logo, banner, and figures |
Makefile, Makefile.inc |
Build system: make all compiles every PDF (intermediate files cached in /dev/shm); make venv creates the Python environment |
.pre-commit-config.yaml |
Quality gate: formatting checks, notebook outputs stripped (nbstripout), ruff on notebooks, and a full build |
pyproject.toml |
Python dependencies and the package faa (pip install -e .) and ruff/basedpyright configuration |
- David J. C. MacKay, Information Theory, Inference, and Learning Algorithms, Cambridge University Press, 2003. Online edition
- Gareth James, Daniela Witten, Trevor Hastie, Robert Tibshirani, and Jonathan Taylor, An Introduction to Statistical Learning with Applications in Python, Springer, 2023. statlearning.com
- Christopher M. Bishop, Pattern Recognition and Machine Learning, Springer, 2006. Online edition
- David Barber, Bayesian Reasoning and Machine Learning, Cambridge University Press, 2012. Online edition
- Ian Goodfellow, Yoshua Bengio, and Aaron Courville, Deep Learning, MIT Press, 2016. deeplearningbook.org
- Richard S. Sutton and Andrew G. Barto, Reinforcement Learning: An Introduction, 2nd ed., MIT Press, 2018. Online edition
- Nate Silver, The Signal and the Noise: Why So Many Predictions Fail — but Some Don't, Penguin, 2012.
- Author: Mário Antunes (
mario.antunes@ua.pt) - License: MIT — see LICENSE.