Marovi AI - User contributions [en]

Template:LanguageBar

2026-04-24T07:09:32Z

DeployBot: [deploy-bot] Improve LanguageBar: show all languages, dim the ones without translation (v1.2.0)

<noinclude>
Language navigation bar. Usage:
<pre>
{{LanguageBar | page = Gradient Descent}}
</pre>
Marks the current language bold; renders links for available translations
and plain text (dimmed) for languages without a translation.
</noinclude><includeonly><div style="background: #f0f0f0; border: 1px solid #ddd; padding: 4px 8px; margin-bottom: 1em; font-size: 90%;">'''Languages:''' {{#ifeq:{{SUBPAGENAME}}|{{{page}}}|'''English'''|[[{{{page}}}|English]]}} | {{#ifexist:{{{page}}}/es|{{#ifeq:{{FULLPAGENAME}}|{{{page}}}/es|'''Español'''|[[{{{page}}}/es|Español]]}}|<span style="color:#888;">Español</span>}} | {{#ifexist:{{{page}}}/zh|{{#ifeq:{{FULLPAGENAME}}|{{{page}}}/zh|'''中文'''|[[{{{page}}}/zh|中文]]}}|<span style="color:#888;">中文</span>}}</div></includeonly>

Template:RecentArticles

2026-04-24T07:09:17Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

* [[Word Embeddings]]
* [[Transfer Learning]]
* [[Stochastic Gradient Descent]]
* [[Softmax Function]]
* [[Recurrent Neural Networks]]
* [[Overfitting and Regularization]]
* [[Neural Networks]]
* [[Loss Functions]]
* [[Linear Regression]]
* [[Gradient Descent]]

Neural Networks/zh

2026-04-24T07:09:02Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Neural Networks}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''神经网络（Neural Networks）'''（也称为'''人工神经网络'''，即ANN）是受生物神经系统结构启发的计算模型。它们由称为'''神经元（Neuron）'''（或节点）的简单处理单元组成的互连层构成，是现代深度学习（Deep Learning）的基础。

== 生物学启发 ==

生物神经元通过其'''树突（Dendrite）'''接收电信号，在'''细胞体'''中进行整合，如果综合信号超过阈值，则沿其'''轴突（Axon）'''向下游神经元发送输出信号。人工神经网络对这一过程进行了抽象：每个人工神经元计算其输入的加权和，加上一个偏置项，然后通过一个非线性的'''激活函数（Activation Function）'''传递结果。

虽然与生物学的类比激发了早期研究，但现代神经网络最好被理解为灵活的参数化函数逼近器，而非忠实的大脑模拟。

== 感知机 ==

'''感知机（Perceptron）'''由Frank Rosenblatt于1958年提出，是最简单的神经网络。它计算：

:<math>y = \sigma\!\left(\sum_{i=1}^{n} w_i x_i + b\right) = \sigma(\mathbf{w}^\top \mathbf{x} + b)</math>

其中 <math>\mathbf{x}</math> 是输入向量，<math>\mathbf{w}</math> 是可学习的权重，<math>b</math> 是偏置，<math>\sigma</math> 是一个阶跃函数，当参数为正时输出1，否则输出0。感知机可以学习任何线性可分函数，但众所周知无法表示异或（XOR）函数——这一局限性使神经网络研究停滞了十多年。

== 前馈网络 ==

'''前馈神经网络（Feedforward Neural Network）'''（也称为'''多层感知机'''，即MLP）将多层神经元堆叠在一起。信息单向流动——从'''输入层'''经过一个或多个'''隐藏层（Hidden Layer）'''到达'''输出层'''。

对于具有一个隐藏层的网络，计算过程为：

:<math>\mathbf{h} = g(\mathbf{W}_1 \mathbf{x} + \mathbf{b}_1)</math>

:<math>\mathbf{y} = f(\mathbf{W}_2 \mathbf{h} + \mathbf{b}_2)</math>

其中 <math>g</math> 和 <math>f</math> 是激活函数，<math>\mathbf{W}_1, \mathbf{W}_2</math> 是权重矩阵，<math>\mathbf{b}_1, \mathbf{b}_2</math> 是偏置向量。隐藏层使网络能够学习单个感知机无法捕捉的非线性关系。

具有多个隐藏层的网络称为'''深度'''神经网络，训练它们是'''深度学习'''的研究主题。

== 激活函数 ==

激活函数引入了非线性；没有它，多层网络将退化为单个线性变换。常见的选择包括：

{| class="wikitable"
|-
! 函数 !! 公式 !! 值域 !! 备注
|-
| '''Sigmoid''' || <math>\sigma(z) = \frac{1}{1+e^{-z}}</math> || (0, 1) || 历史上广泛使用；存在梯度消失问题
|-
| '''Tanh''' || <math>\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}</math> || (−1, 1) || 以零为中心；对于大输入仍会饱和
|-
| '''ReLU''' || <math>\max(0, z)</math> || [0, ∞) || 现代网络的默认选择；可能导致"死亡神经元"
|-
| '''Leaky ReLU''' || <math>\max(\alpha z, z)</math>，其中 <math>\alpha > 0</math> 较小 || (−∞, ∞) || 解决了死亡神经元问题
|-
| '''Softmax''' || <math>\frac{e^{z_i}}{\sum_j e^{z_j}}</math> || (0, 1) || 用于多分类任务的输出层
|}

== 万能近似定理 ==

'''万能近似定理（Universal Approximation Theorem）'''（Cybenko 1989，Hornik 1991）指出，一个包含有限个神经元的单隐藏层前馈网络，在激活函数满足温和条件（例如非常数、有界、连续）的前提下，可以在 <math>\mathbb{R}^n</math> 的紧子集上以任意精度逼近任何连续函数。

该定理保证了良好近似的''存在性''，但没有说明如何''找到''它——在实践中，训练具有多层的深度网络比使用单个宽层要有效得多。

== 训练概述 ==

训练神经网络包括以下步骤：

# '''定义损失函数（Loss Function）''' — 衡量网络预测与真实目标之间差距的指标（参见[[Loss Functions]]）。
# '''前向传播''' — 逐层传播数值，计算给定输入的网络输出。
# '''反向传播（Backpropagation）''' — 通过在网络中反向应用链式法则，计算损失相对于每个权重的梯度（参见[[Backpropagation]]）。
# '''参数更新''' — 使用[[Gradient Descent|梯度下降]]等优化算法调整权重。
# '''迭代''' — 在训练数据上重复步骤2-4多次遍历（轮次/Epoch）。

成功的训练还需要注意'''初始化'''（例如Xavier或He方案）、'''正则化（Regularization）'''（以防止[[Overfitting and Regularization|过拟合]]）以及'''超参数调优'''（学习率、批量大小、网络架构）。

== 常见架构 ==

除了基本的前馈网络，还发展出了几种专门的架构：

* '''[[Convolutional Neural Networks|卷积神经网络]]'''（CNN）— 专为图像等网格结构数据设计，使用局部连接和权重共享。
* '''[[Recurrent Neural Networks|循环神经网络]]'''（RNN）— 专为序列数据设计，具有形成循环的连接以维持隐藏状态。
* '''Transformer''' — 基于注意力机制的架构，已在自然语言处理中占据主导地位，并越来越多地应用于视觉领域。
* '''自编码器（Autoencoder）''' — 训练重建其输入的网络，用于降维和生成建模。
* '''生成对抗网络（GAN）''' — 一对网络（生成器和判别器）通过竞争训练来生成逼真的数据。

== 应用 ==

神经网络被应用于广泛的领域：

* 计算机视觉（图像分类、目标检测、语义分割）
* 自然语言处理（翻译、摘要、问答）
* 语音识别与合成
* 游戏博弈（AlphaGo、Atari智能体）
* 科学发现（蛋白质折叠、药物设计、天气预测）
* 自动驾驶与机器人

== 参见 ==

* [[Gradient Descent]]
* [[Backpropagation]]
* [[Loss Functions]]
* [[Convolutional Neural Networks]]
* [[Recurrent Neural Networks]]
* [[Overfitting and Regularization]]

== 参考文献 ==

* Rosenblatt, F. (1958). "The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain". ''Psychological Review''.
* Cybenko, G. (1989). "Approximation by Superpositions of a Sigmoidal Function". ''Mathematics of Control, Signals, and Systems''.
* Hornik, K. (1991). "Approximation Capabilities of Multilayer Feedforward Networks". ''Neural Networks''.
* LeCun, Y., Bengio, Y. and Hinton, G. (2015). "Deep learning". ''Nature'', 521, 436–444.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning''. MIT Press.

[[Category:Deep Learning]]
[[Category:Introductory]]
[[Category:Neural Networks]]

Gradient Descent/zh

2026-04-24T07:09:02Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Gradient Descent}}
{{ArticleInfobox | topic_area = Optimization | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''梯度下降（Gradient Descent）'''是一种用于求解可微函数局部最小值的一阶迭代优化算法。它是几乎所有现代机器学习训练过程的基础，从简单的线性回归（Linear Regression）到拥有数十亿参数的深度神经网络。

== 直觉理解 ==

想象你站在浓雾弥漫的山坡上。你看不到谷底，但能感受到脚下的坡度。最自然的策略就是朝最陡峭的下坡方向迈出一步，然后重新评估。梯度下降正是将这一想法形式化：在每一步中，算法计算函数最陡上升方向（即'''梯度'''），然后朝相反方向移动。

每步的大小由一个标量控制，称为'''学习率（Learning Rate）'''（通常记为 <math>\eta</math>）。较大的学习率前进速度快，但有越过最小值的风险；较小的学习率收敛更可靠，但可能需要过多的步数。

== 数学公式 ==

给定一个可微的目标函数 <math>f:\mathbb{R}^n \to \mathbb{R}</math>，梯度下降通过以下'''更新规则'''生成一系列迭代点：

:<math>\theta_{t+1} = \theta_t - \eta \, \nabla f(\theta_t)</math>

其中 <math>\nabla f(\theta_t)</math> 是在当前点 <math>\theta_t</math> 处计算的梯度向量，<math>\eta > 0</math> 是学习率。

在一维情况下，公式简化为：

:<math>\theta_{t+1} = \theta_t - \eta \, f'(\theta_t)</math>

梯度 <math>\nabla f</math> 指向最陡上升方向，因此减去它会使迭代点向下移动。

== 批量、随机和小批量变体 ==

当目标函数具有数据点平均值的形式时，

:<math>f(\theta) = \frac{1}{N}\sum_{i=1}^{N} \ell(\theta;\, x_i, y_i)</math>

三种常见策略在用多少数据来估计梯度方面有所不同：

{| class="wikitable"
|-
! 变体 !! 梯度计算范围 !! 每步计算成本 !! 梯度噪声
|-
| '''批量（全量）梯度下降''' || 所有 <math>N</math> 个样本 || 高 || 无
|-
| '''随机梯度下降（SGD）''' || 1个随机样本 || 低 || 高
|-
| '''小批量梯度下降（Mini-batch Gradient Descent）''' || <math>B</math> 个随机样本（<math>1 < B < N</math>） || 中 || 中
|}

全量批量梯度下降计算精确梯度，因此沿着平滑轨迹向最小值移动。[[Stochastic Gradient Descent|随机梯度下降]]使用单个样本来估计梯度，大幅减少每步计算量，但代价是轨迹更加嘈杂。小批量梯度下降在两者之间取得平衡，是实践中最常见的选择，典型的批量大小在32到512之间。

== 收敛性 ==

=== 凸函数 ===

对于具有利普希茨连续梯度（常数 <math>L</math>）的凸函数（Convex Function），使用固定学习率 <math>\eta \leq 1/L</math> 的梯度下降以 <math>O(1/t)</math> 的速率收敛。如果函数还具有参数 <math>\mu > 0</math> 的'''强凸性'''，则收敛加速为线性（指数）速率：

:<math>f(\theta_t) - f(\theta^*) \leq \left(1 - \frac{\mu}{L}\right)^t \bigl(f(\theta_0) - f(\theta^*)\bigr)</math>

比值 <math>\kappa = L / \mu</math> 称为'''条件数（Condition Number）'''，它决定了算法收敛的速度。病态问题（较大的 <math>\kappa</math>）收敛缓慢。

=== 非凸函数 ===

大多数深度学习目标函数是非凸的。在这种情况下，梯度下降只能保证收敛到驻点（Stationary Point）（其中 <math>\nabla f = 0</math>），这可能是局部最小值、鞍点（Saddle Point），甚至是局部最大值。在实践中，高维空间中鞍点比局部最小值更成问题。

== 学习率选择 ==

选择学习率是最重要的实际决策之一：

* '''过大''' — 迭代点振荡或发散。
* '''过小''' — 收敛速度慢得无法接受。
* '''学习率调度（Learning Rate Schedule）''' — 许多实践者从较大的学习率开始，随时间逐渐减小（阶梯衰减、指数衰减、余弦退火）。
* '''线搜索（Line Search）''' — 经典数值方法在每步选择 <math>\eta</math> 以满足沃尔夫条件或阿米霍条件等，但这在深度学习中很少使用。

一种常用的启发式方法是在对数尺度上尝试多个值（例如 <math>10^{-1}, 10^{-2}, 10^{-3}</math>），然后选择在不产生不稳定性的前提下损失下降最快的那个。

== 扩展与改进 ==

几种重要的改进方法解决了原始梯度下降的局限性：

* '''动量（Momentum）''' — 从过去的梯度中积累速度向量，帮助在峡谷状地形中加速收敛。
* '''涅斯捷罗夫加速梯度（Nesterov Accelerated Gradient）''' — 一种动量变体，在前瞻位置评估梯度，具有更好的理论收敛速率。
* '''自适应方法（Adaptive Methods）'''（Adagrad、RMSProp、Adam）— 根据梯度历史为每个参数维护自适应学习率。
* '''二阶方法（Second-order Methods）''' — 如牛顿法和L-BFGS等算法使用曲率信息（海森矩阵或其近似）以加速收敛，但对大规模问题通常计算成本过高。

== 实践技巧 ==

* '''特征缩放（Feature Scaling）''' — 归一化输入特征使其具有相似的范围可以显著改善收敛性，因为损失曲面变得更加各向同性。
* '''梯度裁剪（Gradient Clipping）''' — 限制梯度的范数以防止过大的更新。
* '''随机初始化''' — 从合理的随机初始化开始（例如神经网络中的Xavier或He初始化）可以避免对称性破缺问题。
* '''监控损失曲线''' — 绘制训练损失随迭代次数的变化是最简单的诊断方法：平滑下降的曲线表示训练健康；振荡则表明学习率过高。

== 应用 ==

梯度下降及其变体广泛应用于科学和工程领域：

* 训练机器学习模型（线性模型、神经网络、支持向量机）
* 信号处理与控制系统
* 物理和成像中的逆问题
* 运筹学和物流优化
* 经济学和博弈论均衡计算

== 参见 ==

* [[Stochastic Gradient Descent]]
* [[Backpropagation]]
* [[Loss Functions]]
* [[Neural Networks]]
* [[Overfitting and Regularization]]

== 参考文献 ==

* Cauchy, A. (1847). "Méthode générale pour la résolution des systèmes d'équations simultanées". ''Comptes Rendus de l'Académie des Sciences''.
* Boyd, S. and Vandenberghe, L. (2004). ''Convex Optimization''. Cambridge University Press.
* Ruder, S. (2016). "An overview of gradient descent optimization algorithms". ''arXiv:1609.04747''.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 8. MIT Press.

[[Category:Optimization]]
[[Category:Introductory]]

Convolutional Neural Networks/zh

2026-04-24T07:09:02Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Convolutional Neural Networks}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Backpropagation]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''卷积神经网络（Convolutional Neural Network）'''（'''CNN'''或'''ConvNet'''）是一类专门用于处理具有网格状拓扑结构数据的深度[[Neural Networks|神经网络]]，例如图像（二维像素网格）、音频频谱图和视频。它们通过局部连接、权重共享和池化来利用输入的空间结构，使其在视觉和空间任务上比全连接网络高效得多。

== 卷积运算 ==

核心构建模块是'''离散卷积（Discrete Convolution）'''。对于二维输入 <math>\mathbf{X}</math> 和大小为 <math>k \times k</math> 的滤波器（卷积核） <math>\mathbf{K}</math>，输出特征图 <math>\mathbf{Y}</math> 为：

:<math>Y_{i,j} = \sum_{m=0}^{k-1}\sum_{n=0}^{k-1} K_{m,n} \cdot X_{i+m,\, j+n} + b</math>

其中 <math>b</math> 是偏置项。滤波器在输入上滑动（卷积），在每个位置计算点积。严格来说，大多数实现计算的是'''互相关（Cross-correlation）'''而非真正的卷积（后者会翻转卷积核），但由于卷积核权重是学习得到的，这一区别无关紧要。

控制卷积的关键超参数：

* '''卷积核大小''' — 滤波器的空间范围（例如 <math>3 \times 3</math>，<math>5 \times 5</math>）。
* '''步幅（Stride）''' — 卷积核连续位置之间的步长。步幅为2会将空间维度减半。
* '''填充（Padding）''' — 在输入边界周围添加零来控制输出大小。"Same"填充保持空间维度不变；"Valid"填充不使用填充。

== 滤波器与特征检测 ==

每个滤波器学习检测特定的局部模式。在早期层中，滤波器通常对边缘、角点和颜色梯度有响应。更深的层将这些组合成更高级的特征——纹理、部件，最终是完整的物体。

卷积层并行应用多个滤波器，生成一叠特征图。如果输入有 <math>C_{\text{in}}</math> 个通道，该层有 <math>C_{\text{out}}</math> 个滤波器，则可学习参数的总数为：

:<math>C_{\text{out}} \times (C_{\text{in}} \times k^2 + 1)</math>

这比具有相同输入和输出维度的全连接层少得多，因为权重在所有空间位置上是共享的。

== 池化 ==

'''池化（Pooling）'''层对特征图进行下采样，减小其空间维度并提供一定程度的平移不变性。常见的池化操作：

* '''最大池化（Max Pooling）''' — 取每个局部窗口（例如 <math>2 \times 2</math>）中的最大值。
* '''平均池化（Average Pooling）''' — 取每个窗口中的平均值。
* '''全局平均池化（Global Average Pooling）''' — 将每个完整的特征图平均为单个值，通常在最终分类层之前使用。

池化减少了计算成本，并通过逐步抽象表示来帮助防止过拟合。

== CNN的架构 ==

典型的CNN交替使用卷积层和池化层，然后接一个或多个全连接层用于最终预测：

<pre>
Input → [Conv → ReLU → Pool] × N → Flatten → FC → FC → Output
</pre>

每个卷积-池化模块提取越来越抽象的特征，而全连接层将它们组合用于分类或回归。

== 里程碑架构 ==

{| class="wikitable"
|-
! 架构 !! 年份 !! 关键贡献 !! 深度
|-
| '''LeNet-5''' || 1998 || 开创了CNN用于手写数字识别（MNIST） || 5层
|-
| '''AlexNet''' || 2012 || 赢得ImageNet竞赛；推广了ReLU、Dropout、GPU训练 || 8层
|-
| '''VGGNet''' || 2014 || 证明深度很重要；全程仅使用 <math>3 \times 3</math> 滤波器 || 16-19层
|-
| '''GoogLeNet（Inception）''' || 2014 || 引入了具有并行滤波器大小的Inception模块 || 22层
|-
| '''ResNet''' || 2015 || 引入残差连接，使极深网络的训练成为可能 || 50-152+层
|-
| '''DenseNet''' || 2017 || 通过密集块将每层与所有后续层连接 || 121-264层
|-
| '''EfficientNet''' || 2019 || 对深度、宽度和分辨率进行复合缩放 || 可变
|}

=== 残差连接 ===

ResNet引入的'''残差连接（Residual Connection）'''（或跳跃连接）将模块的输入直接加到其输出上：

:<math>\mathbf{y} = \mathcal{F}(\mathbf{x}) + \mathbf{x}</math>

这使得梯度可以直接通过恒等路径流动，缓解了梯度消失问题，使得训练数百层的网络成为可能。残差连接已成为几乎所有现代架构的标准组件。

== 计算机视觉中的应用 ==

CNN在广泛的视觉任务中取得了最先进的性能：

* '''图像分类''' — 为整张图像分配标签（ImageNet、CIFAR）。
* '''目标检测（Object Detection）''' — 在图像中定位和分类目标（YOLO、Faster R-CNN、SSD）。
* '''语义分割（Semantic Segmentation）''' — 为每个像素分配类别标签（U-Net、DeepLab）。
* '''实例分割（Instance Segmentation）''' — 区分物体的各个实例（Mask R-CNN）。
* '''图像生成''' — 使用基于CNN的生成器生成逼真图像（GAN、扩散模型）。
* '''医学影像''' — 肿瘤检测、视网膜分析和放射学筛查。

== 实践技巧 ==

* 当标注数据有限时，使用预训练模型（迁移学习/Transfer Learning）。
* 优先使用堆叠的小卷积核（<math>3 \times 3</math>）——两个 <math>3 \times 3</math> 层与一个 <math>5 \times 5</math> 层具有相同的感受野（Receptive Field），但参数更少。
* 在卷积之后、激活之前应用批量归一化（Batch Normalization）。
* 大量使用数据增强（Data Augmentation）以减少[[Overfitting and Regularization|过拟合]]。
* 用全局平均池化替代全连接层以减少参数数量。

== 参见 ==

* [[Neural Networks]]
* [[Backpropagation]]
* [[Overfitting and Regularization]]
* [[Recurrent Neural Networks]]
* [[Gradient Descent]]

== 参考文献 ==

* LeCun, Y. et al. (1998). "Gradient-Based Learning Applied to Document Recognition". ''Proceedings of the IEEE''.
* Krizhevsky, A., Sutskever, I. and Hinton, G. E. (2012). "ImageNet Classification with Deep Convolutional Neural Networks". ''NeurIPS''.
* Simonyan, K. and Zisserman, A. (2015). "Very Deep Convolutional Networks for Large-Scale Image Recognition". ''ICLR''.
* He, K. et al. (2016). "Deep Residual Learning for Image Recognition". ''CVPR''.
* Tan, M. and Le, Q. V. (2019). "EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks". ''ICML''.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Backpropagation/zh

2026-04-24T07:09:02Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Backpropagation}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Gradient Descent]], [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''反向传播（Backpropagation）'''（'''误差反向传播'''的缩写）是一种高效计算损失函数相对于神经网络中每个权重的梯度的算法。它与[[Gradient Descent|梯度下降]]等优化方法相结合，构成了现代深度学习模型的标准训练过程。

== 链式法则 ==

反向传播本质上是微积分中'''链式法则（Chain Rule）'''的应用。如果变量 <math>z</math> 依赖于 <math>y</math>，而 <math>y</math> 又依赖于 <math>x</math>，则：

:<math>\frac{\partial z}{\partial x} = \frac{\partial z}{\partial y} \cdot \frac{\partial y}{\partial x}</math>

在神经网络中，损失 <math>L</math> 依赖于输出，输出依赖于最后一个隐藏层的激活值，激活值又依赖于前一层的激活值，以此类推直到输入。链式法则允许我们将梯度分解为局部导数的乘积，每一层对应一个。

== 前向传播 ==

在前向传播过程中，输入数据逐层通过网络传播。对于全连接层 <math>l</math>：

:<math>\mathbf{z}^{(l)} = \mathbf{W}^{(l)} \mathbf{a}^{(l-1)} + \mathbf{b}^{(l)}</math>

:<math>\mathbf{a}^{(l)} = g^{(l)}(\mathbf{z}^{(l)})</math>

其中 <math>\mathbf{a}^{(l-1)}</math> 是前一层的激活值（<math>\mathbf{a}^{(0)} = \mathbf{x}</math>），<math>\mathbf{W}^{(l)}</math> 和 <math>\mathbf{b}^{(l)}</math> 是权重和偏置，<math>g^{(l)}</math> 是激活函数。前向传播存储所有中间值 <math>\mathbf{z}^{(l)}</math> 和 <math>\mathbf{a}^{(l)}</math>，因为它们在反向传播过程中需要使用。

== 反向传播过程 ==

反向传播从损失开始向输入方向计算梯度。定义第 <math>l</math> 层的误差信号为：

:<math>\boldsymbol{\delta}^{(l)} = \frac{\partial L}{\partial \mathbf{z}^{(l)}}</math>

对于输出层（第 <math>L_{\text{out}}</math> 层）：

:<math>\boldsymbol{\delta}^{(L_{\text{out}})} = \frac{\partial L}{\partial \mathbf{a}^{(L_{\text{out}})}} \odot g'^{(L_{\text{out}})}(\mathbf{z}^{(L_{\text{out}})})</math>

对于每个更早的层，误差向后传播：

:<math>\boldsymbol{\delta}^{(l)} = \bigl(\mathbf{W}^{(l+1)}\bigr)^\top \boldsymbol{\delta}^{(l+1)} \odot g'^{(l)}(\mathbf{z}^{(l)})</math>

其中 <math>\odot</math> 表示逐元素乘法。一旦知道误差信号，参数梯度为：

:<math>\frac{\partial L}{\partial \mathbf{W}^{(l)}} = \boldsymbol{\delta}^{(l)} \bigl(\mathbf{a}^{(l-1)}\bigr)^\top, \qquad \frac{\partial L}{\partial \mathbf{b}^{(l)}} = \boldsymbol{\delta}^{(l)}</math>

== 计算图 ==

现代深度学习框架（PyTorch、TensorFlow、JAX）通过构建'''计算图（Computational Graph）'''来实现反向传播——这是一个有向无环图，其中每个节点表示一个运算，每条边传递一个张量。前向传播构建计算图；反向传播按逆拓扑排序遍历它，在每个节点应用链式法则。

这种抽象使得对任意运算组合进行微分成为可能，而不仅限于标准层类型。存在两种实现策略：

* '''静态图''' — 在执行前一次性定义图（早期的TensorFlow）。允许激进的编译器优化，但灵活性较低。
* '''动态图''' — 在每次前向传播时重建图（PyTorch、TensorFlow Eager模式）。更便于调试和处理依赖数据的控制流模型。

== 自动微分 ==

反向传播是'''反向模式自动微分（Reverse-mode Automatic Differentiation）'''（AD）的特例。与数值微分（近似的）或符号微分（可能产生冗长的表达式）不同，自动微分通过系统地对基本运算应用链式法则来计算精确导数。

反向模式自动微分可以在单次反向传播中计算标量输出相对于所有输入的梯度，这使其非常适合神经网络——损失是标量，但参数数量达到数百万。

反向传播的计算成本通常是前向传播的2-3倍，因为它必须评估局部雅可比矩阵（Jacobian）并将其与传入的误差信号相乘。

== 梯度消失与梯度爆炸 ==

当网络层数很多时，梯度是许多局部导数的乘积。如果这些因子持续小于1，梯度会指数级地趋向于零——即'''梯度消失（Vanishing Gradient）'''问题。如果它们持续大于1，梯度会指数级增长——即'''梯度爆炸（Exploding Gradient）'''问题。

{| class="wikitable"
|-
! 问题 !! 症状 !! 常见缓解措施
|-
| '''梯度消失''' || 早期层学习极其缓慢 || ReLU激活函数、残差连接、批量归一化、精心初始化
|-
| '''梯度爆炸''' || 损失发散或产生NaN值 || 梯度裁剪、权重正则化、降低学习率
|}

在引入ReLU激活函数、残差连接（ResNet）和归一化技术之前，这些问题是训练深度网络的主要障碍。

== 实践注意事项 ==

* '''内存''' — 前向传播必须存储所有中间激活值以供反向传播使用。对于非常深的网络，这可能是不可承受的；'''梯度检查点（Gradient Checkpointing）'''通过在反向传播时重新计算激活值来以计算换取内存。
* '''数值稳定性''' — 使用log-sum-exp技巧和融合的softmax-交叉熵实现可以避免上溢和下溢。
* '''高阶梯度''' — 对反向传播本身再求导可以得到二阶信息（海森向量积），这对自然梯度下降和元学习（Meta-learning）等方法很有用。
* '''混合精度（Mixed Precision）''' — 在半精度下执行前向传播，同时保持权重的全精度主副本，可以在现代GPU上加速训练。

== 历史发展 ==

反向传播背后的关键思想由多位研究者独立发展。Seppo Linnainmaa于1970年描述了反向模式自动微分。Paul Werbos在1974年的博士论文中将其应用于神经网络。该算法在Rumelhart、Hinton和Williams于1986年发表的有影响力的论文之后获得了广泛采用，该论文展示了它在多层网络上的有效性。

== 参见 ==

* [[Gradient Descent]]
* [[Stochastic Gradient Descent]]
* [[Neural Networks]]
* [[Loss Functions]]
* [[Convolutional Neural Networks]]
* [[Recurrent Neural Networks]]

== 参考文献 ==

* Rumelhart, D. E., Hinton, G. E. and Williams, R. J. (1986). "Learning representations by back-propagating errors". ''Nature'', 323, 533–536.
* Linnainmaa, S. (1970). "The representation of the cumulative rounding error of an algorithm as a Taylor expansion of the local rounding errors". Master's thesis, University of Helsinki.
* Werbos, P. J. (1974). "Beyond Regression: New Tools for Prediction and Analysis in the Behavioral Sciences". PhD thesis, Harvard University.
* Baydin, A. G. et al. (2018). "Automatic Differentiation in Machine Learning: a Survey". ''JMLR'', 18(153), 1–43.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 6. MIT Press.

[[Category:Deep Learning]]
[[Category:Intermediate]]

Attention Mechanisms/zh

2026-04-24T07:09:02Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Attention Mechanisms}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Advanced | prerequisites = [[Neural Networks]], [[Recurrent Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''注意力机制（Attention Mechanism）'''是一组允许神经网络在生成每个输出元素时选择性地关注输入相关部分的技术。注意力机制最初被引入以克服序列到序列模型中固定长度上下文向量的局限性，如今已成为[[Transformer]]等现代架构的基础构建模块。

== 动机 ==

早期的序列到序列（Sequence-to-Sequence）模型使用[[Recurrent Neural Networks|循环神经网络]]将整个输入序列编码为单个固定维度的向量。这一'''瓶颈'''迫使长距离依赖关系被压缩到一个固定大小的向量中，导致在长序列上性能下降。注意力机制通过让解码器在每个生成步骤中查阅每个编码器隐藏状态来解决这一问题，根据学习到的相关性分数对它们进行加权。

== Bahdanau（加性）注意力 ==

Bahdanau等人（2015）提出了第一个被广泛采用的机器翻译注意力机制。给定编码器隐藏状态 <math>h_1, \dots, h_T</math> 和解码器状态 <math>s_{t-1}</math>，对齐分数计算为：

:<math>e_{t,i} = v^{\!\top} \tanh(W_s\, s_{t-1} + W_h\, h_i)</math>

其中 <math>W_s</math>、<math>W_h</math> 和 <math>v</math> 是可学习参数。注意力权重通过应用softmax获得：

:<math>\alpha_{t,i} = \frac{\exp(e_{t,i})}{\sum_{j=1}^{T} \exp(e_{t,j})}</math>

上下文向量是加权和 <math>c_t = \sum_{i=1}^{T} \alpha_{t,i}\, h_i</math>，它与 <math>s_{t-1}</math> 拼接后输入解码器。

== Luong（乘性）注意力 ==

Luong等人（2015）通过用点积或双线性形式替换加性网络来简化评分函数：

{| class="wikitable"
|-
! 变体 !! 评分函数
|-
| 点积（Dot） || <math>e_{t,i} = s_t^{\!\top} h_i</math>
|-
| 一般（General） || <math>e_{t,i} = s_t^{\!\top} W_a\, h_i</math>
|-
| 拼接（Concat） || <math>e_{t,i} = v^{\!\top} \tanh(W_a [s_t;\, h_i])</math>
|}

点积变体要求编码器和解码器维度匹配，而一般变体引入了一个可学习的权重矩阵 <math>W_a</math>。

== 缩放点积注意力 ==

Vaswani等人（2017）引入了Transformer中使用的公式。给定查询（Query）矩阵 <math>Q</math>、键（Key）矩阵 <math>K</math> 和值（Value）矩阵 <math>V</math>：

:<math>\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\!\left(\frac{Q K^{\!\top}}{\sqrt{d_k}}\right) V</math>

缩放因子 <math>\sqrt{d_k}</math> 防止点积随着键维度 <math>d_k</math> 的增加而变得很大，否则会将softmax推入梯度极小的区域。

== 自注意力 ==

在'''自注意力（Self-Attention）'''中，查询、键和值都来自同一个序列。每个位置关注所有其他位置（包括自身），使模型能够在单层中捕获长距离依赖关系。对于输入矩阵 <math>X \in \mathbb{R}^{n \times d}</math>：

:<math>Q = X W^Q, \quad K = X W^K, \quad V = X W^V</math>

自注意力的复杂度为 <math>O(n^2 d)</math>，对于很长的序列来说可能非常昂贵。稀疏注意力（Sparse Attention）和线性注意力（Linear Attention）等高效变体降低了这一成本。

== 多头注意力 ==

'''多头注意力（Multi-Head Attention）'''不是执行单个注意力函数，而是使用独立的投影运行 <math>h</math> 个并行的注意力头：

:<math>\mathrm{MultiHead}(Q, K, V) = \mathrm{Concat}(\mathrm{head}_1, \dots, \mathrm{head}_h)\, W^O</math>

其中 <math>\mathrm{head}_i = \mathrm{Attention}(Q W_i^Q,\, K W_i^K,\, V W_i^V)</math>。每个头可以学习关注输入的不同方面——例如，一个头可能捕获句法关系，另一个捕获语义关系。典型配置使用8个或16个头。

== 位置编码 ==

由于自注意力是置换不变的（Permutation-invariant）（它将输入视为无序集合），位置信息必须被显式注入。原始Transformer使用正弦位置编码：

:<math>\mathrm{PE}(pos, 2i) = \sin\!\left(\frac{pos}{10000^{2i/d}}\right), \quad \mathrm{PE}(pos, 2i+1) = \cos\!\left(\frac{pos}{10000^{2i/d}}\right)</math>

可学习的位置嵌入和相对位置编码（例如RoPE、ALiBi）是常见的替代方案，它们可以更好地泛化到未见过的序列长度。

== 交叉注意力 ==

'''交叉注意力（Cross-Attention）'''用于查询来自一个序列而键/值来自另一个序列的情况。在编码器-解码器Transformer中，解码器通过交叉注意力关注编码器输出，使模型能够根据完整的输入上下文来生成。

== 实践注意事项 ==

* '''掩码（Masking）'''：在自回归解码中，未来位置被屏蔽（在softmax之前设为 <math>-\infty</math>）以保持因果结构。
* '''注意力Dropout'''：在训练期间随机丢弃注意力权重起到正则化的作用，减少对特定对齐模式的过拟合。
* '''键值缓存（KV Cache）'''：在推理过程中，缓存先前计算的键和值向量以避免冗余计算，显著加速自回归生成。

== 参见 ==

* [[Transformer]]
* [[Recurrent Neural Networks]]
* [[Sequence-to-sequence models]]
* [[Self-supervised learning]]
* [[Softmax Function]]

== 参考文献 ==

* Bahdanau, D., Cho, K. and Bengio, Y. (2015). "Neural Machine Translation by Jointly Learning to Align and Translate". ''ICLR''.
* Luong, M.-T., Pham, H. and Manning, C. D. (2015). "Effective Approaches to Attention-based Neural Machine Translation". ''EMNLP''.
* Vaswani, A. et al. (2017). "Attention Is All You Need". ''NeurIPS''.
* Shaw, P., Uszkoreit, J. and Vaswani, A. (2018). "Self-Attention with Relative Position Representations". ''NAACL''.
* Su, J. et al. (2021). "RoFormer: Enhanced Transformer with Rotary Position Embedding". ''arXiv:2104.09864''.

[[Category:Deep Learning]]
[[Category:Advanced]]
[[Category:Neural Networks]]

Word Embeddings/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Word Embeddings}}
{{ArticleInfobox | topic_area = NLP | difficulty = Intermediate | prerequisites = [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

Los '''word embeddings''' son representaciones vectoriales densas y de baja dimensionalidad de palabras en las que las palabras semanticamente similares se mapean a puntos cercanos en el espacio vectorial. Son un componente fundamental del procesamiento del lenguaje natural (PLN) moderno, reemplazando las codificaciones dispersas one-hot con representaciones que capturan significado, analogia y relaciones sintacticas.

== La hipotesis distribucional ==

Los word embeddings se fundamentan en la '''hipotesis distribucional''', enunciada de forma celebre por J. R. Firth (1957): "Conoceras una palabra por la compania que mantiene." La idea es que las palabras que aparecen en contextos similares tienden a tener significados similares. Por ejemplo, "perro" y "gato" aparecen frecuentemente cerca de palabras como "mascota", "pelo" y "veterinario", por lo que deberian tener representaciones similares.

Los enfoques tempranos para explotar la informacion distribucional incluyen matrices de coocurrencia, informacion mutua puntual (PMI) y analisis semantico latente (LSA). Los metodos modernos de word embeddings aprenden vectores densos directamente utilizando redes neuronales.

== Representaciones one-hot vs. densas ==

=== Codificacion one-hot ===

En un vocabulario de <math>V</math> palabras, un vector one-hot para la <math>i</math>-esima palabra es un vector de <math>V</math> dimensiones con un 1 en la posicion <math>i</math> y 0 en el resto. Esta representacion tiene dos deficiencias criticas:

* '''Dimensionalidad''' — los vectores son de dimension extremadamente alta (tipicamente <math>V > 100{,}000</math>).
* '''Sin similitud''' — cada par de vectores one-hot es igualmente distante: <math>\mathbf{e}_i^\top \mathbf{e}_j = 0</math> para <math>i \neq j</math>. "Gato" esta tan lejos de "perro" como lo esta de "democracia."

=== Embeddings densos ===

Un word embedding mapea cada palabra a un vector de valores reales de <math>d</math> dimensiones (tipicamente <math>d = 100</math>–<math>300</math>):

:<math>\mathbf{w}_i \in \mathbb{R}^d, \quad d \ll V</math>

Las palabras similares tienen una alta similitud coseno:

:<math>\text{sim}(\mathbf{w}_a, \mathbf{w}_b) = \frac{\mathbf{w}_a \cdot \mathbf{w}_b}{\|\mathbf{w}_a\|\;\|\mathbf{w}_b\|}</math>

== Word2Vec ==

'''Word2Vec''' (Mikolov et al., 2013) introdujo dos arquitecturas eficientes para aprender word embeddings a partir de grandes corpus.

=== Bolsa continua de palabras (CBOW) ===

CBOW predice una palabra objetivo a partir de sus palabras de contexto circundantes. Dada una ventana de palabras de contexto <math>\{w_{t-c}, \ldots, w_{t-1}, w_{t+1}, \ldots, w_{t+c}\}</math>, el modelo maximiza:

:<math>P(w_t \mid w_{t-c}, \ldots, w_{t+c})</math>

Los vectores de las palabras de contexto se promedian y se pasan a traves de una capa softmax. CBOW es mas rapido de entrenar y funciona bien para palabras frecuentes.

=== Skip-gram ===

Skip-gram invierte la prediccion: dada una palabra objetivo, predice las palabras de contexto circundantes. Para cada par <math>(w_t, w_{t+j})</math> donde <math>j \in [-c, c] \setminus \{0\}</math>, el modelo maximiza:

:<math>P(w_{t+j} \mid w_t) = \frac{\exp(\mathbf{v}'_{w_{t+j}}{}^\top \mathbf{v}_{w_t})}{\sum_{w=1}^{V}\exp(\mathbf{v}'_w{}^\top \mathbf{v}_{w_t})}</math>

donde <math>\mathbf{v}_w</math> y <math>\mathbf{v}'_w</math> son los vectores de embedding de entrada y salida. Calcular el softmax completo sobre el vocabulario es costoso, por lo que se utilizan dos aproximaciones comunes:

* '''Muestreo negativo''' — en lugar de calcular el softmax completo, el modelo contrasta la palabra de contexto verdadera contra <math>k</math> palabras "negativas" muestreadas aleatoriamente.
* '''Softmax jerarquico''' — organiza el vocabulario en un arbol binario, reduciendo el coste del softmax de <math>O(V)</math> a <math>O(\log V)</math>.

Skip-gram funciona bien con palabras infrecuentes y captura relaciones sutiles. La famosa analogia "rey - hombre + mujer ≈ reina" surgio de embeddings Skip-gram.

== GloVe ==

'''GloVe''' (Global Vectors, Pennington et al., 2014) combina las fortalezas de la factorizacion de matrices globales y los metodos de ventana de contexto local. Construye una matriz de coocurrencia de palabras <math>X</math> a partir del corpus, donde <math>X_{ij}</math> cuenta con que frecuencia la palabra <math>j</math> aparece en el contexto de la palabra <math>i</math>, y luego optimiza:

:<math>J = \sum_{i,j=1}^{V} f(X_{ij})\bigl(\mathbf{w}_i^\top \tilde{\mathbf{w}}_j + b_i + \tilde{b}_j - \log X_{ij}\bigr)^2</math>

donde <math>f</math> es una funcion de ponderacion que limita la influencia de coocurrencias muy frecuentes. Los embeddings de GloVe a menudo igualan o superan la calidad de Word2Vec, y el uso explicito de estadisticas globales puede mejorar el rendimiento en tareas de analogia.

== fastText ==

'''fastText''' (Bojanowski et al., 2017) extiende Word2Vec representando cada palabra como una bolsa de n-gramas de caracteres. Por ejemplo, la palabra "donde" con <math>n = 3</math> se representa por los n-gramas {"<do", "don", "ond", "nde", "de>"} mas la palabra completa "<donde>". El embedding de una palabra es la suma de sus vectores de n-gramas.

Este enfoque tiene dos ventajas clave:

* '''Manejo de palabras raras y no vistas''' — incluso las palabras que no estan en el vocabulario de entrenamiento pueden recibir embeddings al sumar sus vectores de n-gramas de caracteres.
* '''Conciencia morfologica''' — las palabras que comparten subcadenas (por ejemplo, "ensenar", "ensenanza", "ensenante") comparten automaticamente componentes del embedding.

== Evaluacion de embeddings ==

Los word embeddings se evaluan mediante:

{| class="wikitable"
|-
! Tipo de evaluacion !! Ejemplos !! Que mide
|-
| '''Intrinseca: analogia''' || "rey : reina :: hombre : ?" || Estructura lineal del espacio
|-
| '''Intrinseca: similitud''' || Correlacion con juicios de similitud humanos (SimLex-999, WS-353) || Calidad semantica
|-
| '''Extrinseca: tarea posterior''' || Reconocimiento de entidades nombradas, analisis de sentimiento, parsing || Utilidad practica
|}

Las evaluaciones intrinsecas son rapidas pero no siempre predicen el rendimiento en tareas posteriores. La evaluacion extrinseca en la tarea objetivo es, en ultima instancia, la medida mas fiable.

== Embeddings contextuales ==

Los word embeddings tradicionales asignan un unico vector por palabra independientemente del contexto — la palabra "banco" tiene el mismo embedding ya sea que se refiera a un banco de rio o a una institucion financiera. Los '''embeddings contextuales''' abordan esta limitacion produciendo representaciones diferentes segun el texto circundante.

Los modelos de embeddings contextuales mas notables incluyen:

* '''ELMo''' (Peters et al., 2018) — utiliza un LSTM bidireccional para generar representaciones de palabras dependientes del contexto.
* '''BERT''' (Devlin et al., 2019) — utiliza un codificador Transformer entrenado con modelado de lenguaje enmascarado.
* '''Serie GPT''' (Radford et al., 2018–) — utiliza un decodificador Transformer entrenado de forma autorregresiva.

Estos modelos han reemplazado en gran medida a los embeddings estaticos para la mayoria de las tareas de PLN, aunque los embeddings estaticos siguen siendo utiles por su eficiencia, interpretabilidad y en entornos con recursos limitados.

== Vease tambien ==

* [[Neural Networks]]
* [[Recurrent Neural Networks]]
* [[Loss Functions]]
* [[Backpropagation]]

== Referencias ==

* Firth, J. R. (1957). "A synopsis of linguistic theory, 1930–1955". In ''Studies in Linguistic Analysis''.
* Mikolov, T. et al. (2013). "Efficient Estimation of Word Representations in Vector Space". ''arXiv:1301.3781''.
* Pennington, J., Socher, R. and Manning, C. D. (2014). "GloVe: Global Vectors for Word Representation". ''EMNLP''.
* Bojanowski, P. et al. (2017). "Enriching Word Vectors with Subword Information". ''TACL'', 5, 135–146.
* Peters, M. E. et al. (2018). "Deep contextualized word representations". ''NAACL''.
* Devlin, J. et al. (2019). "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding". ''NAACL''.

[[Category:NLP]]
[[Category:Intermediate]]

Transfer Learning/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Transfer Learning}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

El '''transfer learning''' (aprendizaje por transferencia) es una tecnica de aprendizaje automatico en la que un modelo entrenado en una tarea se reutiliza como punto de partida para un modelo en una tarea diferente pero relacionada. Al aprovechar el conocimiento adquirido durante un preentrenamiento a gran escala, el transfer learning reduce drasticamente la cantidad de datos etiquetados, computo y tiempo de entrenamiento requeridos para las aplicaciones posteriores.

== Motivacion ==

Entrenar redes neuronales profundas desde cero tipicamente requiere grandes conjuntos de datos y recursos computacionales significativos. En muchos dominios practicos — imagen medica, analisis de textos legales, idiomas con pocos recursos — los datos etiquetados son escasos. El transfer learning aborda esta asimetria: un modelo preentrenado en una tarea fuente rica en datos captura caracteristicas generales (bordes, texturas, patrones sintacticos) que se transfieren bien a una tarea objetivo con pocos datos.

== Conceptos clave ==

=== Dominio y tarea ===

Formalmente, un '''dominio''' <math>\mathcal{D} = \{\mathcal{X}, P(X)\}</math> consiste en un espacio de caracteristicas <math>\mathcal{X}</math> y una distribucion marginal <math>P(X)</math>. Una '''tarea''' <math>\mathcal{T} = \{\mathcal{Y}, f(\cdot)\}</math> consiste en un espacio de etiquetas <math>\mathcal{Y}</math> y una funcion predictiva <math>f</math>. El transfer learning se aplica cuando la fuente y el objetivo difieren en dominio, tarea o ambos.

=== Adaptacion de dominio ===

Cuando la fuente y el objetivo comparten la misma tarea pero difieren en la distribucion de datos (<math>P_s(X) \neq P_t(X)</math>), el problema se denomina '''adaptacion de dominio'''. Las tecnicas incluyen:

* '''Reponderacion de instancias''' — ajustar los pesos de las muestras para que la distribucion fuente aproxime a la objetivo.
* '''Alineamiento de caracteristicas''' — aprender representaciones invariantes al dominio (por ejemplo, mediante entrenamiento adversario o discrepancia de medias maxima).
* '''Autoentrenamiento''' — utilizar las predicciones del modelo sobre datos objetivo no etiquetados como pseudoetiquetas.

== Ajuste fino vs. extraccion de caracteristicas ==

{| class="wikitable"
|-
! Estrategia !! Descripcion !! Cuando utilizar
|-
| '''Extraccion de caracteristicas''' || Congelar todas las capas preentrenadas; entrenar solo una nueva cabeza de salida || Conjunto de datos objetivo muy pequeno; fuente y objetivo estan estrechamente relacionados
|-
| '''Ajuste fino (completo)''' || Descongelar todas las capas y entrenar de extremo a extremo con una tasa de aprendizaje pequena || Conjunto de datos objetivo moderado; fuente y objetivo difieren significativamente
|-
| '''Descongelamiento gradual''' || Descongelar progresivamente las capas de arriba hacia abajo durante el entrenamiento || Equilibra la estabilidad de las caracteristicas inferiores con la adaptacion de las superiores
|}

Una heuristica comun es utilizar una tasa de aprendizaje entre 10 y 100 veces menor para las capas preentrenadas que para la nueva cabeza de clasificacion, previniendo el olvido catastrofico de las representaciones aprendidas.

== Modelos preentrenados ==

=== Vision por computador ===

Las redes convolucionales preentrenadas en ImageNet (ResNet, EfficientNet, ViT) sirven como columnas vertebrales estandar. Las capas inferiores aprenden caracteristicas universales como bordes y texturas, mientras que las capas superiores aprenden patrones especificos de la tarea. Ajustar un modelo de ImageNet en un conjunto de datos de imagen medica con solo unos pocos miles de imagenes supera rutinariamente al entrenamiento desde cero.

=== Procesamiento del lenguaje natural ===

El preentrenamiento de modelos de lenguaje transformo el PLN. Los hitos clave incluyen:

* '''Word2Vec / GloVe''' — word embeddings estaticos preentrenados en grandes corpus.
* '''ELMo''' — embeddings contextualizados a partir de LSTM bidireccionales.
* '''BERT''' (Devlin et al., 2019) — Transformer bidireccional preentrenado con modelado de lenguaje enmascarado; ajustado para clasificacion, respuesta a preguntas, reconocimiento de entidades nombradas y mas.
* '''Serie GPT''' — Transformers autorregresivos que demuestran que la escala y el preentrenamiento permiten la transferencia con pocos ejemplos e incluso sin ejemplos.

== Cuando utilizar transfer learning ==

El transfer learning es mas beneficioso cuando:

# El conjunto de datos objetivo es pequeno en relacion con la capacidad del modelo.
# Los dominios fuente y objetivo comparten similitudes estructurales (por ejemplo, ambos involucran imagenes naturales o lenguaje natural).
# Los recursos computacionales para un preentrenamiento completo no estan disponibles.
# Se necesita un prototipado rapido antes de comprometerse con la recoleccion de datos a gran escala.

Puede perjudicar el rendimiento ('''transferencia negativa''') cuando los dominios fuente y objetivo son fundamentalmente disimiles — por ejemplo, transferir de imagenes naturales a espectrogramas sin una adaptacion adecuada.

== Consejos practicos ==

* El '''aumento de datos''' complementa el transfer learning al expandir artificialmente el tamano efectivo del conjunto de datos objetivo.
* El '''calentamiento de la tasa de aprendizaje''' ayuda a estabilizar el entrenamiento inicial al ajustar modelos preentrenados grandes.
* La '''parada temprana''' sobre un conjunto de validacion previene el sobreajuste durante el ajuste fino, especialmente con conjuntos de datos pequenos.
* El '''decaimiento de tasa de aprendizaje por capas''' asigna tasas menores a las capas iniciales (mas generales) y tasas mayores a las capas posteriores (mas especificas de la tarea).
* La '''transferencia de tarea intermedia''' — ajustar en una tarea intermedia relacionada antes de la tarea objetivo final (por ejemplo, inferencia de lenguaje natural antes de analisis de sentimiento) — puede mejorar aun mas los resultados.

== Evaluacion ==

La efectividad del transfer learning se mide tipicamente comparando:

:<math>\Delta_{\mathrm{transfer}} = \mathrm{Acc}_{\mathrm{transfer}} - \mathrm{Acc}_{\mathrm{scratch}}</math>

Un <math>\Delta_{\mathrm{transfer}}</math> positivo indica una transferencia de conocimiento exitosa. Los profesionales tambien monitorizan la velocidad de convergencia, ya que los modelos transferidos a menudo alcanzan el rendimiento objetivo en una fraccion de las epocas.

== Vease tambien ==

* [[Neural Networks]]
* [[Transformer]]
* [[Self-supervised learning]]
* [[Domain adaptation]]
* [[Fine-tuning]]

== Referencias ==

* Pan, S. J. and Yang, Q. (2010). "A Survey on Transfer Learning". ''IEEE Transactions on Knowledge and Data Engineering''.
* Yosinski, J. et al. (2014). "How transferable are features in deep neural networks?". ''NeurIPS''.
* Devlin, J. et al. (2019). "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding". ''NAACL''.
* Howard, J. and Ruder, S. (2018). "Universal Language Model Fine-tuning for Text Classification". ''ACL''.
* Zhuang, F. et al. (2021). "A Comprehensive Survey on Transfer Learning". ''Proceedings of the IEEE''.

[[Category:Machine Learning]]
[[Category:Intermediate]]

Stochastic Gradient Descent/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

El '''descenso de gradiente estocástico''' (a menudo abreviado '''SGD''', del inglés ''stochastic gradient descent'') es un algoritmo de optimización iterativa utilizado para minimizar una función objetivo expresada como la suma de subfunciones diferenciables. Es el motor principal del entrenamiento moderno de aprendizaje automático, impulsando desde la regresión logística hasta las redes neuronales profundas.

== Motivación ==

En el [[gradient descent|descenso de gradiente]] clásico, el gradiente completo de la función de pérdida se calcula sobre todo el conjunto de entrenamiento antes de cada actualización de parámetros. Cuando el conjunto de datos es grande, esto resulta prohibitivamente costoso. El SGD aborda este problema estimando el gradiente a partir de una sola muestra seleccionada aleatoriamente (o un pequeño '''mini-lote''') en cada paso, intercambiando una estimación más ruidosa por un costo por iteración drásticamente menor.

== Algoritmo ==

Dada una función de pérdida parametrizada

:<math>L(\theta) = \frac{1}{N}\sum_{i=1}^{N} \ell(\theta;\, x_i,\, y_i)</math>

la regla de actualización del SGD en el paso <math>t</math> es:

:<math>\theta_{t+1} = \theta_t - \eta_t \,\nabla_\theta \ell(\theta_t;\, x_{i_t},\, y_{i_t})</math>

donde <math>\eta_t</math> es la '''tasa de aprendizaje''' (tamaño de paso) e <math>i_t</math> es un índice seleccionado aleatoriamente.

=== Variante con mini-lotes ===

En la práctica se utiliza un '''mini-lote''' de <math>B</math> muestras:

:<math>\theta_{t+1} = \theta_t - \frac{\eta_t}{B}\sum_{j=1}^{B} \nabla_\theta \ell(\theta_t;\, x_{i_j},\, y_{i_j})</math>

Los tamaños de lote habituales oscilan entre 32 y 512. Lotes más grandes reducen la varianza del gradiente, pero incrementan el uso de memoria.

=== Pseudocódigo ===

<pre>
inicializar parámetros θ
para época = 1, 2, … hacer
mezclar conjunto de entrenamiento
para cada mini-lote B ⊂ conjunto de entrenamiento hacer
g ← (1/|B|) Σ ∇ℓ(θ; xᵢ, yᵢ) # estimar gradiente
θ ← θ − η · g # actualizar parámetros
fin para
fin para
</pre>

== Programas de tasa de aprendizaje ==

La tasa de aprendizaje <math>\eta_t</math> influye fuertemente en la convergencia. Las estrategias más comunes incluyen:

* '''Constante''' — sencilla, pero puede sobrepasar el mínimo o estancarse.
* '''Decaimiento por pasos''' — multiplicar <math>\eta</math> por un factor (por ejemplo, 0.1) cada <math>k</math> épocas.
* '''Decaimiento exponencial''' — <math>\eta_t = \eta_0 \, e^{-\lambda t}</math>.
* '''Recocido coseno''' — reduce suavemente la tasa siguiendo una curva coseno, a menudo con reinicios.
* '''Calentamiento lineal''' — aumentar gradualmente desde un <math>\eta</math> pequeño durante las primeras iteraciones para estabilizar el entrenamiento inicial.

== Propiedades de convergencia ==

Para objetivos convexos con gradientes Lipschitz-continuos, el SGD con una tasa de aprendizaje decreciente que satisfaga

:<math>\sum_{t=1}^{\infty} \eta_t = \infty, \qquad \sum_{t=1}^{\infty} \eta_t^2 < \infty</math>

converge casi seguramente al mínimo global (condiciones de Robbins–Monro). Para problemas no convexos —el régimen típico en aprendizaje profundo— el SGD converge a un punto estacionario, y la evidencia empírica muestra que a menudo encuentra buenos mínimos locales.

== Variantes populares ==

Varias extensiones reducen la varianza de la estimación del gradiente o adaptan el tamaño de paso por parámetro:

{| class="wikitable"
|-
! Método !! Idea clave !! Referencia
|-
| '''Momentum''' || Acumula un promedio móvil con decaimiento exponencial de gradientes pasados || Polyak, 1964
|-
| '''Gradiente acelerado de Nesterov''' || Evalúa el gradiente en una posición "anticipada" || Nesterov, 1983
|-
| '''Adagrad''' || Tasas por parámetro que disminuyen para características actualizadas frecuentemente || Duchi et al., 2011
|-
| '''RMSProp''' || Corrige las tasas decrecientes de Adagrad usando un promedio móvil de gradientes al cuadrado || Hinton (notas de clase), 2012
|-
| '''Adam''' || Combina momentum con tasas adaptativas al estilo RMSProp || Kingma y Ba, 2015
|-
| '''AdamW''' || Desacopla la regularización de pesos del paso de gradiente adaptativo || Loshchilov y Hutter, 2019
|}

== Consideraciones prácticas ==

* '''Mezcla de datos''' — Reordenar aleatoriamente el conjunto de datos en cada época para evitar patrones cíclicos.
* '''Recorte de gradiente''' — Limitar la norma del gradiente para prevenir actualizaciones explosivas, especialmente en redes recurrentes.
* '''Normalización por lotes''' — Normalizar las entradas de cada capa reduce la sensibilidad a la tasa de aprendizaje.
* '''Entrenamiento con precisión mixta''' — Usar punto flotante de media precisión acelera el SGD en GPUs modernas con una pérdida mínima de exactitud.

== Aplicaciones ==

El SGD y sus variantes se utilizan en prácticamente todas las áreas del aprendizaje automático:

* Entrenamiento de redes neuronales profundas (visión por computadora, PLN, reconocimiento de voz)
* Modelos lineales a gran escala (regresión logística, SVM mediante SGD)
* Optimización de políticas en aprendizaje por refuerzo
* Sistemas de recomendación y filtrado colaborativo
* Escenarios de aprendizaje en línea donde los datos llegan en flujo continuo

== Véase también ==

* [[Gradient descent|Descenso de gradiente]]
* [[Backpropagation|Retropropagación]]
* [[Adam (optimiser)|Adam (optimizador)]]
* [[Learning rate|Tasa de aprendizaje]]
* [[Convex optimisation|Optimización convexa]]

== Referencias ==

* Robbins, H. y Monro, S. (1951). "A Stochastic Approximation Method". ''Annals of Mathematical Statistics''.
* Bottou, L. (2010). "Large-Scale Machine Learning with Stochastic Gradient Descent". ''COMPSTAT''.
* Kingma, D. P. y Ba, J. (2015). "Adam: A Method for Stochastic Optimization". ''ICLR''.
* Ruder, S. (2016). "An overview of gradient descent optimization algorithms". ''arXiv:1609.04747''.

[[Category:Aprendizaje automático]]
[[Category:Algoritmos de optimización]]
[[Category:Métodos de gradiente]]

Softmax Function/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Softmax Function}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

La '''funcion softmax''' (tambien llamada '''funcion exponencial normalizada''') es una funcion matematica que convierte un vector de numeros reales ('''logits''') en una distribucion de probabilidad. Es la activacion de salida estandar para la clasificacion multiclase en redes neuronales y desempena un papel central en modelos que van desde la regresion logistica hasta los grandes modelos de lenguaje.

== Definicion ==

Dado un vector de logits <math>\mathbf{z} = (z_1, z_2, \dots, z_K)</math> para <math>K</math> clases, la funcion softmax produce:

:<math>\sigma(\mathbf{z})_k = \frac{e^{z_k}}{\sum_{j=1}^{K} e^{z_j}}, \qquad k = 1, \dots, K</math>

La salida satisface dos propiedades que la convierten en una distribucion de probabilidad valida:

# <math>\sigma(\mathbf{z})_k > 0</math> para todo <math>k</math> (dado que la funcion exponencial es siempre positiva).
# <math>\sum_{k=1}^{K} \sigma(\mathbf{z})_k = 1</math> (por construccion).

== Intuicion ==

La funcion softmax amplifica las diferencias entre los logits. Un logit mayor que los demas recibe una proporcion desproporcionadamente grande de la masa de probabilidad porque la funcion exponencial crece de forma superlineal. Por ejemplo:

{| class="wikitable"
|-
! Logits !! Salida softmax
|-
| <math>(2.0,\; 1.0,\; 0.1)</math> || <math>(0.659,\; 0.242,\; 0.099)</math>
|-
| <math>(5.0,\; 1.0,\; 0.1)</math> || <math>(0.993,\; 0.005,\; 0.002)</math>
|}

A medida que la brecha entre el logit mas grande y los demas aumenta, la salida se aproxima a un vector one-hot. Este comportamiento de "el ganador se lleva la mayor parte" hace que softmax sea adecuada para la clasificacion donde una unica clase debe dominar.

== Parametro de temperatura ==

Un parametro de '''temperatura''' <math>T > 0</math> controla la nitidez de la distribucion:

:<math>\sigma(\mathbf{z}; T)_k = \frac{e^{z_k / T}}{\sum_{j=1}^{K} e^{z_j / T}}</math>

* <math>T \to 0</math>: La distribucion colapsa en un vector one-hot seleccionando el argmax — equivalente a una decision rigida.
* <math>T = 1</math>: Softmax estandar.
* <math>T \to \infty</math>: La distribucion se aproxima a la uniforme — todas las clases se vuelven igualmente probables.

El escalado por temperatura se utiliza ampliamente en la destilacion de conocimiento (Hinton et al., 2015), donde una distribucion "suave" de un modelo maestro proporciona una senal de entrenamiento mas rica que las etiquetas rigidas. Tambien se utiliza para controlar la aleatoriedad en la generacion de texto a partir de modelos de lenguaje.

== Estabilidad numerica ==

Una implementacion ingenua de softmax puede desbordarse cuando los logits son grandes (por ejemplo, <math>e^{1000}</math> es infinito en punto flotante). La solucion estandar es restar el logit maximo:

:<math>\sigma(\mathbf{z})_k = \frac{e^{z_k - m}}{\sum_{j=1}^{K} e^{z_j - m}}, \qquad m = \max_j z_j</math>

Esto es matematicamente equivalente (la constante se cancela) pero asegura que el exponente mas grande sea <math>e^0 = 1</math>, previniendo el desbordamiento. Todos los principales frameworks de aprendizaje profundo implementan esta version estabilizada automaticamente.

== Relacion con la sigmoide ==

Para el caso especial de <math>K = 2</math> clases, la funcion softmax se reduce a la funcion '''sigmoide''' (logistica). Si se define <math>z = z_1 - z_2</math>, entonces:

:<math>\sigma(\mathbf{z})_1 = \frac{e^{z_1}}{e^{z_1} + e^{z_2}} = \frac{1}{1 + e^{-z}} = \sigma_{\mathrm{sigmoid}}(z)</math>

Por esto, los clasificadores binarios tipicamente utilizan una unica neurona de salida con activacion sigmoide en lugar de dos neuronas con softmax — son matematicamente equivalentes.

== Gradiente ==

El jacobiano de la funcion softmax con respecto a su entrada es:

:<math>\frac{\partial \sigma_k}{\partial z_j} = \sigma_k (\delta_{kj} - \sigma_j)</math>

donde <math>\delta_{kj}</math> es la delta de Kronecker. Cuando se combina con la [[Cross-Entropy Loss|perdida de entropia cruzada]], el gradiente se simplifica a <math>\hat{y}_k - y_k</math>, lo que es computacionalmente eficiente y numericamente estable.

== Uso en clasificacion ==

En un flujo de clasificacion tipico:

# Una red neuronal produce logits crudos <math>\mathbf{z}</math> a partir de su capa lineal final.
# Softmax convierte los logits en probabilidades: <math>\hat{\mathbf{y}} = \sigma(\mathbf{z})</math>.
# La clase predicha es <math>\hat{c} = \arg\max_k \hat{y}_k</math>.
# El entrenamiento utiliza la [[Cross-Entropy Loss|perdida de entropia cruzada]] aplicada a la distribucion predicha y las etiquetas verdaderas.

En la practica, softmax y la entropia cruzada se calculan conjuntamente por estabilidad numerica (la formulacion '''log-softmax'''), y el argmax en el momento de la inferencia puede aplicarse directamente a los logits sin calcular softmax en absoluto.

== Mas alla de la clasificacion ==

Softmax aparece en muchos contextos mas alla de la capa de salida:

* '''Mecanismos de atencion''': Softmax normaliza las puntuaciones de alineamiento en pesos de atencion en la arquitectura [[Attention Mechanisms|Transformer]].
* '''Aprendizaje por refuerzo''': Softmax sobre las estimaciones de valor de accion produce una politica estocastica (exploracion de Boltzmann).
* '''Modelos de mezcla''': Softmax parametriza los coeficientes de mezcla en arquitecturas de mezcla de expertos.

== Vease tambien ==

* [[Cross-Entropy Loss]]
* [[Loss Functions]]
* [[Logistic regression]]
* [[Attention Mechanisms]]
* [[Neural Networks]]

== Referencias ==

* Bishop, C. M. (2006). ''Pattern Recognition and Machine Learning''. Springer, Section 4.3.4.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning''. MIT Press, Section 6.2.2.3.
* Hinton, G., Vinyals, O. and Dean, J. (2015). "Distilling the Knowledge in a Neural Network". ''arXiv:1503.02531''.
* Bridle, J. S. (1990). "Probabilistic Interpretation of Feedforward Classification Network Outputs". ''Neurocomputing''.

[[Category:Machine Learning]]
[[Category:Introductory]]

Recurrent Neural Networks/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Recurrent Neural Networks}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Backpropagation]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

Las '''redes neuronales recurrentes''' ('''RNN''') son una clase de [[Neural Networks|redes neuronales]] disenadas para procesar '''datos secuenciales''' — datos en los que el orden de los elementos importa. A diferencia de las redes prealimentadas, las RNN contienen conexiones recurrentes que permiten que la informacion persista a traves de los pasos temporales, otorgandoles una forma de memoria.

== Modelado de secuencias ==

Muchos problemas del mundo real involucran secuencias: el texto es una secuencia de palabras, el habla es una secuencia de tramas de audio, los precios de las acciones forman una serie temporal y el ADN es una secuencia de nucleotidos. Las redes prealimentadas estandar requieren entradas de tamano fijo y tratan cada entrada de forma independiente, lo que las hace inadecuadas para secuencias de longitud variable donde el contexto importa.

Las RNN abordan esto procesando las entradas un elemento a la vez mientras mantienen un '''estado oculto''' que resume la informacion vista hasta el momento.

== RNN basica ==

En cada paso temporal <math>t</math>, una RNN basica calcula:

:<math>\mathbf{h}_t = \tanh(\mathbf{W}_{hh}\,\mathbf{h}_{t-1} + \mathbf{W}_{xh}\,\mathbf{x}_t + \mathbf{b}_h)</math>

:<math>\mathbf{y}_t = \mathbf{W}_{hy}\,\mathbf{h}_t + \mathbf{b}_y</math>

donde <math>\mathbf{x}_t</math> es la entrada en el instante <math>t</math>, <math>\mathbf{h}_t</math> es el estado oculto, <math>\mathbf{y}_t</math> es la salida, y <math>\mathbf{W}_{hh}, \mathbf{W}_{xh}, \mathbf{W}_{hy}</math> son matrices de pesos compartidas en todos los pasos temporales. El estado oculto inicial <math>\mathbf{h}_0</math> se establece tipicamente como el vector cero.

La idea clave es que los mismos parametros se aplican en cada paso temporal — '''comparticion de pesos en el tiempo''' — lo que permite a la red generalizar a traves de diferentes posiciones en la secuencia.

== Backpropagation a traves del tiempo (BPTT) ==

El entrenamiento de una RNN requiere calcular los gradientes de la perdida con respecto a los pesos compartidos. '''Backpropagation a traves del tiempo''' (BPTT) "desenrolla" la RNN a lo largo de los pasos temporales, produciendo una red prealimentada profunda con pesos compartidos, y luego aplica [[Backpropagation|backpropagation]] estandar.

Para una secuencia de longitud <math>T</math>, el gradiente de la perdida con respecto a <math>\mathbf{W}_{hh}</math> involucra un producto de jacobianos:

:<math>\frac{\partial L}{\partial \mathbf{W}_{hh}} = \sum_{t=1}^{T}\frac{\partial L_t}{\partial \mathbf{W}_{hh}} = \sum_{t=1}^{T}\sum_{k=1}^{t}\frac{\partial L_t}{\partial \mathbf{h}_t}\left(\prod_{j=k+1}^{t}\frac{\partial \mathbf{h}_j}{\partial \mathbf{h}_{j-1}}\right)\frac{\partial \mathbf{h}_k}{\partial \mathbf{W}_{hh}}</math>

El producto de jacobianos <math>\prod \partial \mathbf{h}_j / \partial \mathbf{h}_{j-1}</math> es la fuente de los problemas de gradientes que se desvanecen y explotan.

== El problema del gradiente que se desvanece ==

Cuando el radio espectral del jacobiano recurrente es menor que 1, la senal del gradiente decae exponencialmente a traves del tiempo — el problema del '''gradiente que se desvanece'''. Esto hace extremadamente dificil que las RNN basicas aprendan dependencias que abarquen mas de 10–20 pasos temporales.

Por el contrario, cuando el radio espectral supera 1, los gradientes pueden crecer exponencialmente — el problema del '''gradiente que explota'''. Los gradientes que explotan se manejan tipicamente mediante '''recorte de gradientes''' (limitar la norma del gradiente a un umbral), pero los gradientes que se desvanecen requieren soluciones arquitectonicas.

== Long Short-Term Memory (LSTM) ==

El '''LSTM''' (Hochreiter y Schmidhuber, 1997) introduce un '''estado de celda''' <math>\mathbf{c}_t</math> que fluye a traves del tiempo con minima interferencia, y tres '''compuertas''' que controlan el flujo de informacion:

:<math>\mathbf{f}_t = \sigma(\mathbf{W}_f[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_f)</math> ('''compuerta de olvido''')

:<math>\mathbf{i}_t = \sigma(\mathbf{W}_i[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_i)</math> ('''compuerta de entrada''')

:<math>\tilde{\mathbf{c}}_t = \tanh(\mathbf{W}_c[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_c)</math> ('''estado de celda candidato''')

:<math>\mathbf{c}_t = \mathbf{f}_t \odot \mathbf{c}_{t-1} + \mathbf{i}_t \odot \tilde{\mathbf{c}}_t</math> ('''actualizacion del estado de celda''')

:<math>\mathbf{o}_t = \sigma(\mathbf{W}_o[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_o)</math> ('''compuerta de salida''')

:<math>\mathbf{h}_t = \mathbf{o}_t \odot \tanh(\mathbf{c}_t)</math>

El estado de celda actua como una cinta transportadora: la compuerta de olvido decide que informacion antigua descartar, la compuerta de entrada decide que informacion nueva almacenar, y la compuerta de salida controla lo que se expone a la siguiente capa. Dado que el estado de celda se actualiza mediante suma (no multiplicacion), los gradientes fluyen mas facilmente a traves de secuencias largas.

== Unidad Recurrente con Compuertas (GRU) ==

La '''GRU''' (Cho et al., 2014) simplifica el LSTM fusionando el estado de celda y el estado oculto y utilizando solo dos compuertas:

:<math>\mathbf{z}_t = \sigma(\mathbf{W}_z[\mathbf{h}_{t-1}, \mathbf{x}_t])</math> ('''compuerta de actualizacion''')

:<math>\mathbf{r}_t = \sigma(\mathbf{W}_r[\mathbf{h}_{t-1}, \mathbf{x}_t])</math> ('''compuerta de reinicio''')

:<math>\tilde{\mathbf{h}}_t = \tanh(\mathbf{W}[\mathbf{r}_t \odot \mathbf{h}_{t-1}, \mathbf{x}_t])</math>

:<math>\mathbf{h}_t = (1 - \mathbf{z}_t) \odot \mathbf{h}_{t-1} + \mathbf{z}_t \odot \tilde{\mathbf{h}}_t</math>

La GRU tiene menos parametros que el LSTM y a menudo alcanza un rendimiento comparable. En la practica, la eleccion entre LSTM y GRU se realiza tipicamente de forma empirica.

== RNN bidireccionales ==

Una '''RNN bidireccional''' procesa la secuencia en ambas direcciones — hacia adelante (de izquierda a derecha) y hacia atras (de derecha a izquierda) — y concatena los estados ocultos:

:<math>\mathbf{h}_t = [\overrightarrow{\mathbf{h}}_t;\; \overleftarrow{\mathbf{h}}_t]</math>

Esto permite al modelo utilizar tanto el contexto pasado como el futuro en cada paso temporal, lo cual es beneficioso para tareas como el reconocimiento de entidades nombradas y la traduccion automatica, donde el significado de una palabra depende de su contexto circundante.

== Aplicaciones ==

Las RNN y sus variantes con compuertas se han aplicado a una amplia gama de tareas secuenciales:

* '''Modelado del lenguaje''' — predecir la siguiente palabra en una secuencia.
* '''Traduccion automatica''' — arquitecturas codificador-decodificador para traduccion secuencia a secuencia (Sutskever et al., 2014).
* '''Reconocimiento de voz''' — transcripcion de audio a texto (a menudo combinado con la perdida CTC).
* '''Analisis de sentimiento''' — clasificacion del sentimiento de un texto.
* '''Prediccion de series temporales''' — prediccion de valores futuros de datos financieros o de sensores.
* '''Generacion de musica''' — generacion de secuencias de notas.

Cabe destacar que para muchas tareas de procesamiento del lenguaje natural, los '''Transformers''' (Vaswani et al., 2017) han reemplazado en gran medida a las RNN debido a su capacidad para procesar secuencias en paralelo y capturar dependencias de largo alcance de manera mas efectiva mediante autoatencion.

== Vease tambien ==

* [[Neural Networks]]
* [[Backpropagation]]
* [[Convolutional Neural Networks]]
* [[Word Embeddings]]
* [[Overfitting and Regularization]]

== Referencias ==

* Elman, J. L. (1990). "Finding Structure in Time". ''Cognitive Science'', 14(2), 179–211.
* Hochreiter, S. and Schmidhuber, J. (1997). "Long Short-Term Memory". ''Neural Computation'', 9(8), 1735–1780.
* Cho, K. et al. (2014). "Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation". ''EMNLP''.
* Sutskever, I., Vinyals, O. and Le, Q. V. (2014). "Sequence to Sequence Learning with Neural Networks". ''NeurIPS''.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 10. MIT Press.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Overfitting and Regularization/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Overfitting and Regularization}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Intermediate | prerequisites = [[Loss Functions]], [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

El '''sobreajuste''' (overfitting) ocurre cuando un modelo de aprendizaje automatico aprende los datos de entrenamiento demasiado bien — capturando ruido e idiosincrasias en lugar del patron subyacente — y, en consecuencia, tiene un rendimiento deficiente en datos no vistos. La '''regularizacion''' es la familia de tecnicas utilizadas para prevenir el sobreajuste y mejorar la capacidad del modelo para generalizar.

== El equilibrio entre sesgo y varianza ==

El error de prediccion sobre datos no vistos puede descomponerse en tres componentes:

:<math>\text{Error} = \text{Bias}^2 + \text{Variance} + \text{Irreducible noise}</math>

* El '''sesgo''' mide cuan lejos esta la prediccion promedio del modelo del valor verdadero. Un sesgo alto indica que el modelo es demasiado simple para capturar la estructura de los datos ('''subajuste''').
* La '''varianza''' mide cuanto fluctuan las predicciones entre diferentes conjuntos de entrenamiento. Una varianza alta indica que el modelo es demasiado sensible a los datos de entrenamiento particulares ('''sobreajuste''').

El objetivo es encontrar el punto optimo que minimice el error total. Un modelo con muy pocos parametros subajusta (sesgo alto); un modelo con demasiados parametros sobreajusta (varianza alta). Las tecnicas de regularizacion inclinan el equilibrio restringiendo la complejidad del modelo, aceptando un sesgo ligeramente mayor a cambio de una varianza sustancialmente menor.

== Deteccion del sobreajuste ==

El diagnostico mas claro es comparar el rendimiento en entrenamiento y validacion:

* '''Perdida de entrenamiento decreciente, perdida de validacion tambien decreciente''' — el modelo aun esta aprendiendo; continuar el entrenamiento.
* '''Perdida de entrenamiento decreciente, perdida de validacion creciente''' — el modelo esta sobreajustando; aplicar regularizacion o detener el entrenamiento.
* '''Perdida de entrenamiento alta, perdida de validacion alta''' — el modelo esta subajustando; aumentar la capacidad o entrenar mas tiempo.

Graficar estas '''curvas de aprendizaje''' a lo largo de las iteraciones de entrenamiento es una practica esencial. Una gran brecha entre la precision de entrenamiento y la precision de validacion es la marca distintiva del sobreajuste.

== Regularizacion L2 (decaimiento de pesos) ==

La regularizacion L2 anade una penalizacion proporcional a la magnitud al cuadrado de los pesos:

:<math>J(\theta) = L(\theta) + \frac{\lambda}{2}\|\theta\|_2^2 = L(\theta) + \frac{\lambda}{2}\sum_j \theta_j^2</math>

El gradiente del termino de regularizacion es <math>\lambda \theta</math>, de modo que cada peso se reduce multiplicativamente hacia cero en cada actualizacion — de ahi el nombre '''decaimiento de pesos'''. El hiperparametro <math>\lambda</math> controla la intensidad de la regularizacion.

La regularizacion L2 es equivalente a colocar un prior gaussiano sobre los pesos desde una perspectiva bayesiana. Fomenta pesos pequenos y distribuidos y desalienta que cualquier peso individual se vuelva excesivamente grande.

== Regularizacion L1 ==

La regularizacion L1 penaliza la suma de valores absolutos:

:<math>J(\theta) = L(\theta) + \lambda \|\theta\|_1 = L(\theta) + \lambda \sum_j |\theta_j|</math>

A diferencia de L2, la penalizacion L1 lleva muchos pesos exactamente a cero, produciendo modelos '''dispersos'''. Esto hace que la regularizacion L1 sea util para la seleccion de caracteristicas. LASSO (Least Absolute Shrinkage and Selection Operator) es el ejemplo clasico de regresion lineal con regularizacion L1.

{| class="wikitable"
|-
! Propiedad !! L1 !! L2
|-
| Penalizacion || <math>\lambda\sum|\theta_j|</math> || <math>\frac{\lambda}{2}\sum\theta_j^2</math>
|-
| Efecto sobre los pesos || Lleva muchos a exactamente cero || Reduce todos hacia cero
|-
| Dispersidad || Si || No
|-
| Interpretacion bayesiana || Prior de Laplace || Prior gaussiano
|-
| Caso de uso || Seleccion de caracteristicas, interpretabilidad || Regularizacion general
|}

== Dropout ==

'''Dropout''' (Srivastava et al., 2014) es una tecnica de regularizacion especifica para redes neuronales. Durante el entrenamiento, cada neurona es aleatoriamente "descartada" (establecida en cero) con probabilidad <math>p</math> en cada pasada hacia adelante. Esto evita que las neuronas se coadapten y obliga a la red a aprender representaciones redundantes.

En el momento de la prueba, todas las neuronas estan activas pero sus salidas se escalan por <math>(1 - p)</math> para compensar el mayor numero de unidades activas (o equivalentemente, las salidas se escalan por <math>1/(1-p)</math> durante el entrenamiento — '''dropout invertido''').

Dropout puede interpretarse como un metodo de ensamblaje aproximado: cada paso de entrenamiento utiliza una subred diferente, y el modelo final aproxima la prediccion promedio de un numero exponencial de subredes.

== Parada temprana ==

La '''parada temprana''' monitoriza la perdida de validacion durante el entrenamiento y detiene la optimizacion cuando la perdida de validacion deja de mejorar. Es una de las estrategias de regularizacion mas simples y efectivas.

En la practica, un parametro de '''paciencia''' especifica cuantas epocas esperar despues de la ultima mejora antes de detenerse. Los pesos del modelo se guardan en el punto de menor perdida de validacion y se restauran al final.

La parada temprana actua como una forma implicita de regularizacion: limita el numero efectivo de pasos de entrenamiento, evitando que el modelo memorice completamente los datos de entrenamiento.

== Aumento de datos ==

El '''aumento de datos''' incrementa el tamano efectivo y la diversidad del conjunto de entrenamiento aplicando transformaciones que preservan las etiquetas. Para datos de imagenes, las transformaciones comunes incluyen:

* Volteos horizontales/verticales aleatorios
* Recortes y redimensionamientos aleatorios
* Variacion de color (brillo, contraste, saturacion)
* Rotacion y transformaciones afines
* Mixup (interpolacion lineal de pares de imagenes y sus etiquetas)
* Cutout (enmascaramiento de parches aleatorios)

Para datos de texto, las transformaciones incluyen sustitucion de sinonimos, retrotraduccion y parafraseo. El aumento de datos reduce el sobreajuste al exponer al modelo a entradas mas variadas sin recopilar datos adicionales.

== Otras tecnicas de regularizacion ==

* '''Batch normalization''' — normalizar las entradas de las capas reduce el desplazamiento covariante interno y tiene un leve efecto regularizador.
* '''Suavizado de etiquetas''' — reemplaza los objetivos one-hot con una mezcla, por ejemplo <math>y_{\text{smooth}} = (1 - \epsilon)\, y + \epsilon / C</math>, previniendo la sobreconfianza.
* '''Inyeccion de ruido''' — anadir ruido gaussiano a las entradas, pesos o gradientes durante el entrenamiento.

== Directrices practicas ==

# Comenzar con un modelo lo suficientemente grande como para sobreajustar los datos de entrenamiento — esto confirma que el modelo tiene capacidad suficiente.
# Anadir regularizacion incrementalmente (dropout, decaimiento de pesos, aumento de datos) y monitorizar el rendimiento en validacion.
# Utilizar la parada temprana como red de seguridad.
# Preferir mas datos de entrenamiento sobre una regularizacion mas fuerte siempre que sea posible — la regularizacion es un sustituto de los datos, no un reemplazo.
# Ajustar la intensidad de la regularizacion (<math>\lambda</math>, tasa de dropout) utilizando un conjunto de validacion, nunca el conjunto de prueba.

== Vease tambien ==

* [[Loss Functions]]
* [[Neural Networks]]
* [[Gradient Descent]]
* [[Convolutional Neural Networks]]

== Referencias ==

* Srivastava, N. et al. (2014). "Dropout: A Simple Way to Prevent Neural Networks from Overfitting". ''JMLR'', 15, 1929–1958.
* Tibshirani, R. (1996). "Regression Shrinkage and Selection via the Lasso". ''JRSS Series B'', 58(1), 267–288.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 7. MIT Press.
* Zhang, C. et al. (2017). "Understanding deep learning requires rethinking generalization". ''ICLR''.
* Shorten, C. and Khoshgoftaar, T. M. (2019). "A survey on Image Data Augmentation for Deep Learning". ''Journal of Big Data''.

[[Category:Machine Learning]]
[[Category:Intermediate]]

Neural Networks/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Neural Networks}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

Las '''redes neuronales''' (tambien llamadas '''redes neuronales artificiales''' o RNA) son modelos computacionales inspirados en la estructura de los sistemas nerviosos biologicos. Consisten en capas interconectadas de unidades de procesamiento simples denominadas '''neuronas''' (o nodos) y constituyen la base del aprendizaje profundo moderno.

== Inspiracion biologica ==

La neurona biologica recibe senales electricas a traves de sus '''dendritas''', las integra en el '''cuerpo celular''' y, si la senal combinada supera un umbral, emite una senal de salida a lo largo de su '''axon''' hacia las neuronas posteriores. Las redes neuronales artificiales abstraen este proceso: cada neurona artificial calcula una suma ponderada de sus entradas, anade un termino de sesgo y pasa el resultado a traves de una '''funcion de activacion''' no lineal.

Aunque la analogia con la biologia motivo la investigacion temprana, las redes neuronales modernas se entienden mejor como aproximadores de funciones parametrizados y flexibles, mas que como simulaciones fieles del cerebro.

== El perceptron ==

El '''perceptron''', introducido por Frank Rosenblatt en 1958, es la red neuronal mas simple. Calcula:

:<math>y = \sigma\!\left(\sum_{i=1}^{n} w_i x_i + b\right) = \sigma(\mathbf{w}^\top \mathbf{x} + b)</math>

donde <math>\mathbf{x}</math> es el vector de entrada, <math>\mathbf{w}</math> son los pesos aprendibles, <math>b</math> es un sesgo y <math>\sigma</math> es una funcion escalon que produce 1 si el argumento es positivo y 0 en caso contrario. El perceptron puede aprender cualquier funcion linealmente separable, pero notoriamente no puede representar la funcion XOR — una limitacion que detuvo la investigacion en redes neuronales durante mas de una decada.

== Redes prealimentadas ==

Una '''red neuronal prealimentada''' (tambien llamada '''perceptron multicapa''' o MLP) apila multiples capas de neuronas. La informacion fluye en una sola direccion — desde la '''capa de entrada''' a traves de una o mas '''capas ocultas''' hasta la '''capa de salida'''.

Para una red con una capa oculta, el calculo es:

:<math>\mathbf{h} = g(\mathbf{W}_1 \mathbf{x} + \mathbf{b}_1)</math>

:<math>\mathbf{y} = f(\mathbf{W}_2 \mathbf{h} + \mathbf{b}_2)</math>

donde <math>g</math> y <math>f</math> son funciones de activacion, <math>\mathbf{W}_1, \mathbf{W}_2</math> son matrices de pesos y <math>\mathbf{b}_1, \mathbf{b}_2</math> son vectores de sesgo. La capa oculta permite a la red aprender relaciones no lineales que un unico perceptron no puede capturar.

Las redes con muchas capas ocultas se denominan redes neuronales '''profundas''', y su entrenamiento es el tema del '''aprendizaje profundo'''.

== Funciones de activacion ==

La funcion de activacion introduce no linealidad; sin ella, una red multicapa se reduciria a una unica transformacion lineal. Las opciones comunes incluyen:

{| class="wikitable"
|-
! Funcion !! Formula !! Rango !! Notas
|-
| '''Sigmoide''' || <math>\sigma(z) = \frac{1}{1+e^{-z}}</math> || (0, 1) || Historicamente popular; sufre de gradientes que se desvanecen
|-
| '''Tanh''' || <math>\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}</math> || (−1, 1) || Centrada en cero; aun se satura para entradas grandes
|-
| '''ReLU''' || <math>\max(0, z)</math> || [0, ∞) || Opcion predeterminada en redes modernas; puede causar "neuronas muertas"
|-
| '''Leaky ReLU''' || <math>\max(\alpha z, z)</math> para <math>\alpha > 0</math> pequeno || (−∞, ∞) || Aborda el problema de las neuronas muertas
|-
| '''Softmax''' || <math>\frac{e^{z_i}}{\sum_j e^{z_j}}</math> || (0, 1) || Utilizada en la capa de salida para clasificacion multiclase
|}

== Teorema de aproximacion universal ==

El '''teorema de aproximacion universal''' (Cybenko 1989, Hornik 1991) establece que una red prealimentada con una unica capa oculta que contenga un numero finito de neuronas puede aproximar cualquier funcion continua en un subconjunto compacto de <math>\mathbb{R}^n</math> con precision arbitraria, siempre que la funcion de activacion satisfaga condiciones suaves (por ejemplo, que sea no constante, acotada y continua).

Este teorema garantiza la ''existencia'' de una buena aproximacion pero no dice nada sobre como ''encontrarla'' — en la practica, entrenar redes profundas con muchas capas es mucho mas efectivo que utilizar una unica capa ancha.

== Vision general del entrenamiento ==

El entrenamiento de una red neuronal implica:

# '''Definir una funcion de perdida''' — una medida de cuan lejos estan las predicciones de la red de los objetivos verdaderos (vease [[Loss Functions]]).
# '''Pasada hacia adelante''' — calcular la salida de la red para una entrada dada propagando los valores capa por capa.
# '''Pasada hacia atras (backpropagation)''' — calcular el gradiente de la perdida con respecto a cada peso aplicando la regla de la cadena en orden inverso a traves de la red (vease [[Backpropagation]]).
# '''Actualizacion de parametros''' — ajustar los pesos utilizando un algoritmo de optimizacion como el [[Gradient Descent|descenso de gradiente]] o alguna de sus variantes.
# '''Iteracion''' — repetir los pasos 2–4 durante muchas pasadas (epocas) sobre los datos de entrenamiento.

Un entrenamiento exitoso tambien requiere atencion a la '''inicializacion''' (por ejemplo, esquemas de Xavier o He), la '''regularizacion''' (para prevenir el [[Overfitting and Regularization|sobreajuste]]) y el '''ajuste de hiperparametros''' (tasa de aprendizaje, tamano de lote, arquitectura de la red).

== Arquitecturas comunes ==

Mas alla de la red prealimentada basica, se han desarrollado varias arquitecturas especializadas:

* '''[[Convolutional Neural Networks]]''' (CNN) — disenadas para datos con estructura de cuadricula como imagenes, utilizando conectividad local y comparticion de pesos.
* '''[[Recurrent Neural Networks]]''' (RNN) — disenadas para datos secuenciales, con conexiones que forman ciclos para mantener un estado oculto.
* '''Transformers''' — arquitecturas basadas en atencion que se han convertido en dominantes en el procesamiento del lenguaje natural y cada vez mas en vision.
* '''Autoencoders''' — redes entrenadas para reconstruir su entrada, utilizadas para reduccion de dimensionalidad y modelado generativo.
* '''Redes generativas adversarias''' (GAN) — pares de redes (generador y discriminador) entrenadas en competencia para generar datos realistas.

== Aplicaciones ==

Las redes neuronales se aplican en una amplia gama de dominios:

* Vision por computador (clasificacion de imagenes, deteccion de objetos, segmentacion)
* Procesamiento del lenguaje natural (traduccion, resumen, respuesta a preguntas)
* Reconocimiento y sintesis de voz
* Juegos (AlphaGo, agentes de Atari)
* Descubrimiento cientifico (plegamiento de proteinas, diseno de farmacos, prediccion meteorologica)
* Vehiculos autonomos y robotica

== Vease tambien ==

* [[Gradient Descent]]
* [[Backpropagation]]
* [[Loss Functions]]
* [[Convolutional Neural Networks]]
* [[Recurrent Neural Networks]]
* [[Overfitting and Regularization]]

== Referencias ==

* Rosenblatt, F. (1958). "The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain". ''Psychological Review''.
* Cybenko, G. (1989). "Approximation by Superpositions of a Sigmoidal Function". ''Mathematics of Control, Signals, and Systems''.
* Hornik, K. (1991). "Approximation Capabilities of Multilayer Feedforward Networks". ''Neural Networks''.
* LeCun, Y., Bengio, Y. and Hinton, G. (2015). "Deep learning". ''Nature'', 521, 436–444.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning''. MIT Press.

[[Category:Deep Learning]]
[[Category:Introductory]]
[[Category:Neural Networks]]

Loss Functions/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Loss Functions}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

Las '''funciones de perdida''' (tambien llamadas '''funciones de coste''' o '''funciones objetivo''') cuantifican cuan lejos estan las predicciones de un modelo del resultado deseado. Minimizar la funcion de perdida es el objetivo central del proceso de entrenamiento en el aprendizaje automatico: el algoritmo de optimizacion ajusta los parametros del modelo para reducir la perdida al minimo posible.

== Proposito ==

Una funcion de perdida mapea la prediccion del modelo <math>\hat{y}</math> y el objetivo verdadero <math>y</math> a un numero real no negativo. Formalmente, para un unico ejemplo:

:<math>\ell: \mathcal{Y} \times \mathcal{Y} \to \mathbb{R}_{\geq 0}</math>

Sobre un conjunto de datos de <math>N</math> ejemplos, la perdida total es tipicamente el promedio:

:<math>L(\theta) = \frac{1}{N}\sum_{i=1}^{N}\ell\bigl(y_i,\, \hat{y}_i(\theta)\bigr)</math>

La eleccion de la funcion de perdida codifica la estructura del problema — que tipo de errores importan y con que severidad deben ser penalizados. Una funcion de perdida mal elegida puede llevar a un modelo que optimiza el objetivo equivocado.

== Error cuadratico medio ==

El '''error cuadratico medio''' (MSE, por sus siglas en ingles) es la perdida predeterminada para tareas de regresion:

:<math>L_{\text{MSE}} = \frac{1}{N}\sum_{i=1}^{N}(y_i - \hat{y}_i)^2</math>

El MSE penaliza los errores grandes de forma cuadratica, lo que lo hace sensible a valores atipicos. Su gradiente es directo:

:<math>\frac{\partial}{\partial \hat{y}_i} (y_i - \hat{y}_i)^2 = -2(y_i - \hat{y}_i)</math>

Una variante estrechamente relacionada es el '''error absoluto medio''' (MAE), <math>\frac{1}{N}\sum|y_i - \hat{y}_i|</math>, que es mas robusto ante valores atipicos pero tiene un gradiente no suave en cero. La '''perdida de Huber''' combina ambas: se comporta como el MSE para errores pequenos y como el MAE para errores grandes.

== Perdida de entropia cruzada ==

La '''perdida de entropia cruzada''' es la opcion estandar para tareas de clasificacion. Mide la disimilitud entre la distribucion de probabilidad predicha y la distribucion de la etiqueta verdadera.

=== Entropia cruzada binaria ===

Para clasificacion binaria con probabilidad predicha <math>p</math> y etiqueta verdadera <math>y \in \{0, 1\}</math>:

:<math>L_{\text{BCE}} = -\frac{1}{N}\sum_{i=1}^{N}\bigl[y_i \log p_i + (1 - y_i)\log(1 - p_i)\bigr]</math>

Esta perdida se minimiza cuando la probabilidad predicha coincide perfectamente con la etiqueta verdadera (<math>p = 1</math> cuando <math>y = 1</math> y <math>p = 0</math> cuando <math>y = 0</math>).

=== Entropia cruzada categorica ===

Para clasificacion multiclase con <math>C</math> clases y vector de probabilidad predicho <math>\hat{\mathbf{y}}</math>:

:<math>L_{\text{CE}} = -\frac{1}{N}\sum_{i=1}^{N}\sum_{c=1}^{C} y_{i,c} \log \hat{y}_{i,c}</math>

Cuando las etiquetas verdaderas estan codificadas en formato one-hot, solo sobrevive el termino correspondiente a la clase correcta.

== Perdida de bisagra ==

La '''perdida de bisagra''' esta asociada con las maquinas de vectores de soporte (SVM) y los clasificadores de margen maximo. Para un problema de clasificacion binaria con etiquetas <math>y \in \{-1, +1\}</math> y salida cruda del modelo <math>s</math>:

:<math>L_{\text{hinge}} = \frac{1}{N}\sum_{i=1}^{N}\max(0,\; 1 - y_i \, s_i)</math>

La perdida de bisagra es cero cuando la prediccion tiene el signo correcto con un margen de al menos 1, y aumenta linealmente en caso contrario. Dado que no es diferenciable en el punto de bisagra, se utilizan metodos de subgradiente para la optimizacion.

== Otras funciones de perdida comunes ==

{| class="wikitable"
|-
! Perdida !! Formula !! Uso tipico
|-
| '''Huber''' || <math>\begin{cases}\tfrac{1}{2}(y-\hat{y})^2 & |y-\hat{y}|\leq\delta \\ \delta(|y-\hat{y}|-\tfrac{\delta}{2}) & \text{otherwise}\end{cases}</math> || Regresion robusta
|-
| '''Divergencia KL''' || <math>\sum_c p_c \log\frac{p_c}{q_c}</math> || Ajuste de distribuciones, VAE
|-
| '''Perdida focal''' || <math>-\alpha(1-p_t)^\gamma \log p_t</math> || Clasificacion desbalanceada
|-
| '''Perdida CTC''' || Programacion dinamica sobre alineamientos || Reconocimiento de voz, OCR
|-
| '''Perdida de tripleta''' || <math>\max(0,\; d(a,p) - d(a,n) + m)</math> || Aprendizaje de metricas, verificacion facial
|}

== Eleccion de la perdida adecuada ==

La funcion de perdida apropiada depende de la tarea:

* '''Regresion''' — el MSE es la opcion predeterminada; se cambia a MAE o Huber si los valores atipicos son una preocupacion.
* '''Clasificacion binaria''' — entropia cruzada binaria con salida sigmoide.
* '''Clasificacion multiclase''' — entropia cruzada categorica con salida softmax.
* '''Clasificacion multietiqueta''' — entropia cruzada binaria aplicada independientemente por etiqueta.
* '''Ranking o recuperacion''' — perdida contrastiva, perdida de tripleta o perdidas de ranking por lista.

Una consideracion importante es si la perdida esta '''calibrada''' — es decir, si minimizarla produce probabilidades predichas bien calibradas. La entropia cruzada es una regla de puntuacion propia y produce probabilidades calibradas, mientras que la perdida de bisagra no.

== Terminos de regularizacion ==

En la practica, el objetivo total a menudo incluye un '''termino de regularizacion''' que penaliza la complejidad del modelo:

:<math>J(\theta) = L(\theta) + \lambda \, R(\theta)</math>

donde <math>\lambda</math> controla la intensidad de la regularizacion. Las opciones comunes incluyen la regularizacion L2 (<math>R = \|\theta\|_2^2</math>) y la regularizacion L1 (<math>R = \|\theta\|_1</math>). Vease [[Overfitting and Regularization]] para mas detalles.

== Vease tambien ==

* [[Gradient Descent]]
* [[Neural Networks]]
* [[Backpropagation]]
* [[Overfitting and Regularization]]
* [[Stochastic Gradient Descent]]

== Referencias ==

* Bishop, C. M. (2006). ''Pattern Recognition and Machine Learning'', Chapter 1. Springer.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapters 6 and 8. MIT Press.
* Lin, T.-Y. et al. (2017). "Focal Loss for Dense Object Detection". ''ICCV''.
* Murphy, K. P. (2022). ''Probabilistic Machine Learning: An Introduction''. MIT Press.

[[Category:Machine Learning]]
[[Category:Introductory]]

Linear Regression/es

2026-04-24T07:09:01Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Linear Regression}}
{{ArticleInfobox | topic_area = Statistics | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

La '''regresion lineal''' es un metodo estadistico fundamental que modela la relacion entre una variable dependiente y una o mas variables independientes ajustando una ecuacion lineal a los datos observados. Es una de las tecnicas mas antiguas y ampliamente utilizadas en estadistica y aprendizaje automatico, sirviendo tanto como herramienta predictiva practica como bloque de construccion para comprender modelos mas complejos.

== Planteamiento del problema ==

Dado un conjunto de datos de <math>N</math> observaciones <math>\{(\mathbf{x}_i, y_i)\}_{i=1}^{N}</math>, donde <math>\mathbf{x}_i \in \mathbb{R}^d</math> es un vector de caracteristicas y <math>y_i \in \mathbb{R}</math> es el objetivo, la regresion lineal asume la relacion:

:<math>y_i = \mathbf{w}^{\!\top} \mathbf{x}_i + b + \epsilon_i</math>

donde <math>\mathbf{w} \in \mathbb{R}^d</math> es el vector de pesos, <math>b</math> es el sesgo (intercepto) y <math>\epsilon_i</math> es el termino de error. Al absorber el sesgo en el vector de pesos (anadiendo un 1 a cada <math>\mathbf{x}_i</math>), esto se simplifica a <math>y_i = \mathbf{w}^{\!\top} \mathbf{x}_i + \epsilon_i</math>.

== Minimos cuadrados ordinarios ==

El metodo de '''minimos cuadrados ordinarios''' (MCO) encuentra los pesos que minimizan la suma de los residuos al cuadrado:

:<math>\mathcal{L}(\mathbf{w}) = \sum_{i=1}^{N} (y_i - \mathbf{w}^{\!\top} \mathbf{x}_i)^2 = \|\mathbf{y} - X\mathbf{w}\|^2</math>

donde <math>X \in \mathbb{R}^{N \times d}</math> es la matriz de diseno y <math>\mathbf{y} \in \mathbb{R}^N</math> es el vector de objetivos.

=== Solucion en forma cerrada ===

Igualando el gradiente a cero se obtienen las '''ecuaciones normales''':

:<math>\nabla_{\mathbf{w}} \mathcal{L} = -2 X^{\!\top}(\mathbf{y} - X\mathbf{w}) = 0</math>

:<math>\hat{\mathbf{w}} = (X^{\!\top} X)^{-1} X^{\!\top} \mathbf{y}</math>

Esta solucion existe y es unica cuando <math>X^{\!\top} X</math> es invertible (es decir, las caracteristicas son linealmente independientes). El coste computacional es <math>O(Nd^2 + d^3)</math>, lo cual es eficiente para <math>d</math> moderado pero se vuelve costoso para problemas de alta dimensionalidad.

=== Enfoque por descenso de gradiente ===

Cuando la solucion en forma cerrada es impracticable (valores grandes de <math>d</math> o <math>N</math>), se utiliza la optimizacion iterativa mediante [[Stochastic Gradient Descent|descenso de gradiente]]. El gradiente es:

:<math>\nabla_{\mathbf{w}} \mathcal{L} = -\frac{2}{N} X^{\!\top}(\mathbf{y} - X\mathbf{w})</math>

La regla de actualizacion es <math>\mathbf{w} \leftarrow \mathbf{w} - \eta \nabla_{\mathbf{w}} \mathcal{L}</math>, donde <math>\eta</math> es la tasa de aprendizaje. Las variantes estocastica y por mini-lotes escalan a millones de puntos de datos.

== Supuestos de MCO ==

El estimador MCO clasico es '''BLUE''' (Mejor Estimador Lineal Insesgado) bajo las condiciones de Gauss-Markov:

# '''Linealidad''': La relacion verdadera entre las caracteristicas y el objetivo es lineal.
# '''Independencia''': Las observaciones son independientes entre si.
# '''Homocedasticidad''': La varianza del error <math>\mathrm{Var}(\epsilon_i) = \sigma^2</math> es constante en todas las observaciones.
# '''Sin multicolinealidad perfecta''': Ninguna caracteristica es una combinacion lineal exacta de otras.
# '''Exogeneidad''': <math>E[\epsilon_i \mid \mathbf{x}_i] = 0</math> — los errores no estan correlacionados con las caracteristicas.

Las violaciones de estos supuestos no necesariamente hacen que la regresion lineal sea inutil, pero pueden invalidar los intervalos de confianza y las pruebas de hipotesis derivadas del modelo.

== Metricas de evaluacion ==

{| class="wikitable"
|-
! Metrica !! Formula !! Interpretacion
|-
| '''MSE''' || <math>\frac{1}{N}\sum(y_i - \hat{y}_i)^2</math> || Error cuadratico promedio; penaliza errores grandes
|-
| '''RMSE''' || <math>\sqrt{\mathrm{MSE}}</math> || En las mismas unidades que el objetivo
|-
| '''MAE''' || <math>\frac{1}{N}\sum|y_i - \hat{y}_i|</math> || Error absoluto promedio; robusto a valores atipicos
|-
| '''R-cuadrado''' || <math>1 - \frac{\sum(y_i - \hat{y}_i)^2}{\sum(y_i - \bar{y})^2}</math> || Proporcion de varianza explicada (0 a 1)
|}

Un <math>R^2</math> de 1 indica prediccion perfecta, mientras que <math>R^2 = 0</math> significa que el modelo no es mejor que predecir la media. El '''R-cuadrado ajustado''' penaliza por el numero de caracteristicas, previniendo la inflacion artificial al anadir predictores irrelevantes.

== Regresion multiple ==

Cuando <math>d > 1</math>, el modelo se denomina '''regresion lineal multiple'''. Cada coeficiente <math>w_j</math> representa el cambio esperado en <math>y</math> por unidad de cambio en <math>x_j</math>, manteniendo todas las demas caracteristicas constantes. Interpretar los coeficientes requiere cautela cuando las caracteristicas estan correlacionadas (multicolinealidad), ya que los coeficientes individuales pueden volverse inestables aunque el modelo global ajuste bien.

== Variantes regularizadas ==

Cuando el numero de caracteristicas es grande en relacion con el numero de observaciones, o cuando las caracteristicas estan correlacionadas, MCO puede sobreajustar. La regularizacion anade una penalizacion a la funcion de perdida:

=== Regresion Ridge (L2) ===

:<math>\mathcal{L}_{\mathrm{ridge}} = \|\mathbf{y} - X\mathbf{w}\|^2 + \lambda \|\mathbf{w}\|_2^2</math>

La solucion en forma cerrada se convierte en <math>\hat{\mathbf{w}} = (X^{\!\top} X + \lambda I)^{-1} X^{\!\top} \mathbf{y}</math>. Ridge reduce los coeficientes hacia cero pero nunca los establece exactamente en cero.

=== Regresion Lasso (L1) ===

:<math>\mathcal{L}_{\mathrm{lasso}} = \|\mathbf{y} - X\mathbf{w}\|^2 + \lambda \|\mathbf{w}\|_1</math>

Lasso puede llevar los coeficientes exactamente a cero, realizando una '''seleccion automatica de caracteristicas'''. No tiene solucion en forma cerrada y se resuelve tipicamente mediante descenso por coordenadas.

=== Elastic Net ===

Elastic Net combina ambas penalizaciones: <math>\lambda_1 \|\mathbf{w}\|_1 + \lambda_2 \|\mathbf{w}\|_2^2</math>, equilibrando dispersidad y estabilidad.

== Consideraciones practicas ==

* '''Escalado de caracteristicas''': Estandarizar las caracteristicas (media cero, varianza unitaria) mejora la convergencia del descenso de gradiente y hace que la regularizacion sea equitativa entre las caracteristicas.
* '''Caracteristicas polinomicas''': Anadir terminos polinomicos (por ejemplo, <math>x^2, x_1 x_2</math>) permite a la regresion lineal capturar relaciones no lineales.
* '''Valores atipicos''': MCO es sensible a los valores atipicos debido a la perdida cuadratica. Las alternativas robustas incluyen la regresion de Huber y RANSAC.
* '''Graficos de diagnostico''': Los graficos de residuos ayudan a detectar violaciones de los supuestos (no linealidad, heterocedasticidad, no normalidad).

== Vease tambien ==

* [[Stochastic Gradient Descent]]
* [[Logistic regression]]
* [[Loss Functions]]
* [[Overfitting and Regularization]]
* [[Neural Networks]]

== Referencias ==

* Hastie, T., Tibshirani, R. and Friedman, J. (2009). ''The Elements of Statistical Learning''. Springer, Chapter 3.
* Montgomery, D. C., Peck, E. A. and Vining, G. G. (2012). ''Introduction to Linear Regression Analysis''. Wiley.
* Hoerl, A. E. and Kennard, R. W. (1970). "Ridge Regression: Biased Estimation for Nonorthogonal Problems". ''Technometrics''.
* Tibshirani, R. (1996). "Regression Shrinkage and Selection via the Lasso". ''Journal of the Royal Statistical Society, Series B''.

[[Category:Statistics]]
[[Category:Introductory]]

Gradient Descent/es

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Gradient Descent}}
{{ArticleInfobox | topic_area = Optimization | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Descenso de gradiente''' es un algoritmo de optimizacion iterativo de primer orden para encontrar un minimo local de una funcion diferenciable. Constituye la base de practicamente todos los procedimientos de entrenamiento del aprendizaje automatico moderno, desde la regresion lineal simple hasta las redes neuronales profundas con miles de millones de parametros.

== Intuicion ==

Imaginese de pie en la ladera de una montana en medio de una niebla espesa. No se puede ver el fondo del valle, pero se puede sentir la pendiente bajo los pies. La estrategia mas natural consiste en dar un paso en la direccion de mayor descenso y luego reevaluar. El descenso de gradiente formaliza precisamente esta idea: en cada paso, el algoritmo calcula la direccion de mayor crecimiento de la funcion (el '''gradiente''') y se desplaza en la direccion opuesta.

El tamano de cada paso esta controlado por un escalar denominado '''tasa de aprendizaje''' (frecuentemente denotada <math>\eta</math>). Una tasa de aprendizaje grande cubre terreno rapidamente pero corre el riesgo de sobrepasar el minimo; una tasa de aprendizaje pequena converge de forma mas fiable pero puede requerir un numero prohibitivamente alto de pasos.

== Formulacion matematica ==

Dada una funcion objetivo diferenciable <math>f:\mathbb{R}^n \to \mathbb{R}</math>, el descenso de gradiente genera una secuencia de iteraciones mediante la '''regla de actualizacion''':

:<math>\theta_{t+1} = \theta_t - \eta \, \nabla f(\theta_t)</math>

donde <math>\nabla f(\theta_t)</math> es el vector gradiente evaluado en el punto actual <math>\theta_t</math> y <math>\eta > 0</math> es la tasa de aprendizaje.

En el caso unidimensional, esto se simplifica a:

:<math>\theta_{t+1} = \theta_t - \eta \, f'(\theta_t)</math>

El gradiente <math>\nabla f</math> apunta en la direccion de mayor ascenso, por lo que restarlo mueve la iteracion cuesta abajo.

== Variantes por lotes, estocastica y mini-lotes ==

Cuando la funcion objetivo tiene la forma de un promedio sobre puntos de datos,

:<math>f(\theta) = \frac{1}{N}\sum_{i=1}^{N} \ell(\theta;\, x_i, y_i)</math>

tres estrategias comunes difieren en la cantidad de datos utilizada para estimar el gradiente:

{| class="wikitable"
|-
! Variante !! Gradiente calculado sobre !! Coste por paso !! Ruido del gradiente
|-
| '''Descenso de gradiente por lotes (completo)''' || Las <math>N</math> muestras || Alto || Ninguno
|-
| '''Descenso de gradiente estocastico (SGD)''' || 1 muestra aleatoria || Bajo || Alto
|-
| '''Descenso de gradiente por mini-lotes''' || <math>B</math> muestras aleatorias (<math>1 < B < N</math>) || Medio || Medio
|}

El descenso de gradiente por lotes completo calcula el gradiente exacto y, por lo tanto, sigue una trayectoria suave hacia el minimo. [[Stochastic Gradient Descent|El descenso de gradiente estocastico]] utiliza una unica muestra para estimar el gradiente, lo que reduce drasticamente el calculo por paso a costa de una trayectoria mas ruidosa. El descenso de gradiente por mini-lotes logra un equilibrio y es la opcion mas comun en la practica, con tamanos de lote tipicos entre 32 y 512.

== Convergencia ==

=== Funciones convexas ===

Para una funcion convexa con gradientes Lipschitz-continuos (constante <math>L</math>), el descenso de gradiente con una tasa de aprendizaje fija <math>\eta \leq 1/L</math> converge a una tasa de <math>O(1/t)</math>. Si la funcion es adicionalmente '''fuertemente convexa''' con parametro <math>\mu > 0</math>, la convergencia se acelera a una tasa lineal (exponencial):

:<math>f(\theta_t) - f(\theta^*) \leq \left(1 - \frac{\mu}{L}\right)^t \bigl(f(\theta_0) - f(\theta^*)\bigr)</math>

La relacion <math>\kappa = L / \mu</math> se denomina '''numero de condicion''' y determina la velocidad de convergencia del algoritmo. Los problemas mal condicionados (con <math>\kappa</math> grande) convergen lentamente.

=== Funciones no convexas ===

La mayoria de las funciones objetivo del aprendizaje profundo son no convexas. En este escenario, solo se garantiza que el descenso de gradiente converja a un punto estacionario (donde <math>\nabla f = 0</math>), que podria ser un minimo local, un punto de silla o incluso un maximo local. En la practica, los puntos de silla son mas problematicos que los minimos locales en espacios de alta dimension.

== Seleccion de la tasa de aprendizaje ==

La eleccion de la tasa de aprendizaje es una de las decisiones practicas mas importantes:

* '''Demasiado grande''' — las iteraciones oscilan o divergen.
* '''Demasiado pequena''' — la convergencia es inaceptablemente lenta.
* '''Programas de tasa de aprendizaje''' — muchos profesionales comienzan con una tasa mayor y la reducen con el tiempo (decaimiento por escalones, decaimiento exponencial, recocido coseno).
* '''Busqueda de linea''' — los metodos numericos clasicos eligen <math>\eta</math> en cada paso para satisfacer condiciones como las de Wolfe o Armijo, aunque esto es poco habitual en el aprendizaje profundo.

Una heuristica comun consiste en probar varios valores en una escala logaritmica (por ejemplo, <math>10^{-1}, 10^{-2}, 10^{-3}</math>) y elegir el que reduzca la perdida mas rapidamente sin inestabilidad.

== Extensiones y mejoras ==

Varias modificaciones importantes abordan las limitaciones del descenso de gradiente basico:

* '''Momento''' — acumula un vector de velocidad a partir de gradientes anteriores, lo que ayuda a acelerar la convergencia en paisajes con forma de barranco.
* '''Gradiente acelerado de Nesterov''' — una variante del momento que evalua el gradiente en una posicion anticipada, obteniendo mejores tasas de convergencia teoricas.
* '''Metodos adaptativos''' (Adagrad, RMSProp, Adam) — mantienen tasas de aprendizaje por parametro que se adaptan segun el historial de gradientes.
* '''Metodos de segundo orden''' — algoritmos como el metodo de Newton y L-BFGS utilizan informacion de curvatura (la hessiana o su aproximacion) para una convergencia mas rapida, pero suelen ser demasiado costosos para problemas a gran escala.

== Consejos practicos ==

* '''Escalado de caracteristicas''' — normalizar las caracteristicas de entrada para que tengan rangos similares mejora drasticamente la convergencia, porque la superficie de perdida se vuelve mas isotropica.
* '''Recorte de gradientes''' — limitar la norma del gradiente evita actualizaciones excesivamente grandes.
* '''Inicializacion aleatoria''' — comenzar desde una inicializacion aleatoria razonable (por ejemplo, inicializacion de Xavier o He para redes neuronales) evita problemas de ruptura de simetria.
* '''Monitorizacion de la curva de perdida''' — graficar la perdida de entrenamiento a lo largo de las iteraciones es el diagnostico mas sencillo: una curva que decrece suavemente indica un entrenamiento saludable; las oscilaciones sugieren que la tasa de aprendizaje es demasiado alta.

== Aplicaciones ==

El descenso de gradiente y sus variantes se utilizan en toda la ciencia y la ingenieria:

* Entrenamiento de modelos de aprendizaje automatico (modelos lineales, redes neuronales, maquinas de vectores de soporte)
* Procesamiento de senales y sistemas de control
* Problemas inversos en fisica e imagen
* Investigacion de operaciones y optimizacion logistica
* Economia y calculo de equilibrios en teoria de juegos

== Vease tambien ==

* [[Stochastic Gradient Descent]]
* [[Backpropagation]]
* [[Loss Functions]]
* [[Neural Networks]]
* [[Overfitting and Regularization]]

== Referencias ==

* Cauchy, A. (1847). "Methode generale pour la resolution des systemes d'equations simultanees". ''Comptes Rendus de l'Academie des Sciences''.
* Boyd, S. and Vandenberghe, L. (2004). ''Convex Optimization''. Cambridge University Press.
* Ruder, S. (2016). "An overview of gradient descent optimization algorithms". ''arXiv:1609.04747''.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 8. MIT Press.

[[Category:Optimization]]
[[Category:Introductory]]

Dropout/es

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Dropout}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Overfitting and Regularization]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Dropout''' es una tecnica de regularizacion para redes neuronales que establece aleatoriamente una fraccion de las activaciones neuronales a cero durante cada paso de entrenamiento. Introducida por Srivastava et al. (2014), dropout es uno de los metodos mas ampliamente utilizados para prevenir el sobreajuste en el aprendizaje profundo.

== Motivacion: coadaptacion ==

En las redes neuronales grandes, las neuronas pueden desarrollar patrones complejos de '''coadaptacion''' — grupos de neuronas que solo funcionan correctamente en presencia de otras neuronas especificas. Este acoplamiento estrecho hace que la red sea fragil y propensa al sobreajuste, ya que las caracteristicas aprendidas dependen de las idiosincrasias particulares de los datos de entrenamiento en lugar de capturar patrones robustos y generales.

Dropout rompe estas coadaptaciones obligando a cada neurona a aprender caracteristicas que sean utiles en conjunto con muchos subconjuntos aleatorios diferentes de las demas neuronas.

== El algoritmo de dropout ==

=== Durante el entrenamiento ===

En cada paso de entrenamiento, cada neurona en una capa de dropout se retiene independientemente con probabilidad <math>p</math> (la '''probabilidad de retencion''') o se establece en cero con probabilidad <math>1 - p</math>. Formalmente, para una capa con vector de activacion <math>\mathbf{h}</math>:

:<math>r_j \sim \mathrm{Bernoulli}(p)</math>

:<math>\tilde{h}_j = r_j \cdot h_j</math>

donde <math>r_j</math> es una mascara binaria extraida independientemente para cada neurona <math>j</math>. Una probabilidad de retencion tipica es <math>p = 0.5</math> para capas ocultas y <math>p = 0.8</math> o mayor para la capa de entrada.

Cada paso de entrenamiento efectivamente entrena una subred "adelgazada" diferente muestreada de la arquitectura completa. Con <math>n</math> neuronas, existen <math>2^n</math> posibles subredes, creando un ensamblaje implicito.

=== Durante la inferencia: dropout invertido ===

En el momento de la inferencia, todas las neuronas estan activas, por lo que la salida esperada de cada neurona esta escalada por un factor de <math>p</math> en relacion con el entrenamiento. Dos enfoques abordan esto:

* '''Dropout estandar''': Multiplicar todos los pesos por <math>p</math> en el momento de la prueba.
* '''Dropout invertido''' (mas comun): Durante el entrenamiento, dividir las activaciones retenidas por <math>p</math>:

:<math>\tilde{h}_j = \frac{r_j \cdot h_j}{p}</math>

El dropout invertido asegura que el valor esperado de <math>\tilde{h}_j</math> sea igual a <math>h_j</math> durante el entrenamiento, de modo que no se necesita ajuste en la inferencia. Esta es la implementacion predeterminada en frameworks como PyTorch y TensorFlow.

== Interpretacion teorica ==

=== Perspectiva de ensamblaje ===

Dropout puede verse como el entrenamiento de un ensamblaje exponencialmente grande de subredes con amplia comparticion de pesos. En el momento de la prueba, utilizar la red completa con pesos escalados aproxima la media geometrica de las predicciones de todas las <math>2^n</math> subredes. Este promediado del ensamblaje reduce la varianza y mejora la generalizacion.

=== Interpretacion bayesiana ===

Gal y Ghahramani (2016) demostraron que una red neuronal con dropout aplicado antes de cada capa de pesos es matematicamente equivalente a una aproximacion de un proceso gaussiano profundo. Realizar dropout en el momento de la prueba ('''dropout de Monte Carlo''') produce una distribucion sobre las predicciones, proporcionando una estimacion practica de la incertidumbre del modelo.

== Variantes de dropout ==

{| class="wikitable"
|-
! Variante !! Descripcion !! Aplicacion tipica
|-
| '''Dropout estandar''' || Descarta neuronas individuales || Capas completamente conectadas
|-
| '''Dropout espacial''' || Descarta mapas de caracteristicas completos (canales) || Redes convolucionales
|-
| '''DropConnect''' || Descarta pesos individuales en lugar de neuronas || Capas densas
|-
| '''Dropout variacional''' || Aprende la tasa de dropout por neurona/peso || Aprendizaje profundo bayesiano
|-
| '''DropBlock''' || Descarta regiones contiguas de mapas de caracteristicas || Redes convolucionales
|-
| '''Alpha dropout''' || Mantiene la propiedad de autonormalizacion (para activaciones SELU) || Redes autonormalizantes
|}

El '''dropout espacial''' (Tompson et al., 2015) es particularmente importante para las redes convolucionales. El dropout estandar sobre mapas de caracteristicas convolucionales es ineficaz porque las activaciones adyacentes estan altamente correlacionadas; descartar pixeles individuales aun deja informacion espacial redundante. El dropout espacial en cambio descarta canales completos, obligando a la red a utilizar representaciones de caracteristicas diversas.

== Directrices practicas ==

* '''Ubicacion''': Aplicar dropout despues de la funcion de activacion en capas completamente conectadas. En los Transformers, dropout se aplica a los pesos de atencion y despues de las subcapas de red prealimentada.
* '''Seleccion de tasa''': Comenzar con <math>p = 0.5</math> para capas ocultas. Utilizar tasas de retencion mas altas (menor dropout) para capas con menos parametros. Aumentar el dropout para modelos mas grandes o conjuntos de datos mas pequenos.
* '''Interaccion con BatchNorm''': Utilizar dropout y [[Batch Normalization]] juntos requiere cuidado, ya que dropout introduce varianza que puede desestabilizar las estadisticas del lote. Una practica comun es aplicar dropout solo despues de la ultima capa con batch normalization.
* '''Dropout programado''': Algunos regimenes de entrenamiento comienzan sin dropout y lo aumentan gradualmente, o viceversa, a lo largo del entrenamiento.

== Efecto sobre el entrenamiento ==

Dropout tipicamente aumenta la perdida de entrenamiento y ralentiza la convergencia, ya que la capacidad efectiva del modelo se reduce en cada paso. Sin embargo, disminuye la brecha entre el rendimiento de entrenamiento y validacion, lo que conduce a una mejor generalizacion. Si la perdida de entrenamiento ya es alta (subajuste), el dropout debe reducirse o eliminarse.

== Vease tambien ==

* [[Overfitting and Regularization]]
* [[Batch Normalization]]
* [[Neural Networks]]
* [[Backpropagation]]
* [[Bayesian deep learning]]

== Referencias ==

* Srivastava, N. et al. (2014). "Dropout: A Simple Way to Prevent Neural Networks from Overfitting". ''Journal of Machine Learning Research'' 15(56):1929–1958.
* Gal, Y. and Ghahramani, Z. (2016). "Dropout as a Bayesian Approximation: Representing Model Uncertainty in Deep Learning". ''ICML''.
* Tompson, J. et al. (2015). "Efficient Object Localization Using Convolutional Networks". ''CVPR''.
* Wan, L. et al. (2013). "Regularization of Neural Networks using DropConnect". ''ICML''.
* Ghiasi, G., Lin, T.-Y. and Le, Q. V. (2018). "DropBlock: A regularization method for convolutional networks". ''NeurIPS''.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Cross-Entropy Loss/es

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Cross-Entropy Loss}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Intermediate | prerequisites = [[Loss Functions]], [[Softmax Function]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

La '''perdida de entropia cruzada''' (tambien llamada '''perdida logaritmica''') es la funcion de perdida mas ampliamente utilizada para tareas de clasificacion en el aprendizaje automatico. Con raices en la teoria de la informacion, mide la disimilitud entre la distribucion de la etiqueta verdadera y la distribucion de probabilidad predicha por el modelo, proporcionando un objetivo suave y diferenciable que impulsa a los clasificadores probabilisticos hacia predicciones correctas y con alta confianza.

== Fundamentos de la teoria de la informacion ==

=== Entropia ===

La '''entropia''' de una distribucion de probabilidad discreta <math>p</math> cuantifica su incertidumbre:

:<math>H(p) = -\sum_{k=1}^{K} p_k \log p_k</math>

Para una distribucion determinista (etiqueta one-hot), <math>H(p) = 0</math>. La entropia se maximiza cuando todos los resultados son igualmente probables.

=== Divergencia KL ===

La '''divergencia de Kullback-Leibler''' mide cuanto difiere una distribucion <math>q</math> de una distribucion de referencia <math>p</math>:

:<math>D_{\mathrm{KL}}(p \,\|\, q) = \sum_{k=1}^{K} p_k \log \frac{p_k}{q_k}</math>

La divergencia KL es no negativa e igual a cero si y solo si <math>p = q</math>.

=== Entropia cruzada ===

La '''entropia cruzada''' entre las distribuciones <math>p</math> (verdadera) y <math>q</math> (predicha) es:

:<math>H(p, q) = -\sum_{k=1}^{K} p_k \log q_k = H(p) + D_{\mathrm{KL}}(p \,\|\, q)</math>

Dado que <math>H(p)</math> es constante con respecto a los parametros del modelo, minimizar la entropia cruzada es equivalente a minimizar la divergencia KL — es decir, hacer que la distribucion predicha <math>q</math> sea lo mas cercana posible a la distribucion verdadera <math>p</math>.

== Entropia cruzada binaria ==

Para clasificacion binaria con etiqueta verdadera <math>y \in \{0, 1\}</math> y probabilidad predicha <math>\hat{y} = \sigma(z)</math> (donde <math>\sigma</math> es la [[Softmax Function|funcion sigmoide]]):

:<math>\mathcal{L}_{\mathrm{BCE}} = -\bigl[y \log \hat{y} + (1 - y) \log(1 - \hat{y})\bigr]</math>

Sobre un conjunto de datos de <math>N</math> muestras:

:<math>\mathcal{L} = -\frac{1}{N} \sum_{i=1}^{N} \bigl[y_i \log \hat{y}_i + (1 - y_i) \log(1 - \hat{y}_i)\bigr]</math>

El gradiente con respecto al logit <math>z</math> toma la forma elegantemente simple <math>\hat{y} - y</math>, que es tanto intuitiva como computacionalmente eficiente.

== Entropia cruzada categorica ==

Para clasificacion multiclase con <math>K</math> clases, la etiqueta verdadera es tipicamente un vector one-hot <math>\mathbf{y}</math> con <math>y_c = 1</math> para la clase correcta <math>c</math>. Las probabilidades predichas <math>\hat{\mathbf{y}}</math> se obtienen mediante la [[Softmax Function|funcion softmax]]:

:<math>\mathcal{L}_{\mathrm{CE}} = -\sum_{k=1}^{K} y_k \log \hat{y}_k = -\log \hat{y}_c</math>

Esto se reduce a la probabilidad logaritmica negativa de la clase correcta, razon por la cual la entropia cruzada categorica tambien se denomina '''verosimilitud logaritmica negativa''' en este contexto.

== Estabilidad numerica ==

=== El truco log-sum-exp ===

Calcular ingenuamente <math>\log(\mathrm{softmax}(z_k))</math> implica exponenciar logits potencialmente grandes, causando desbordamiento. El truco '''log-sum-exp''' evita esto:

:<math>\log \hat{y}_k = z_k - \log \sum_{j=1}^{K} e^{z_j} = z_k - \left(m + \log \sum_{j=1}^{K} e^{z_j - m}\right)</math>

donde <math>m = \max_j z_j</math>. Restar el logit maximo asegura que el exponente mas grande sea cero, previniendo el desbordamiento. Todos los principales frameworks de aprendizaje profundo implementan esta operacion fusionada (por ejemplo, <code>CrossEntropyLoss</code> de PyTorch acepta logits crudos).

=== Recorte ===

Las probabilidades predichas deben recortarse lejos de exactamente 0 y 1 para evitar <math>\log(0) = -\infty</math>. Tipicamente se utiliza un epsilon pequeno (por ejemplo, <math>10^{-7}</math>).

== Suavizado de etiquetas ==

El '''suavizado de etiquetas''' (Szegedy et al., 2016) reemplaza el objetivo one-hot rigido con una distribucion suave:

:<math>y_k^{\mathrm{smooth}} = (1 - \alpha)\, y_k + \frac{\alpha}{K}</math>

donde <math>\alpha</math> es una constante pequena (comunmente 0.1). Esto evita que el modelo se vuelva excesivamente confiado, mejora la calibracion y a menudo produce una mejor generalizacion. Es practica estandar en el entrenamiento de grandes clasificadores de imagenes y modelos Transformer.

== Comparacion con otras perdidas ==

{| class="wikitable"
|-
! Perdida !! Formula !! Uso tipico
|-
| '''Entropia cruzada''' || <math>-\sum y_k \log \hat{y}_k</math> || Clasificacion
|-
| '''Error cuadratico medio''' || <math>\frac{1}{K}\sum(y_k - \hat{y}_k)^2</math> || Regresion (inadecuado para clasificacion)
|-
| '''Perdida de bisagra''' || <math>\max(0, 1 - y \cdot z)</math> || Clasificacion tipo SVM
|-
| '''Perdida focal''' || <math>-(1-\hat{y}_c)^\gamma \log \hat{y}_c</math> || Clasificacion desbalanceada
|}

La entropia cruzada tiene gradientes mas pronunciados que el MSE cuando la prediccion es confidencialmente erronea, lo que conduce a una correccion mas rapida de los errores grandes.

== Vease tambien ==

* [[Loss Functions]]
* [[Softmax Function]]
* [[Logistic regression]]
* [[Information theory]]
* [[Neural Networks]]

== Referencias ==

* Shannon, C. E. (1948). "A Mathematical Theory of Communication". ''Bell System Technical Journal''.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning''. MIT Press, Chapter 6.
* Szegedy, C. et al. (2016). "Rethinking the Inception Architecture for Computer Vision". ''CVPR''.
* Lin, T.-Y. et al. (2017). "Focal Loss for Dense Object Detection". ''ICCV''.

[[Category:Machine Learning]]
[[Category:Intermediate]]

Convolutional Neural Networks/es

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Convolutional Neural Networks}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Backpropagation]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

Las '''redes neuronales convolucionales''' ('''CNN''' o '''ConvNets''') son una clase de [[Neural Networks|redes neuronales]] profundas disenadas especificamente para procesar datos con una topologia de cuadricula, como imagenes (cuadriculas 2D de pixeles), espectrogramas de audio y video. Explotan la estructura espacial de la entrada mediante conectividad local, comparticion de pesos y agrupamiento (pooling), lo que las hace mucho mas eficientes que las redes completamente conectadas para tareas visuales y espaciales.

== La operacion de convolucion ==

El bloque de construccion fundamental es la '''convolucion discreta'''. Para una entrada 2D <math>\mathbf{X}</math> y un filtro (kernel) <math>\mathbf{K}</math> de tamano <math>k \times k</math>, el mapa de caracteristicas de salida <math>\mathbf{Y}</math> es:

:<math>Y_{i,j} = \sum_{m=0}^{k-1}\sum_{n=0}^{k-1} K_{m,n} \cdot X_{i+m,\, j+n} + b</math>

donde <math>b</math> es un termino de sesgo. El filtro se desliza (convoluciona) sobre la entrada, calculando un producto escalar en cada posicion. Tecnicamente, la mayoria de las implementaciones calculan una '''correlacion cruzada''' en lugar de una convolucion verdadera (que voltearía el kernel), pero la distincion es irrelevante dado que los pesos del kernel se aprenden.

Hiperparametros clave que controlan la convolucion:

* '''Tamano del kernel''' — la extension espacial del filtro (por ejemplo, <math>3 \times 3</math>, <math>5 \times 5</math>).
* '''Paso (stride)''' — el tamano del desplazamiento entre posiciones sucesivas del kernel. Un stride de 2 reduce las dimensiones espaciales a la mitad.
* '''Relleno (padding)''' — anadir ceros alrededor del borde de la entrada para controlar el tamano de la salida. El relleno "same" preserva las dimensiones espaciales; el relleno "valid" no utiliza relleno.

== Filtros y deteccion de caracteristicas ==

Cada filtro aprende a detectar un patron local especifico. En las capas iniciales, los filtros tipicamente responden a bordes, esquinas y gradientes de color. Las capas mas profundas componen estos en caracteristicas de nivel superior — texturas, partes y eventualmente objetos completos.

Una capa convolucional aplica multiples filtros en paralelo, produciendo una pila de mapas de caracteristicas. Si la entrada tiene <math>C_{\text{in}}</math> canales y la capa tiene <math>C_{\text{out}}</math> filtros, el numero total de parametros aprendibles es:

:<math>C_{\text{out}} \times (C_{\text{in}} \times k^2 + 1)</math>

Esto es drasticamente menor que una capa completamente conectada con las mismas dimensiones de entrada y salida, porque los pesos se comparten en todas las posiciones espaciales.

== Agrupamiento (pooling) ==

Las capas de '''agrupamiento''' (pooling) submuestrean los mapas de caracteristicas, reduciendo sus dimensiones espaciales y proporcionando cierto grado de invariancia a la traslacion. Operaciones de agrupamiento comunes:

* '''Max pooling''' — toma el valor maximo en cada ventana local (por ejemplo, <math>2 \times 2</math>).
* '''Average pooling''' — toma el valor medio en cada ventana.
* '''Global average pooling''' — promedia cada mapa de caracteristicas completo a un unico valor, frecuentemente utilizado antes de la capa de clasificacion final.

El agrupamiento reduce el coste computacional y ayuda a prevenir el sobreajuste al abstraer progresivamente la representacion.

== Arquitectura de una CNN ==

Una CNN tipica alterna capas convolucionales y capas de agrupamiento, seguidas de una o mas capas completamente conectadas para la prediccion final:

<pre>
Entrada → [Conv → ReLU → Pool] × N → Aplanar → FC → FC → Salida
</pre>

Cada bloque conv-pool extrae caracteristicas cada vez mas abstractas, mientras que las capas completamente conectadas las combinan para la clasificacion o regresion.

== Arquitecturas historicas ==

{| class="wikitable"
|-
! Arquitectura !! Ano !! Contribucion clave !! Profundidad
|-
| '''LeNet-5''' || 1998 || Pionera de las CNN para el reconocimiento de digitos manuscritos (MNIST) || 5 capas
|-
| '''AlexNet''' || 2012 || Gano ImageNet; popularizo ReLU, dropout y entrenamiento en GPU || 8 capas
|-
| '''VGGNet''' || 2014 || Demostro que la profundidad importa; uso solo filtros de <math>3 \times 3</math> || 16–19 capas
|-
| '''GoogLeNet (Inception)''' || 2014 || Introdujo modulos inception con tamanos de filtro en paralelo || 22 capas
|-
| '''ResNet''' || 2015 || Introdujo conexiones residuales que permiten redes muy profundas || 50–152+ capas
|-
| '''DenseNet''' || 2017 || Conecto cada capa con todas las capas subsiguientes mediante bloques densos || 121–264 capas
|-
| '''EfficientNet''' || 2019 || Escalado compuesto de profundidad, anchura y resolucion || Variable
|}

=== Conexiones residuales ===

La '''conexion residual''' (o conexion de salto) introducida por ResNet suma la entrada de un bloque directamente a su salida:

:<math>\mathbf{y} = \mathcal{F}(\mathbf{x}) + \mathbf{x}</math>

Esto permite que los gradientes fluyan directamente a traves de la ruta identidad, mitigando el problema del gradiente que se desvanece y permitiendo el entrenamiento de redes con cientos de capas. Las conexiones residuales se han convertido en un componente estandar en practicamente todas las arquitecturas modernas.

== Aplicaciones en vision por computador ==

Las CNN han alcanzado un rendimiento de vanguardia en una amplia gama de tareas de vision:

* '''Clasificacion de imagenes''' — asignar una etiqueta a una imagen completa (ImageNet, CIFAR).
* '''Deteccion de objetos''' — localizar y clasificar objetos dentro de una imagen (YOLO, Faster R-CNN, SSD).
* '''Segmentacion semantica''' — asignar una etiqueta de clase a cada pixel (U-Net, DeepLab).
* '''Segmentacion de instancias''' — distinguir instancias individuales de objetos (Mask R-CNN).
* '''Generacion de imagenes''' — generar imagenes realistas utilizando generadores basados en CNN (GAN, modelos de difusion).
* '''Imagen medica''' — deteccion de tumores, analisis de retina y cribado radiologico.

== Consejos practicos ==

* Utilizar modelos preentrenados (transfer learning) cuando los datos etiquetados son limitados.
* Preferir kernels pequenos (<math>3 \times 3</math>) apilados en profundidad — dos capas de <math>3 \times 3</math> tienen el mismo campo receptivo que una capa de <math>5 \times 5</math> pero con menos parametros.
* Aplicar batch normalization despues de la convolucion y antes de la activacion.
* Utilizar el aumento de datos generosamente para reducir el [[Overfitting and Regularization|sobreajuste]].
* Reemplazar las capas completamente conectadas con global average pooling para reducir parametros.

== Vease tambien ==

* [[Neural Networks]]
* [[Backpropagation]]
* [[Overfitting and Regularization]]
* [[Recurrent Neural Networks]]
* [[Gradient Descent]]

== Referencias ==

* LeCun, Y. et al. (1998). "Gradient-Based Learning Applied to Document Recognition". ''Proceedings of the IEEE''.
* Krizhevsky, A., Sutskever, I. and Hinton, G. E. (2012). "ImageNet Classification with Deep Convolutional Neural Networks". ''NeurIPS''.
* Simonyan, K. and Zisserman, A. (2015). "Very Deep Convolutional Networks for Large-Scale Image Recognition". ''ICLR''.
* He, K. et al. (2016). "Deep Residual Learning for Image Recognition". ''CVPR''.
* Tan, M. and Le, Q. V. (2019). "EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks". ''ICML''.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Batch Normalization/es

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Batch Normalization}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Backpropagation]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Batch normalization''' (frecuentemente abreviado '''BatchNorm''' o '''BN''') es una tecnica para mejorar la velocidad, estabilidad y rendimiento de las redes neuronales profundas mediante la normalizacion de las entradas a cada capa. Introducida por Ioffe y Szegedy en 2015, se ha convertido en un componente estandar en la mayoria de las arquitecturas modernas de aprendizaje profundo.

== Desplazamiento covariante interno ==

La motivacion original de batch normalization fue abordar el '''desplazamiento covariante interno''' — el fenomeno por el cual la distribucion de las entradas de cada capa cambia durante el entrenamiento a medida que se actualizan los parametros de las capas precedentes. Esta distribucion cambiante obliga a cada capa a adaptarse continuamente, ralentizando la convergencia y requiriendo una inicializacion cuidadosa y tasas de aprendizaje pequenas.

Aunque el papel preciso del desplazamiento covariante interno ha sido debatido (Santurkar et al., 2018, argumentaron que los beneficios de BatchNorm provienen mas del suavizado del paisaje de perdida), la efectividad practica de la tecnica esta bien establecida.

== El algoritmo de batch normalization ==

=== Durante el entrenamiento ===

Para un mini-lote <math>\mathcal{B} = \{x_1, \dots, x_m\}</math> de activaciones en una capa dada, BatchNorm procede de la siguiente manera:

'''Paso 1.''' Calcular la media y varianza del mini-lote:

:<math>\mu_{\mathcal{B}} = \frac{1}{m} \sum_{i=1}^{m} x_i, \qquad \sigma_{\mathcal{B}}^2 = \frac{1}{m} \sum_{i=1}^{m} (x_i - \mu_{\mathcal{B}})^2</math>

'''Paso 2.''' Normalizar:

:<math>\hat{x}_i = \frac{x_i - \mu_{\mathcal{B}}}{\sqrt{\sigma_{\mathcal{B}}^2 + \epsilon}}</math>

donde <math>\epsilon</math> es una constante pequena (por ejemplo, <math>10^{-5}</math>) para estabilidad numerica.

'''Paso 3.''' Escalar y desplazar con parametros aprendidos <math>\gamma</math> y <math>\beta</math>:

:<math>y_i = \gamma \hat{x}_i + \beta</math>

Los parametros <math>\gamma</math> y <math>\beta</math> se aprenden durante el entrenamiento. Restauran la capacidad de la red para representar la transformacion identidad si esta es optima, asegurando que la normalizacion no reduzca la expresividad del modelo.

=== Durante la inferencia ===

En el momento de la inferencia, las estadisticas de mini-lotes individuales no son fiables (la entrada puede ser un unico ejemplo). En su lugar, BatchNorm utiliza estimaciones acumuladas de la media y varianza poblacional acumuladas durante el entrenamiento mediante promedios moviles exponenciales:

:<math>\mu_{\mathrm{running}} \leftarrow (1 - \alpha)\, \mu_{\mathrm{running}} + \alpha\, \mu_{\mathcal{B}}</math>

:<math>\sigma^2_{\mathrm{running}} \leftarrow (1 - \alpha)\, \sigma^2_{\mathrm{running}} + \alpha\, \sigma^2_{\mathcal{B}}</math>

donde <math>\alpha</math> es el parametro de momento (tipicamente 0.1). Estas estadisticas fijas aseguran salidas deterministas en la inferencia.

== Beneficios ==

* '''Tasas de aprendizaje mas altas''': Al restringir las distribuciones de activacion, BatchNorm permite pasos mas grandes sin divergencia.
* '''Menor sensibilidad a la inicializacion''': Las redes con BatchNorm son mas tolerantes a una inicializacion de pesos deficiente.
* '''Efecto regularizador''': El ruido introducido por las estadisticas del mini-lote actua como un regularizador suave, a veces reduciendo la necesidad de [[Dropout]].
* '''Convergencia mas rapida''': El entrenamiento tipicamente requiere menos epocas para alcanzar un nivel dado de rendimiento.

== Ubicacion ==

BatchNorm se aplica tipicamente '''antes''' de la funcion de activacion (como en el articulo original), aunque algunos profesionales lo colocan '''despues''' de la activacion. Para capas convolucionales, la normalizacion se realiza por canal a traves de las dimensiones espaciales y la dimension del lote.

== Alternativas de normalizacion ==

{| class="wikitable"
|-
! Metodo !! Normaliza sobre !! Caso de uso
|-
| '''Batch Norm''' || Dimensiones del lote y espaciales, por canal || CNN con lotes grandes
|-
| '''Layer Norm''' || Todos los canales y dimensiones espaciales, por muestra || Transformers, RNN, lotes pequenos
|-
| '''Instance Norm''' || Solo dimensiones espaciales, por muestra por canal || Transferencia de estilo, generacion de imagenes
|-
| '''Group Norm''' || Grupos de canales, por muestra || Deteccion de objetos, entrenamiento con lotes pequenos
|}

La '''normalizacion de capa''' (Ba et al., 2016) normaliza a traves de todas las caracteristicas dentro de una unica muestra, haciendola independiente del tamano del lote. Es la opcion estandar en las arquitecturas Transformer.

La '''normalizacion de grupo''' (Wu y He, 2018) divide los canales en grupos y normaliza dentro de cada grupo por muestra. Sirve de puente entre Layer Norm e Instance Norm y funciona bien cuando los tamanos de lote son demasiado pequenos para obtener estadisticas de lote fiables.

== Limitaciones ==

* El rendimiento se degrada con tamanos de lote muy pequenos, ya que las estadisticas del lote se vuelven ruidosas.
* Introduce una discrepancia entre el comportamiento de entrenamiento (estadisticas de lote) y el de inferencia (estadisticas acumuladas).
* No es directamente aplicable a secuencias de longitud variable sin relleno o enmascaramiento.
* Las estadisticas acumuladas requieren un manejo cuidadoso cuando se utiliza entrenamiento distribuido en multiples dispositivos.

== Vease tambien ==

* [[Neural Networks]]
* [[Backpropagation]]
* [[Dropout]]
* [[Stochastic Gradient Descent]]
* [[Transformer]]

== Referencias ==

* Ioffe, S. and Szegedy, C. (2015). "Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift". ''ICML''.
* Ba, J. L., Kiros, J. R. and Hinton, G. E. (2016). "Layer Normalization". ''arXiv:1607.06450''.
* Wu, Y. and He, K. (2018). "Group Normalization". ''ECCV''.
* Santurkar, S. et al. (2018). "How Does Batch Normalization Help Optimization?". ''NeurIPS''.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Backpropagation/es

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Backpropagation}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Gradient Descent]], [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Backpropagation''' (abreviatura de '''propagacion hacia atras de errores''') es un algoritmo para calcular de manera eficiente el gradiente de una funcion de perdida con respecto a cada peso en una red neuronal. Combinado con un metodo de optimizacion como el [[Gradient Descent|descenso de gradiente]], constituye el procedimiento estandar de entrenamiento para los modelos modernos de aprendizaje profundo.

== La regla de la cadena ==

Backpropagation es fundamentalmente una aplicacion de la '''regla de la cadena''' del calculo. Si una variable <math>z</math> depende de <math>y</math>, que a su vez depende de <math>x</math>, entonces:

:<math>\frac{\partial z}{\partial x} = \frac{\partial z}{\partial y} \cdot \frac{\partial y}{\partial x}</math>

En una red neuronal, la perdida <math>L</math> depende de la salida, que depende de las activaciones de la ultima capa oculta, que dependen de las activaciones de la capa anterior, y asi sucesivamente hasta la entrada. La regla de la cadena permite descomponer el gradiente en un producto de derivadas locales, una para cada capa.

== Pasada hacia adelante ==

Durante la pasada hacia adelante, los datos de entrada se propagan a traves de la red capa por capa. Para una capa completamente conectada <math>l</math>:

:<math>\mathbf{z}^{(l)} = \mathbf{W}^{(l)} \mathbf{a}^{(l-1)} + \mathbf{b}^{(l)}</math>

:<math>\mathbf{a}^{(l)} = g^{(l)}(\mathbf{z}^{(l)})</math>

donde <math>\mathbf{a}^{(l-1)}</math> es la activacion de la capa anterior (con <math>\mathbf{a}^{(0)} = \mathbf{x}</math>), <math>\mathbf{W}^{(l)}</math> y <math>\mathbf{b}^{(l)}</math> son los pesos y sesgos, y <math>g^{(l)}</math> es la funcion de activacion. La pasada hacia adelante almacena todos los valores intermedios <math>\mathbf{z}^{(l)}</math> y <math>\mathbf{a}^{(l)}</math> porque se necesitan durante la pasada hacia atras.

== Pasada hacia atras ==

La pasada hacia atras calcula los gradientes comenzando desde la perdida y avanzando hacia la entrada. Se define la senal de error en la capa <math>l</math> como:

:<math>\boldsymbol{\delta}^{(l)} = \frac{\partial L}{\partial \mathbf{z}^{(l)}}</math>

Para la capa de salida (capa <math>L_{\text{out}}</math>):

:<math>\boldsymbol{\delta}^{(L_{\text{out}})} = \frac{\partial L}{\partial \mathbf{a}^{(L_{\text{out}})}} \odot g'^{(L_{\text{out}})}(\mathbf{z}^{(L_{\text{out}})})</math>

Para cada capa anterior, el error se propaga hacia atras:

:<math>\boldsymbol{\delta}^{(l)} = \bigl(\mathbf{W}^{(l+1)}\bigr)^\top \boldsymbol{\delta}^{(l+1)} \odot g'^{(l)}(\mathbf{z}^{(l)})</math>

donde <math>\odot</math> denota la multiplicacion elemento a elemento. Una vez conocida la senal de error, los gradientes de los parametros son:

:<math>\frac{\partial L}{\partial \mathbf{W}^{(l)}} = \boldsymbol{\delta}^{(l)} \bigl(\mathbf{a}^{(l-1)}\bigr)^\top, \qquad \frac{\partial L}{\partial \mathbf{b}^{(l)}} = \boldsymbol{\delta}^{(l)}</math>

== Grafos computacionales ==

Los frameworks modernos de aprendizaje profundo (PyTorch, TensorFlow, JAX) implementan backpropagation construyendo un '''grafo computacional''' — un grafo dirigido aciclico donde cada nodo representa una operacion y cada arista transporta un tensor. La pasada hacia adelante construye el grafo; la pasada hacia atras lo recorre en orden topologico inverso, aplicando la regla de la cadena en cada nodo.

Esta abstraccion permite diferenciar composiciones arbitrarias de operaciones, no solo tipos de capas estandar. Existen dos estrategias de implementacion:

* '''Grafos estaticos''' — el grafo se define una vez antes de la ejecucion (TensorFlow en sus versiones iniciales). Permite optimizaciones agresivas del compilador pero es menos flexible.
* '''Grafos dinamicos''' — el grafo se reconstruye en cada pasada hacia adelante (PyTorch, modo Eager de TensorFlow). Mas intuitivo para la depuracion y para modelos con flujo de control dependiente de los datos.

== Diferenciacion automatica ==

Backpropagation es un caso especial de la '''diferenciacion automatica en modo inverso''' (AD). A diferencia de la diferenciacion numerica (que es aproximada) o la diferenciacion simbolica (que puede producir expresiones inmanejables), la AD calcula derivadas exactas aplicando sistematicamente la regla de la cadena a las operaciones elementales.

La AD en modo inverso calcula el gradiente de una salida escalar con respecto a todas las entradas en una unica pasada hacia atras, lo que la hace ideal para las redes neuronales, donde la perdida es escalar pero los parametros se cuentan por millones.

El coste de la pasada hacia atras es tipicamente entre 2 y 3 veces el de la pasada hacia adelante, ya que debe evaluar los jacobianos locales y multiplicarlos con la senal de error entrante.

== Gradientes que se desvanecen y explotan ==

Cuando una red tiene muchas capas, el gradiente es un producto de muchas derivadas locales. Si estos factores son consistentemente menores que 1, el gradiente se reduce exponencialmente hacia cero — el problema del '''gradiente que se desvanece'''. Si son consistentemente mayores que 1, el gradiente crece exponencialmente — el problema del '''gradiente que explota'''.

{| class="wikitable"
|-
! Problema !! Sintoma !! Mitigaciones comunes
|-
| '''Gradientes que se desvanecen''' || Las capas iniciales aprenden extremadamente lento || Activaciones ReLU, conexiones residuales, batch normalization, inicializacion cuidadosa
|-
| '''Gradientes que explotan''' || La perdida diverge o produce valores NaN || Recorte de gradientes, regularizacion de pesos, tasa de aprendizaje mas baja
|}

Estos problemas fueron obstaculos importantes para el entrenamiento de redes profundas antes de la introduccion de las activaciones ReLU, las conexiones residuales (ResNets) y las tecnicas de normalizacion.

== Consideraciones practicas ==

* '''Memoria''' — la pasada hacia adelante debe almacenar todas las activaciones intermedias para la pasada hacia atras. Para redes muy profundas esto puede ser prohibitivo; el '''gradient checkpointing''' intercambia calculo por memoria al recalcular las activaciones durante la pasada hacia atras en lugar de almacenarlas.
* '''Estabilidad numerica''' — el uso de trucos como log-sum-exp e implementaciones fusionadas de softmax-cross-entropy evita el desbordamiento por exceso y por defecto.
* '''Gradientes de orden superior''' — diferenciar a traves de la propia pasada hacia atras produce informacion de segundo orden (productos hessiana-vector), util para metodos como el descenso de gradiente natural y el meta-aprendizaje.
* '''Precision mixta''' — realizar la pasada hacia adelante en media precision mientras se mantiene una copia maestra de los pesos en precision completa acelera el entrenamiento en GPUs modernas.

== Desarrollo historico ==

Las ideas clave detras de backpropagation fueron desarrolladas de forma independiente por varios investigadores. Seppo Linnainmaa describio la diferenciacion automatica en modo inverso en 1970. Paul Werbos la aplico a las redes neuronales en su tesis doctoral de 1974. El algoritmo alcanzo una adopcion generalizada tras el influyente articulo de 1986 de Rumelhart, Hinton y Williams, que demostro su eficacia en redes multicapa.

== Vease tambien ==

* [[Gradient Descent]]
* [[Stochastic Gradient Descent]]
* [[Neural Networks]]
* [[Loss Functions]]
* [[Convolutional Neural Networks]]
* [[Recurrent Neural Networks]]

== Referencias ==

* Rumelhart, D. E., Hinton, G. E. and Williams, R. J. (1986). "Learning representations by back-propagating errors". ''Nature'', 323, 533–536.
* Linnainmaa, S. (1970). "The representation of the cumulative rounding error of an algorithm as a Taylor expansion of the local rounding errors". Master's thesis, University of Helsinki.
* Werbos, P. J. (1974). "Beyond Regression: New Tools for Prediction and Analysis in the Behavioral Sciences". PhD thesis, Harvard University.
* Baydin, A. G. et al. (2018). "Automatic Differentiation in Machine Learning: a Survey". ''JMLR'', 18(153), 1–43.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 6. MIT Press.

[[Category:Deep Learning]]
[[Category:Intermediate]]

Attention Mechanisms/es

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Attention Mechanisms}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Advanced | prerequisites = [[Neural Networks]], [[Recurrent Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

Los '''mecanismos de atencion''' son una familia de tecnicas que permiten a las redes neuronales enfocarse selectivamente en las partes relevantes de su entrada al producir cada elemento de la salida. Introducidos originalmente para superar las limitaciones de los vectores de contexto de longitud fija en los modelos secuencia a secuencia, la atencion se ha convertido en el bloque de construccion fundamental de las arquitecturas modernas como el [[Transformer]].

== Motivacion ==

Los primeros modelos secuencia a secuencia codificaban una secuencia de entrada completa en un unico vector de dimension fija utilizando una [[Recurrent Neural Networks|red neuronal recurrente]]. Este ''cuello de botella'' obligaba a comprimir las dependencias de largo alcance en un vector de tamano constante, degradando el rendimiento en secuencias largas. La atencion resuelve esto permitiendo que el decodificador consulte todos los estados ocultos del codificador en cada paso de generacion, ponderandolos mediante puntuaciones de relevancia aprendidas.

== Atencion de Bahdanau (aditiva) ==

Bahdanau et al. (2015) propusieron el primer mecanismo de atencion ampliamente adoptado para la traduccion automatica. Dados los estados ocultos del codificador <math>h_1, \dots, h_T</math> y el estado del decodificador <math>s_{t-1}</math>, la puntuacion de alineamiento se calcula como:

:<math>e_{t,i} = v^{\!\top} \tanh(W_s\, s_{t-1} + W_h\, h_i)</math>

donde <math>W_s</math>, <math>W_h</math> y <math>v</math> son parametros aprendidos. Los pesos de atencion se obtienen aplicando softmax:

:<math>\alpha_{t,i} = \frac{\exp(e_{t,i})}{\sum_{j=1}^{T} \exp(e_{t,j})}</math>

El vector de contexto es la suma ponderada <math>c_t = \sum_{i=1}^{T} \alpha_{t,i}\, h_i</math>, que se concatena con <math>s_{t-1}</math> y se alimenta al decodificador.

== Atencion de Luong (multiplicativa) ==

Luong et al. (2015) simplificaron la funcion de puntuacion reemplazando la red aditiva con un producto escalar o una forma bilineal:

{| class="wikitable"
|-
! Variante !! Funcion de puntuacion
|-
| Dot || <math>e_{t,i} = s_t^{\!\top} h_i</math>
|-
| General || <math>e_{t,i} = s_t^{\!\top} W_a\, h_i</math>
|-
| Concat || <math>e_{t,i} = v^{\!\top} \tanh(W_a [s_t;\, h_i])</math>
|}

La variante dot requiere que las dimensiones del codificador y el decodificador coincidan, mientras que la variante general introduce una matriz de pesos aprendible <math>W_a</math>.

== Atencion de producto escalar escalado ==

Vaswani et al. (2017) introdujeron la formulacion utilizada en el Transformer. Dadas las matrices de consultas <math>Q</math>, claves <math>K</math> y valores <math>V</math>:

:<math>\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\!\left(\frac{Q K^{\!\top}}{\sqrt{d_k}}\right) V</math>

El factor de escalado <math>\sqrt{d_k}</math> evita que los productos escalares crezcan en magnitud a medida que la dimension de la clave <math>d_k</math> aumenta, lo que empujaria al softmax hacia regiones de gradientes extremadamente pequenos.

== Autoatencion ==

En la '''autoatencion''', las consultas, claves y valores se derivan de la misma secuencia. Cada posicion atiende a todas las demas posiciones (incluida ella misma), lo que permite al modelo capturar dependencias de largo alcance en una unica capa. Para una matriz de entrada <math>X \in \mathbb{R}^{n \times d}</math>:

:<math>Q = X W^Q, \quad K = X W^K, \quad V = X W^V</math>

La autoatencion tiene una complejidad de <math>O(n^2 d)</math>, lo que puede ser costoso para secuencias muy largas. Variantes eficientes como la atencion dispersa y la atencion lineal reducen este coste.

== Atencion multicabezal ==

En lugar de realizar una unica funcion de atencion, la '''atencion multicabezal''' ejecuta <math>h</math> cabezas de atencion en paralelo con proyecciones independientes:

:<math>\mathrm{MultiHead}(Q, K, V) = \mathrm{Concat}(\mathrm{head}_1, \dots, \mathrm{head}_h)\, W^O</math>

donde <math>\mathrm{head}_i = \mathrm{Attention}(Q W_i^Q,\, K W_i^K,\, V W_i^V)</math>. Cada cabeza puede aprender a atender diferentes aspectos de la entrada — por ejemplo, una cabeza podria capturar relaciones sintacticas mientras otra captura relaciones semanticas. Las configuraciones tipicas utilizan 8 o 16 cabezas.

== Codificacion posicional ==

Dado que la autoatencion es invariante a la permutacion (trata la entrada como un conjunto no ordenado), la informacion posicional debe inyectarse explicitamente. El Transformer original utiliza codificaciones sinusoidales:

:<math>\mathrm{PE}(pos, 2i) = \sin\!\left(\frac{pos}{10000^{2i/d}}\right), \quad \mathrm{PE}(pos, 2i+1) = \cos\!\left(\frac{pos}{10000^{2i/d}}\right)</math>

Los embeddings posicionales aprendidos y las codificaciones posicionales relativas (por ejemplo, RoPE, ALiBi) son alternativas comunes que pueden generalizar mejor a longitudes de secuencia no vistas.

== Atencion cruzada ==

La '''atencion cruzada''' se utiliza cuando las consultas provienen de una secuencia y las claves/valores provienen de otra. En los Transformers codificador-decodificador, el decodificador atiende a las salidas del codificador mediante atencion cruzada, lo que permite al modelo condicionar su generacion en el contexto completo de la entrada.

== Consideraciones practicas ==

* '''Enmascaramiento''': En la decodificacion autorregresiva, las posiciones futuras se enmascaran (se establecen en <math>-\infty</math> antes del softmax) para preservar la estructura causal.
* '''Dropout en atencion''': Descartar pesos de atencion aleatoriamente durante el entrenamiento actua como regularizador y reduce el sobreajuste a patrones de alineamiento especificos.
* '''Cache de clave-valor''': Durante la inferencia, los vectores de clave y valor previamente calculados se almacenan en cache para evitar calculo redundante, acelerando significativamente la generacion autorregresiva.

== Vease tambien ==

* [[Transformer]]
* [[Recurrent Neural Networks]]
* [[Sequence-to-sequence models]]
* [[Self-supervised learning]]
* [[Softmax Function]]

== Referencias ==

* Bahdanau, D., Cho, K. and Bengio, Y. (2015). "Neural Machine Translation by Jointly Learning to Align and Translate". ''ICLR''.
* Luong, M.-T., Pham, H. and Manning, C. D. (2015). "Effective Approaches to Attention-based Neural Machine Translation". ''EMNLP''.
* Vaswani, A. et al. (2017). "Attention Is All You Need". ''NeurIPS''.
* Shaw, P., Uszkoreit, J. and Vaswani, A. (2018). "Self-Attention with Relative Position Representations". ''NAACL''.
* Su, J. et al. (2021). "RoFormer: Enhanced Transformer with Rotary Position Embedding". ''arXiv:2104.09864''.

[[Category:Deep Learning]]
[[Category:Advanced]]
[[Category:Neural Networks]]

Word Embeddings

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Word Embeddings}}
{{ArticleInfobox | topic_area = NLP | difficulty = Intermediate | prerequisites = [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Word embeddings''' are dense, low-dimensional vector representations of words in which semantically similar words are mapped to nearby points in the vector space. They are a foundational component of modern natural language processing (NLP), replacing sparse one-hot encodings with representations that capture meaning, analogy, and syntactic relationships.

== The distributional hypothesis ==

Word embeddings are grounded in the '''distributional hypothesis''', famously stated by J. R. Firth (1957): "You shall know a word by the company it keeps." The idea is that words appearing in similar contexts tend to have similar meanings. For example, "dog" and "cat" frequently appear near words like "pet", "fur", and "veterinarian", so they should have similar representations.

Early approaches to exploiting distributional information include co-occurrence matrices, pointwise mutual information (PMI), and latent semantic analysis (LSA). Modern word embedding methods learn dense vectors directly using neural networks.

== One-hot vs dense representations ==

=== One-hot encoding ===

In a vocabulary of <math>V</math> words, a one-hot vector for the <math>i</math>-th word is a <math>V</math>-dimensional vector with a 1 in position <math>i</math> and 0 elsewhere. This representation has two critical shortcomings:

* '''Dimensionality''' — vectors are extremely high-dimensional (typically <math>V > 100{,}000</math>).
* '''No similarity''' — every pair of one-hot vectors is equally distant: <math>\mathbf{e}_i^\top \mathbf{e}_j = 0</math> for <math>i \neq j</math>. "Cat" is as far from "dog" as it is from "democracy."

=== Dense embeddings ===

A word embedding maps each word to a real-valued vector of <math>d</math> dimensions (typically <math>d = 100</math>–<math>300</math>):

:<math>\mathbf{w}_i \in \mathbb{R}^d, \quad d \ll V</math>

Similar words have high cosine similarity:

:<math>\text{sim}(\mathbf{w}_a, \mathbf{w}_b) = \frac{\mathbf{w}_a \cdot \mathbf{w}_b}{\|\mathbf{w}_a\|\;\|\mathbf{w}_b\|}</math>

== Word2Vec ==

'''Word2Vec''' (Mikolov et al., 2013) introduced two efficient architectures for learning word embeddings from large corpora.

=== Continuous Bag of Words (CBOW) ===

CBOW predicts a target word from its surrounding context words. Given a window of context words <math>\{w_{t-c}, \ldots, w_{t-1}, w_{t+1}, \ldots, w_{t+c}\}</math>, the model maximises:

:<math>P(w_t \mid w_{t-c}, \ldots, w_{t+c})</math>

The context word vectors are averaged and passed through a softmax layer. CBOW is faster to train and works well for frequent words.

=== Skip-gram ===

Skip-gram reverses the prediction: given a target word, it predicts the surrounding context words. For each pair <math>(w_t, w_{t+j})</math> where <math>j \in [-c, c] \setminus \{0\}</math>, the model maximises:

:<math>P(w_{t+j} \mid w_t) = \frac{\exp(\mathbf{v}'_{w_{t+j}}{}^\top \mathbf{v}_{w_t})}{\sum_{w=1}^{V}\exp(\mathbf{v}'_w{}^\top \mathbf{v}_{w_t})}</math>

where <math>\mathbf{v}_w</math> and <math>\mathbf{v}'_w</math> are the input and output embedding vectors. Computing the full softmax over the vocabulary is expensive, so two approximations are commonly used:

* '''Negative sampling''' — instead of computing the full softmax, the model contrasts the true context word against <math>k</math> randomly sampled "negative" words.
* '''Hierarchical softmax''' — organises the vocabulary in a binary tree, reducing the softmax cost from <math>O(V)</math> to <math>O(\log V)</math>.

Skip-gram performs well on rare words and captures subtle relationships. The famous analogy "king − man + woman ≈ queen" emerged from Skip-gram embeddings.

== GloVe ==

'''GloVe''' (Global Vectors, Pennington et al., 2014) combines the strengths of global matrix factorisation and local context window methods. It constructs a word co-occurrence matrix <math>X</math> from the corpus, where <math>X_{ij}</math> counts how often word <math>j</math> appears in the context of word <math>i</math>, and then optimises:

:<math>J = \sum_{i,j=1}^{V} f(X_{ij})\bigl(\mathbf{w}_i^\top \tilde{\mathbf{w}}_j + b_i + \tilde{b}_j - \log X_{ij}\bigr)^2</math>

where <math>f</math> is a weighting function that caps the influence of very frequent co-occurrences. GloVe embeddings often match or exceed Word2Vec quality, and the explicit use of global statistics can improve performance on analogy tasks.

== fastText ==

'''fastText''' (Bojanowski et al., 2017) extends Word2Vec by representing each word as a bag of character n-grams. For example, the word "where" with <math>n = 3</math> is represented by the n-grams {"<wh", "whe", "her", "ere", "re>"} plus the whole word "<where>". The embedding for a word is the sum of its n-gram vectors.

This approach has two key advantages:

* '''Handling rare and unseen words''' — even words not in the training vocabulary can receive embeddings by summing their character n-gram vectors.
* '''Morphological awareness''' — words sharing substrings (e.g. "teach", "teacher", "teaching") automatically share embedding components.

== Evaluation of embeddings ==

Word embeddings are evaluated through:

{| class="wikitable"
|-
! Evaluation type !! Examples !! What it measures
|-
| '''Intrinsic: analogy''' || "king : queen :: man : ?" || Linear structure of the space
|-
| '''Intrinsic: similarity''' || Correlation with human similarity judgements (SimLex-999, WS-353) || Semantic quality
|-
| '''Extrinsic: downstream''' || Named entity recognition, sentiment analysis, parsing || Practical utility
|}

Intrinsic evaluations are fast but do not always predict downstream performance. Extrinsic evaluation on the target task is ultimately the most reliable measure.

== Contextual embeddings ==

Traditional word embeddings assign a single vector per word regardless of context — the word "bank" has the same embedding whether it refers to a river bank or a financial institution. '''Contextual embeddings''' address this limitation by producing different representations depending on the surrounding text.

Notable contextual embedding models include:

* '''ELMo''' (Peters et al., 2018) — uses a bidirectional LSTM to generate context-dependent word representations.
* '''BERT''' (Devlin et al., 2019) — uses a Transformer encoder trained with masked language modelling.
* '''GPT''' series (Radford et al., 2018–) — uses a Transformer decoder trained autoregressively.

These models have largely superseded static embeddings for most NLP tasks, though static embeddings remain useful for efficiency, interpretability, and low-resource settings.

== See also ==

* [[Neural Networks]]
* [[Recurrent Neural Networks]]
* [[Loss Functions]]
* [[Backpropagation]]

== References ==

* Firth, J. R. (1957). "A synopsis of linguistic theory, 1930–1955". In ''Studies in Linguistic Analysis''.
* Mikolov, T. et al. (2013). "Efficient Estimation of Word Representations in Vector Space". ''arXiv:1301.3781''.
* Pennington, J., Socher, R. and Manning, C. D. (2014). "GloVe: Global Vectors for Word Representation". ''EMNLP''.
* Bojanowski, P. et al. (2017). "Enriching Word Vectors with Subword Information". ''TACL'', 5, 135–146.
* Peters, M. E. et al. (2018). "Deep contextualized word representations". ''NAACL''.
* Devlin, J. et al. (2019). "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding". ''NAACL''.

[[Category:NLP]]
[[Category:Intermediate]]

Transfer Learning

2026-04-24T07:09:00Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Transfer Learning}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Transfer learning''' is a machine learning technique in which a model trained on one task is reused as the starting point for a model on a different but related task. By leveraging knowledge acquired from large-scale pretraining, transfer learning dramatically reduces the amount of labelled data, compute, and training time required for downstream applications.

== Motivation ==

Training deep neural networks from scratch typically requires large datasets and significant computational resources. In many practical domains — medical imaging, legal text analysis, low-resource languages — labelled data is scarce. Transfer learning addresses this mismatch: a model pretrained on a data-rich source task captures general features (edges, textures, syntactic patterns) that transfer well to a data-scarce target task.

== Key Concepts ==

=== Domain and Task ===

Formally, a '''domain''' <math>\mathcal{D} = \{\mathcal{X}, P(X)\}</math> consists of a feature space <math>\mathcal{X}</math> and a marginal distribution <math>P(X)</math>. A '''task''' <math>\mathcal{T} = \{\mathcal{Y}, f(\cdot)\}</math> consists of a label space <math>\mathcal{Y}</math> and a predictive function <math>f</math>. Transfer learning applies when the source and target differ in domain, task, or both.

=== Domain Adaptation ===

When the source and target share the same task but differ in data distribution (<math>P_s(X) \neq P_t(X)</math>), the problem is called '''domain adaptation'''. Techniques include:

* '''Instance reweighting''' — adjusting sample weights so the source distribution approximates the target.
* '''Feature alignment''' — learning domain-invariant representations (e.g., via adversarial training or maximum mean discrepancy).
* '''Self-training''' — using model predictions on unlabelled target data as pseudo-labels.

== Fine-Tuning vs Feature Extraction ==

{| class="wikitable"
|-
! Strategy !! Description !! When to use
|-
| '''Feature extraction''' || Freeze all pretrained layers; train only a new output head || Very small target dataset; source and target are closely related
|-
| '''Fine-tuning (full)''' || Unfreeze all layers and train end-to-end with a small learning rate || Moderate target dataset; source and target differ meaningfully
|-
| '''Gradual unfreezing''' || Progressively unfreeze layers from top to bottom over training || Balances stability of lower features with adaptation of higher ones
|}

A common heuristic is to use a learning rate 10–100x smaller for pretrained layers than for the new classification head, preventing catastrophic forgetting of learned representations.

== Pretrained Models ==

=== Computer Vision ===

ImageNet-pretrained convolutional networks (ResNet, EfficientNet, ViT) serve as standard backbones. Lower layers learn universal features such as edges and textures, while higher layers learn task-specific patterns. Fine-tuning an ImageNet model on a medical imaging dataset with only a few thousand images routinely outperforms training from scratch.

=== Natural Language Processing ===

Language model pretraining transformed NLP. Key milestones include:

* '''Word2Vec / GloVe''' — static word embeddings pretrained on large corpora.
* '''ELMo''' — contextualised embeddings from bidirectional LSTMs.
* '''BERT''' (Devlin et al., 2019) — bidirectional Transformer pretrained with masked language modelling; fine-tuned for classification, QA, NER, and more.
* '''GPT series''' — autoregressive Transformers demonstrating that scale and pretraining enable few-shot and zero-shot transfer.

== When to Use Transfer Learning ==

Transfer learning is most beneficial when:

# The target dataset is small relative to the model's capacity.
# The source and target domains share structural similarities (e.g., both involve natural images or natural language).
# Computational resources for full pretraining are unavailable.
# Rapid prototyping is needed before committing to large-scale data collection.

It may hurt performance ('''negative transfer''') when the source and target domains are fundamentally dissimilar — for instance, transferring from natural images to spectrograms without appropriate adaptation.

== Practical Tips ==

* '''Data augmentation''' complements transfer learning by artificially expanding the effective size of the target dataset.
* '''Learning rate warmup''' helps stabilise early training when fine-tuning large pretrained models.
* '''Early stopping''' on a validation set prevents overfitting during fine-tuning, especially with small datasets.
* '''Layer-wise learning rate decay''' assigns smaller rates to earlier (more general) layers and larger rates to later (more task-specific) layers.
* '''Intermediate task transfer''' — fine-tuning on a related intermediate task before the final target (e.g., NLI before sentiment analysis) can further improve results.

== Evaluation ==

Transfer learning effectiveness is typically measured by comparing:

:<math>\Delta_{\mathrm{transfer}} = \mathrm{Acc}_{\mathrm{transfer}} - \mathrm{Acc}_{\mathrm{scratch}}</math>

A positive <math>\Delta_{\mathrm{transfer}}</math> indicates successful knowledge transfer. Practitioners also track convergence speed, as transferred models often reach target performance in a fraction of the epochs.

== See also ==

* [[Neural Networks]]
* [[Transformer]]
* [[Self-supervised learning]]
* [[Domain adaptation]]
* [[Fine-tuning]]

== References ==

* Pan, S. J. and Yang, Q. (2010). "A Survey on Transfer Learning". ''IEEE Transactions on Knowledge and Data Engineering''.
* Yosinski, J. et al. (2014). "How transferable are features in deep neural networks?". ''NeurIPS''.
* Devlin, J. et al. (2019). "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding". ''NAACL''.
* Howard, J. and Ruder, S. (2018). "Universal Language Model Fine-tuning for Text Classification". ''ACL''.
* Zhuang, F. et al. (2021). "A Comprehensive Survey on Transfer Learning". ''Proceedings of the IEEE''.

[[Category:Machine Learning]]
[[Category:Intermediate]]

Stochastic Gradient Descent

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{TopicNav|field=Machine Learning|subfield=Optimization algorithms}}
{{Article
|title=Stochastic Gradient Descent
|field=Machine Learning
|topics=Optimization, Neural Networks, Gradient Methods
|related_papers=
|languages=es
}}
{{Summary
|text=Stochastic gradient descent (SGD) is the core optimization algorithm behind modern machine learning. Instead of computing gradients over an entire dataset, it estimates them from small random samples, making training feasible on large-scale data. Nearly all deep learning models are trained using SGD or one of its variants (Adam, RMSProp, etc.).
|key_points=Estimates gradients from random mini-batches instead of the full dataset; Learning rate schedule is critical for convergence; Variants like Adam and AdamW add adaptive per-parameter rates; Converges to global minimum for convex problems under Robbins–Monro conditions
}}
'''Stochastic gradient descent''' (often abbreviated '''{{Term|SGD|SGD}}''') is an iterative optimisation algorithm used to minimise an {{Term|objective function|objective function}} written as a sum of differentiable sub-functions. It is the workhorse behind modern machine-learning training, powering everything from logistic regression to deep neural networks.

== Motivation ==

In classical {{Term|gradient descent}}, the full gradient of the {{Term|loss function}} is computed over the entire training set before each parameter update. When the dataset is large this becomes prohibitively expensive. SGD addresses the problem by estimating the gradient from a single randomly chosen sample (or a small '''{{Term|mini-batch}}''') at each step, trading a noisier estimate for dramatically lower per-iteration cost.

== Algorithm ==

Given a parameterised {{Term|loss function}}

:<math>L(\theta) = \frac{1}{N}\sum_{i=1}^{N} \ell(\theta;\, x_i,\, y_i)</math>

the SGD update rule at step <math>t</math> is:

:<math>\theta_{t+1} = \theta_t - \eta_t \,\nabla_\theta \ell(\theta_t;\, x_{i_t},\, y_{i_t})</math>

where <math>\eta_t</math> is the '''{{Term|learning rate}}''' (step size) and <math>i_t</math> is a randomly selected index.

=== Mini-batch variant ===

In practice a '''{{Term|mini-batch}}''' of <math>B</math> samples is used:

:<math>\theta_{t+1} = \theta_t - \frac{\eta_t}{B}\sum_{j=1}^{B} \nabla_\theta \ell(\theta_t;\, x_{i_j},\, y_{i_j})</math>

Common batch sizes range from 32 to 512. Larger batches reduce gradient variance but increase memory usage.

=== Pseudocode ===

<pre>
initialise parameters θ
for epoch = 1, 2, … do
shuffle training set
for each mini-batch B ⊂ training set do
g ← (1/|B|) Σ ∇ℓ(θ; xᵢ, yᵢ) # estimate gradient
θ ← θ − η · g # update parameters
end for
end for
</pre>

== Learning rate schedules ==

The {{Term|learning rate}} <math>\eta_t</math> strongly influences {{Term|convergence}}. Common strategies include:

* '''Constant''' — simple but may overshoot or stall.
* '''Step decay''' — multiply <math>\eta</math> by a factor (e.g. 0.1) every <math>k</math> epochs.
* '''Exponential decay''' — <math>\eta_t = \eta_0 \, e^{-\lambda t}</math>.
* '''Cosine annealing''' — smoothly reduces the rate following a cosine curve, often with warm restarts.
* '''Linear warm-up''' — ramp up from a small <math>\eta</math> during the first few iterations to stabilise early training.

== Convergence properties ==

For {{Term|convex optimization|convex}} objectives with Lipschitz-continuous gradients, SGD with a decaying {{Term|learning rate}} satisfying

:<math>\sum_{t=1}^{\infty} \eta_t = \infty, \qquad \sum_{t=1}^{\infty} \eta_t^2 < \infty</math>

converges almost surely to the global minimum (Robbins–Monro conditions). For non-convex problems — the typical regime for deep learning — SGD converges to a stationary point, and empirical evidence shows it often finds good local minima.

== Popular variants ==

Several extensions reduce the variance of the gradient estimate or adapt the step size per parameter:

{| class="wikitable"
|-
! Method !! Key idea !! Reference
|-
| '''{{Term|momentum|Momentum}}''' || Accumulates an exponentially decaying moving average of past gradients || Polyak, 1964
|-
| '''Nesterov accelerated gradient''' || Evaluates the gradient at a "look-ahead" position || Nesterov, 1983
|-
| '''Adagrad''' || Per-parameter rates that shrink for frequently updated features || Duchi et al., 2011
|-
| '''RMSProp''' || Fixes Adagrad's diminishing rates using a moving average of squared gradients || Hinton (lecture notes), 2012
|-
| '''{{Term|Adam}}''' || Combines {{Term|momentum}} with RMSProp-style adaptive rates || Kingma & Ba, 2015
|-
| '''AdamW''' || Decouples weight decay from the adaptive gradient step || Loshchilov & Hutter, 2019
|}

== Practical considerations ==

* '''Data shuffling''' — Re-shuffle the dataset each epoch to avoid cyclic patterns.
* '''{{Term|gradient clipping|Gradient clipping}}''' — Cap the gradient norm to prevent exploding updates, especially in recurrent networks.
* '''{{Term|batch normalization|Batch normalisation}}''' — Normalising layer inputs reduces sensitivity to the {{Term|learning rate}}.
* '''Mixed-precision training''' — Using half-precision floats accelerates SGD on modern GPUs with minimal accuracy loss.

== Applications ==

SGD and its variants are used across virtually all areas of machine learning:

* Training deep neural networks (computer vision, NLP, speech recognition)
* Large-scale linear models (logistic regression, SVMs via SGD)
* Reinforcement learning policy optimisation
* Recommendation systems and collaborative filtering
* Online learning settings where data arrives in a stream

== See also ==

* [[Gradient descent]]
* [[Backpropagation]]
* [[Adam (optimiser)]]
* [[Learning rate]]
* [[Convex optimisation]]

== References ==

* Robbins, H. and Monro, S. (1951). "A Stochastic Approximation Method". ''Annals of Mathematical Statistics''.
* Bottou, L. (2010). "Large-Scale Machine Learning with Stochastic Gradient Descent". ''COMPSTAT''.
* Kingma, D. P. and Ba, J. (2015). "Adam: A Method for Stochastic Optimization". ''ICLR''.
* Ruder, S. (2016). "An overview of gradient descent optimization algorithms". ''arXiv:1609.04747''.

{{RelatedContent
|articles=Gradient descent, Backpropagation, Adam (optimiser), Learning rate, Convex optimisation
|papers=
}}

[[Category:Machine learning]]
[[Category:Optimisation algorithms]]
[[Category:Gradient methods]]

Softmax Function

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Softmax Function}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

The '''softmax function''' (also called the '''normalized exponential function''') is a mathematical function that converts a vector of real numbers ('''logits''') into a probability distribution. It is the standard output activation for multi-class classification in neural networks and plays a central role in models ranging from logistic regression to large language models.

== Definition ==

Given a vector of logits <math>\mathbf{z} = (z_1, z_2, \dots, z_K)</math> for <math>K</math> classes, the softmax function produces:

:<math>\sigma(\mathbf{z})_k = \frac{e^{z_k}}{\sum_{j=1}^{K} e^{z_j}}, \qquad k = 1, \dots, K</math>

The output satisfies two properties that make it a valid probability distribution:

# <math>\sigma(\mathbf{z})_k > 0</math> for all <math>k</math> (since the exponential is always positive).
# <math>\sum_{k=1}^{K} \sigma(\mathbf{z})_k = 1</math> (by construction).

== Intuition ==

The softmax function amplifies differences between logits. A logit that is larger than its peers receives a disproportionately large share of the probability mass because the exponential function grows super-linearly. For example:

{| class="wikitable"
|-
! Logits !! Softmax output
|-
| <math>(2.0,\; 1.0,\; 0.1)</math> || <math>(0.659,\; 0.242,\; 0.099)</math>
|-
| <math>(5.0,\; 1.0,\; 0.1)</math> || <math>(0.993,\; 0.005,\; 0.002)</math>
|}

As the gap between the largest logit and the others increases, the output approaches a one-hot vector. This "winner-take-most" behavior makes softmax well-suited for classification where a single class should dominate.

== Temperature Parameter ==

A '''temperature''' parameter <math>T > 0</math> controls the sharpness of the distribution:

:<math>\sigma(\mathbf{z}; T)_k = \frac{e^{z_k / T}}{\sum_{j=1}^{K} e^{z_j / T}}</math>

* <math>T \to 0</math>: The distribution collapses to a one-hot vector selecting the argmax — equivalent to a hard decision.
* <math>T = 1</math>: Standard softmax.
* <math>T \to \infty</math>: The distribution approaches uniform — all classes become equally likely.

Temperature scaling is widely used in knowledge distillation (Hinton et al., 2015), where a "soft" distribution from a teacher model provides richer training signal than hard labels. It is also used to control randomness in text generation from language models.

== Numerical Stability ==

A naive implementation of softmax can overflow when logits are large (e.g., <math>e^{1000}</math> is infinite in floating point). The standard fix subtracts the maximum logit:

:<math>\sigma(\mathbf{z})_k = \frac{e^{z_k - m}}{\sum_{j=1}^{K} e^{z_j - m}}, \qquad m = \max_j z_j</math>

This is mathematically equivalent (the constant cancels) but ensures the largest exponent is <math>e^0 = 1</math>, preventing overflow. All major deep learning frameworks implement this stabilized version automatically.

== Relationship to Sigmoid ==

For the special case of <math>K = 2</math> classes, the softmax function reduces to the '''sigmoid''' (logistic) function. If we define <math>z = z_1 - z_2</math>, then:

:<math>\sigma(\mathbf{z})_1 = \frac{e^{z_1}}{e^{z_1} + e^{z_2}} = \frac{1}{1 + e^{-z}} = \sigma_{\mathrm{sigmoid}}(z)</math>

This is why binary classifiers typically use a single output neuron with a sigmoid activation rather than two neurons with softmax — they are mathematically equivalent.

== Gradient ==

The Jacobian of the softmax function with respect to its input is:

:<math>\frac{\partial \sigma_k}{\partial z_j} = \sigma_k (\delta_{kj} - \sigma_j)</math>

where <math>\delta_{kj}</math> is the Kronecker delta. When combined with [[Cross-Entropy Loss]], the gradient simplifies to <math>\hat{y}_k - y_k</math>, which is computationally efficient and numerically stable.

== Use in Classification ==

In a typical classification pipeline:

# A neural network produces raw logits <math>\mathbf{z}</math> from its final linear layer.
# Softmax converts logits to probabilities: <math>\hat{\mathbf{y}} = \sigma(\mathbf{z})</math>.
# The predicted class is <math>\hat{c} = \arg\max_k \hat{y}_k</math>.
# Training uses [[Cross-Entropy Loss]] applied to the predicted distribution and the true labels.

In practice, the softmax and cross-entropy are computed jointly for numerical stability (the '''log-softmax''' formulation), and the argmax at inference time can be applied directly to the logits without computing softmax at all.

== Beyond Classification ==

Softmax appears in many contexts beyond the output layer:

* '''Attention mechanisms''': Softmax normalizes alignment scores into attention weights in the [[Attention Mechanisms|Transformer]] architecture.
* '''Reinforcement learning''': Softmax over action-value estimates produces a stochastic policy (Boltzmann exploration).
* '''Mixture models''': Softmax parameterizes mixing coefficients in mixture-of-experts architectures.

== See also ==

* [[Cross-Entropy Loss]]
* [[Loss Functions]]
* [[Logistic regression]]
* [[Attention Mechanisms]]
* [[Neural Networks]]

== References ==

* Bishop, C. M. (2006). ''Pattern Recognition and Machine Learning''. Springer, Section 4.3.4.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning''. MIT Press, Section 6.2.2.3.
* Hinton, G., Vinyals, O. and Dean, J. (2015). "Distilling the Knowledge in a Neural Network". ''arXiv:1503.02531''.
* Bridle, J. S. (1990). "Probabilistic Interpretation of Feedforward Classification Network Outputs". ''Neurocomputing''.

[[Category:Machine Learning]]
[[Category:Introductory]]

Recurrent Neural Networks

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Recurrent Neural Networks}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Backpropagation]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Recurrent neural networks''' ('''RNNs''') are a class of [[Neural Networks|neural networks]] designed to process '''sequential data''' — data where the order of elements matters. Unlike feedforward networks, RNNs contain recurrent connections that allow information to persist across time steps, giving them a form of memory.

== Sequence modelling ==

Many real-world problems involve sequences: text is a sequence of words, speech is a sequence of audio frames, stock prices form a time series, and DNA is a sequence of nucleotides. Standard feedforward networks require fixed-size inputs and treat each input independently, making them unsuitable for sequences of variable length where context matters.

RNNs address this by processing inputs one element at a time while maintaining a '''hidden state''' that summarises the information seen so far.

== Vanilla RNN ==

At each time step <math>t</math>, a vanilla RNN computes:

:<math>\mathbf{h}_t = \tanh(\mathbf{W}_{hh}\,\mathbf{h}_{t-1} + \mathbf{W}_{xh}\,\mathbf{x}_t + \mathbf{b}_h)</math>

:<math>\mathbf{y}_t = \mathbf{W}_{hy}\,\mathbf{h}_t + \mathbf{b}_y</math>

where <math>\mathbf{x}_t</math> is the input at time <math>t</math>, <math>\mathbf{h}_t</math> is the hidden state, <math>\mathbf{y}_t</math> is the output, and <math>\mathbf{W}_{hh}, \mathbf{W}_{xh}, \mathbf{W}_{hy}</math> are weight matrices shared across all time steps. The initial hidden state <math>\mathbf{h}_0</math> is typically set to the zero vector.

The key insight is that the same parameters are applied at every time step — '''weight sharing in time''' — allowing the network to generalise across different positions in the sequence.

== Backpropagation through time (BPTT) ==

Training an RNN requires computing gradients of the loss with respect to the shared weights. '''Backpropagation through time''' (BPTT) "unrolls" the RNN across time steps, producing a deep feedforward network with shared weights, and then applies standard [[Backpropagation|backpropagation]].

For a sequence of length <math>T</math>, the gradient of the loss with respect to <math>\mathbf{W}_{hh}</math> involves a product of Jacobians:

:<math>\frac{\partial L}{\partial \mathbf{W}_{hh}} = \sum_{t=1}^{T}\frac{\partial L_t}{\partial \mathbf{W}_{hh}} = \sum_{t=1}^{T}\sum_{k=1}^{t}\frac{\partial L_t}{\partial \mathbf{h}_t}\left(\prod_{j=k+1}^{t}\frac{\partial \mathbf{h}_j}{\partial \mathbf{h}_{j-1}}\right)\frac{\partial \mathbf{h}_k}{\partial \mathbf{W}_{hh}}</math>

The product of Jacobians <math>\prod \partial \mathbf{h}_j / \partial \mathbf{h}_{j-1}</math> is the source of the vanishing and exploding gradient problems.

== The vanishing gradient problem ==

When the spectral radius of the recurrent Jacobian is less than 1, the gradient signal decays exponentially through time — the '''vanishing gradient problem'''. This makes it extremely difficult for vanilla RNNs to learn dependencies that span more than 10–20 time steps.

Conversely, when the spectral radius exceeds 1, gradients can grow exponentially — the '''exploding gradient problem'''. Exploding gradients are typically handled by '''gradient clipping''' (capping the gradient norm at a threshold), but vanishing gradients require architectural solutions.

== Long Short-Term Memory (LSTM) ==

The '''LSTM''' (Hochreiter and Schmidhuber, 1997) introduces a '''cell state''' <math>\mathbf{c}_t</math> that flows through time with minimal interference, and three '''gates''' that control the flow of information:

:<math>\mathbf{f}_t = \sigma(\mathbf{W}_f[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_f)</math> ('''forget gate''')

:<math>\mathbf{i}_t = \sigma(\mathbf{W}_i[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_i)</math> ('''input gate''')

:<math>\tilde{\mathbf{c}}_t = \tanh(\mathbf{W}_c[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_c)</math> ('''candidate cell state''')

:<math>\mathbf{c}_t = \mathbf{f}_t \odot \mathbf{c}_{t-1} + \mathbf{i}_t \odot \tilde{\mathbf{c}}_t</math> ('''cell state update''')

:<math>\mathbf{o}_t = \sigma(\mathbf{W}_o[\mathbf{h}_{t-1}, \mathbf{x}_t] + \mathbf{b}_o)</math> ('''output gate''')

:<math>\mathbf{h}_t = \mathbf{o}_t \odot \tanh(\mathbf{c}_t)</math>

The cell state acts as a conveyor belt: the forget gate decides what old information to discard, the input gate decides what new information to store, and the output gate controls what is exposed to the next layer. Because the cell state is updated through addition (not multiplication), gradients flow more easily across long sequences.

== Gated Recurrent Unit (GRU) ==

The '''GRU''' (Cho et al., 2014) simplifies the LSTM by merging the cell state and hidden state and using only two gates:

:<math>\mathbf{z}_t = \sigma(\mathbf{W}_z[\mathbf{h}_{t-1}, \mathbf{x}_t])</math> ('''update gate''')

:<math>\mathbf{r}_t = \sigma(\mathbf{W}_r[\mathbf{h}_{t-1}, \mathbf{x}_t])</math> ('''reset gate''')

:<math>\tilde{\mathbf{h}}_t = \tanh(\mathbf{W}[\mathbf{r}_t \odot \mathbf{h}_{t-1}, \mathbf{x}_t])</math>

:<math>\mathbf{h}_t = (1 - \mathbf{z}_t) \odot \mathbf{h}_{t-1} + \mathbf{z}_t \odot \tilde{\mathbf{h}}_t</math>

The GRU has fewer parameters than the LSTM and often achieves comparable performance. In practice, the choice between LSTM and GRU is typically made empirically.

== Bidirectional RNNs ==

A '''bidirectional RNN''' processes the sequence in both directions — forward (left to right) and backward (right to left) — and concatenates the hidden states:

:<math>\mathbf{h}_t = [\overrightarrow{\mathbf{h}}_t;\; \overleftarrow{\mathbf{h}}_t]</math>

This allows the model to use both past and future context at every time step, which is beneficial for tasks like named entity recognition and machine translation where the meaning of a word depends on its surrounding context.

== Applications ==

RNNs and their gated variants have been applied to a wide range of sequence tasks:

* '''Language modelling''' — predicting the next word in a sequence.
* '''Machine translation''' — encoder-decoder architectures for sequence-to-sequence translation (Sutskever et al., 2014).
* '''Speech recognition''' — transcribing audio to text (often combined with CTC loss).
* '''Sentiment analysis''' — classifying the sentiment of text.
* '''Time-series forecasting''' — predicting future values of financial or sensor data.
* '''Music generation''' — generating sequences of notes.

Note that for many NLP tasks, '''Transformers''' (Vaswani et al., 2017) have largely superseded RNNs due to their ability to process sequences in parallel and capture long-range dependencies more effectively through self-attention.

== See also ==

* [[Neural Networks]]
* [[Backpropagation]]
* [[Convolutional Neural Networks]]
* [[Word Embeddings]]
* [[Overfitting and Regularization]]

== References ==

* Elman, J. L. (1990). "Finding Structure in Time". ''Cognitive Science'', 14(2), 179–211.
* Hochreiter, S. and Schmidhuber, J. (1997). "Long Short-Term Memory". ''Neural Computation'', 9(8), 1735–1780.
* Cho, K. et al. (2014). "Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation". ''EMNLP''.
* Sutskever, I., Vinyals, O. and Le, Q. V. (2014). "Sequence to Sequence Learning with Neural Networks". ''NeurIPS''.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 10. MIT Press.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Overfitting and Regularization

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Overfitting and Regularization}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Intermediate | prerequisites = [[Loss Functions]], [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Overfitting''' occurs when a machine-learning model learns the training data too well — capturing noise and idiosyncrasies rather than the underlying pattern — and consequently performs poorly on unseen data. '''Regularization''' is the family of techniques used to prevent overfitting and improve a model's ability to generalise.

== The bias–variance tradeoff ==

Prediction error on unseen data can be decomposed into three components:

:<math>\text{Error} = \text{Bias}^2 + \text{Variance} + \text{Irreducible noise}</math>

* '''Bias''' measures how far the model's average prediction is from the true value. High bias indicates the model is too simple to capture the data's structure ('''underfitting''').
* '''Variance''' measures how much predictions fluctuate across different training sets. High variance indicates the model is too sensitive to the particular training data ('''overfitting''').

The goal is to find the sweet spot that minimises total error. A model with too few parameters underfits (high bias); a model with too many parameters overfits (high variance). Regularization techniques tilt the balance by constraining model complexity, accepting slightly higher bias in exchange for substantially lower variance.

== Detecting overfitting ==

The clearest diagnostic is to compare training and validation performance:

* '''Training loss decreasing, validation loss also decreasing''' — the model is still learning; continue training.
* '''Training loss decreasing, validation loss increasing''' — the model is overfitting; apply regularization or stop training.
* '''Training loss high, validation loss high''' — the model is underfitting; increase capacity or train longer.

Plotting these '''learning curves''' over training iterations is essential practice. A large gap between training accuracy and validation accuracy is the hallmark of overfitting.

== L2 regularization (weight decay) ==

L2 regularization adds a penalty proportional to the squared magnitude of the weights:

:<math>J(\theta) = L(\theta) + \frac{\lambda}{2}\|\theta\|_2^2 = L(\theta) + \frac{\lambda}{2}\sum_j \theta_j^2</math>

The gradient of the regularization term is <math>\lambda \theta</math>, so each weight is multiplicatively shrunk toward zero at every update — hence the name '''weight decay'''. The hyperparameter <math>\lambda</math> controls the regularization strength.

L2 regularization is equivalent to placing a Gaussian prior on the weights from a Bayesian perspective. It encourages small, distributed weights and discourages any single weight from becoming excessively large.

== L1 regularization ==

L1 regularization penalises the sum of absolute values:

:<math>J(\theta) = L(\theta) + \lambda \|\theta\|_1 = L(\theta) + \lambda \sum_j |\theta_j|</math>

Unlike L2, the L1 penalty drives many weights exactly to zero, producing '''sparse''' models. This makes L1 regularization useful for feature selection. The LASSO (Least Absolute Shrinkage and Selection Operator) is the classic example of L1-regularized linear regression.

{| class="wikitable"
|-
! Property !! L1 !! L2
|-
| Penalty || <math>\lambda\sum|\theta_j|</math> || <math>\frac{\lambda}{2}\sum\theta_j^2</math>
|-
| Effect on weights || Drives many to exactly zero || Shrinks all toward zero
|-
| Sparsity || Yes || No
|-
| Bayesian interpretation || Laplace prior || Gaussian prior
|-
| Use case || Feature selection, interpretability || General regularization
|}

== Dropout ==

'''Dropout''' (Srivastava et al., 2014) is a regularization technique specific to neural networks. During training, each neuron is randomly "dropped" (set to zero) with probability <math>p</math> at each forward pass. This prevents neurons from co-adapting and forces the network to learn redundant representations.

At test time, all neurons are active but their outputs are scaled by <math>(1 - p)</math> to compensate for the larger number of active units (or equivalently, outputs are scaled by <math>1/(1-p)</math> during training — '''inverted dropout''').

Dropout can be interpreted as an approximate ensemble method: each training step uses a different subnetwork, and the final model approximates the average prediction of exponentially many subnetworks.

== Early stopping ==

'''Early stopping''' monitors the validation loss during training and halts optimisation when the validation loss stops improving. This is one of the simplest and most effective regularization strategies.

In practice, a '''patience''' parameter specifies how many epochs to wait after the last improvement before stopping. The model weights are saved at the point of lowest validation loss and restored at the end.

Early stopping acts as an implicit form of regularization: it limits the effective number of training steps, preventing the model from fully memorising the training data.

== Data augmentation ==

'''Data augmentation''' increases the effective size and diversity of the training set by applying label-preserving transformations. For image data, common augmentations include:

* Random horizontal/vertical flips
* Random crops and resizing
* Colour jittering (brightness, contrast, saturation)
* Rotation and affine transformations
* Mixup (linear interpolation of pairs of images and their labels)
* Cutout (masking random patches)

For text data, augmentations include synonym replacement, back-translation, and paraphrasing. Data augmentation reduces overfitting by exposing the model to more varied inputs without collecting additional data.

== Other regularization techniques ==

* '''Batch normalization''' — normalising layer inputs reduces internal covariate shift and has a mild regularizing effect.
* '''Label smoothing''' — replaces one-hot targets with a mixture, e.g. <math>y_{\text{smooth}} = (1 - \epsilon)\, y + \epsilon / C</math>, preventing overconfidence.
* '''Noise injection''' — adding Gaussian noise to inputs, weights, or gradients during training.

== Practical guidelines ==

# Start with a model large enough to overfit the training data — this confirms the model has sufficient capacity.
# Add regularization incrementally (dropout, weight decay, augmentation) and monitor validation performance.
# Use early stopping as a safety net.
# Prefer more training data over stronger regularization whenever possible — regularization is a substitute for data, not a replacement.
# Tune the regularization strength (<math>\lambda</math>, dropout rate) using a validation set, never the test set.

== See also ==

* [[Loss Functions]]
* [[Neural Networks]]
* [[Gradient Descent]]
* [[Convolutional Neural Networks]]

== References ==

* Srivastava, N. et al. (2014). "Dropout: A Simple Way to Prevent Neural Networks from Overfitting". ''JMLR'', 15, 1929–1958.
* Tibshirani, R. (1996). "Regression Shrinkage and Selection via the Lasso". ''JRSS Series B'', 58(1), 267–288.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 7. MIT Press.
* Zhang, C. et al. (2017). "Understanding deep learning requires rethinking generalization". ''ICLR''.
* Shorten, C. and Khoshgoftaar, T. M. (2019). "A survey on Image Data Augmentation for Deep Learning". ''Journal of Big Data''.

[[Category:Machine Learning]]
[[Category:Intermediate]]

Neural Networks

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Neural Networks}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Neural networks''' (also called '''artificial neural networks''', or ANNs) are computational models inspired by the structure of biological nervous systems. They consist of interconnected layers of simple processing units called '''neurons''' (or nodes) and form the basis of modern deep learning.

== Biological inspiration ==

The biological neuron receives electrical signals through its '''dendrites''', integrates them in the '''cell body''', and, if the combined signal exceeds a threshold, fires an output signal along its '''axon''' to downstream neurons. Artificial neural networks abstract this process: each artificial neuron computes a weighted sum of its inputs, adds a bias term, and passes the result through a nonlinear '''activation function'''.

While the analogy to biology motivated early research, modern neural networks are best understood as flexible parameterised function approximators rather than faithful brain simulations.

== The perceptron ==

The '''perceptron''', introduced by Frank Rosenblatt in 1958, is the simplest neural network. It computes:

:<math>y = \sigma\!\left(\sum_{i=1}^{n} w_i x_i + b\right) = \sigma(\mathbf{w}^\top \mathbf{x} + b)</math>

where <math>\mathbf{x}</math> is the input vector, <math>\mathbf{w}</math> are learnable weights, <math>b</math> is a bias, and <math>\sigma</math> is a step function that outputs 1 if the argument is positive and 0 otherwise. The perceptron can learn any linearly separable function but famously cannot represent the XOR function — a limitation that stalled neural-network research for over a decade.

== Feedforward networks ==

A '''feedforward neural network''' (also called a '''multilayer perceptron''', or MLP) stacks multiple layers of neurons. Information flows in one direction — from the '''input layer''' through one or more '''hidden layers''' to the '''output layer'''.

For a network with one hidden layer, the computation is:

:<math>\mathbf{h} = g(\mathbf{W}_1 \mathbf{x} + \mathbf{b}_1)</math>

:<math>\mathbf{y} = f(\mathbf{W}_2 \mathbf{h} + \mathbf{b}_2)</math>

where <math>g</math> and <math>f</math> are activation functions, <math>\mathbf{W}_1, \mathbf{W}_2</math> are weight matrices, and <math>\mathbf{b}_1, \mathbf{b}_2</math> are bias vectors. The hidden layer enables the network to learn nonlinear relationships that a single perceptron cannot capture.

Networks with many hidden layers are called '''deep''' neural networks, and training them is the subject of '''deep learning'''.

== Activation functions ==

The activation function introduces nonlinearity; without it, a multi-layer network would collapse to a single linear transformation. Common choices include:

{| class="wikitable"
|-
! Function !! Formula !! Range !! Notes
|-
| '''Sigmoid''' || <math>\sigma(z) = \frac{1}{1+e^{-z}}</math> || (0, 1) || Historically popular; suffers from vanishing gradients
|-
| '''Tanh''' || <math>\tanh(z) = \frac{e^z - e^{-z}}{e^z + e^{-z}}</math> || (−1, 1) || Zero-centred; still saturates for large inputs
|-
| '''ReLU''' || <math>\max(0, z)</math> || [0, ∞) || Default choice in modern networks; can cause "dead neurons"
|-
| '''Leaky ReLU''' || <math>\max(\alpha z, z)</math> for small <math>\alpha > 0</math> || (−∞, ∞) || Addresses the dead-neuron problem
|-
| '''Softmax''' || <math>\frac{e^{z_i}}{\sum_j e^{z_j}}</math> || (0, 1) || Used in output layer for multi-class classification
|}

== Universal approximation theorem ==

The '''universal approximation theorem''' (Cybenko 1989, Hornik 1991) states that a feedforward network with a single hidden layer containing a finite number of neurons can approximate any continuous function on a compact subset of <math>\mathbb{R}^n</math> to arbitrary accuracy, provided the activation function satisfies mild conditions (e.g. is non-constant, bounded, and continuous).

This theorem guarantees the ''existence'' of a good approximation but says nothing about how to ''find'' it — in practice, training deep networks with many layers is far more effective than using a single wide layer.

== Training overview ==

Training a neural network involves:

# '''Defining a loss function''' — a measure of how far the network's predictions are from the true targets (see [[Loss Functions]]).
# '''Forward pass''' — computing the output of the network for a given input by propagating values layer by layer.
# '''Backward pass (backpropagation)''' — computing the gradient of the loss with respect to every weight by applying the chain rule in reverse through the network (see [[Backpropagation]]).
# '''Parameter update''' — adjusting the weights using an optimisation algorithm such as [[Gradient Descent]] or one of its variants.
# '''Iteration''' — repeating steps 2–4 over many passes (epochs) through the training data.

Successful training also requires attention to '''initialisation''' (e.g. Xavier or He schemes), '''regularisation''' (to prevent [[Overfitting and Regularization|overfitting]]), and '''hyperparameter tuning''' (learning rate, batch size, network architecture).

== Common architectures ==

Beyond the basic feedforward network, several specialised architectures have been developed:

* '''[[Convolutional Neural Networks]]''' (CNNs) — designed for grid-structured data such as images, using local connectivity and weight sharing.
* '''[[Recurrent Neural Networks]]''' (RNNs) — designed for sequential data, with connections that form cycles to maintain hidden state.
* '''Transformers''' — attention-based architectures that have become dominant in natural language processing and increasingly in vision.
* '''Autoencoders''' — networks trained to reconstruct their input, used for dimensionality reduction and generative modelling.
* '''Generative adversarial networks''' (GANs) — pairs of networks (generator and discriminator) trained in competition to generate realistic data.

== Applications ==

Neural networks are applied across a vast range of domains:

* Computer vision (image classification, object detection, segmentation)
* Natural language processing (translation, summarisation, question answering)
* Speech recognition and synthesis
* Game playing (AlphaGo, Atari agents)
* Scientific discovery (protein folding, drug design, weather prediction)
* Autonomous vehicles and robotics

== See also ==

* [[Gradient Descent]]
* [[Backpropagation]]
* [[Loss Functions]]
* [[Convolutional Neural Networks]]
* [[Recurrent Neural Networks]]
* [[Overfitting and Regularization]]

== References ==

* Rosenblatt, F. (1958). "The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain". ''Psychological Review''.
* Cybenko, G. (1989). "Approximation by Superpositions of a Sigmoidal Function". ''Mathematics of Control, Signals, and Systems''.
* Hornik, K. (1991). "Approximation Capabilities of Multilayer Feedforward Networks". ''Neural Networks''.
* LeCun, Y., Bengio, Y. and Hinton, G. (2015). "Deep learning". ''Nature'', 521, 436–444.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning''. MIT Press.

[[Category:Deep Learning]]
[[Category:Introductory]]
[[Category:Neural Networks]]

Loss Functions

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Loss Functions}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Loss functions''' (also called '''cost functions''' or '''objective functions''') quantify how far a model's predictions are from the desired output. Minimising the loss function is the central goal of the training process in machine learning: the optimisation algorithm adjusts the model's parameters to drive the loss as low as possible.

== Purpose ==

A loss function maps the model's prediction <math>\hat{y}</math> and the true target <math>y</math> to a non-negative real number. Formally, for a single example:

:<math>\ell: \mathcal{Y} \times \mathcal{Y} \to \mathbb{R}_{\geq 0}</math>

Over a dataset of <math>N</math> examples, the total loss is typically the average:

:<math>L(\theta) = \frac{1}{N}\sum_{i=1}^{N}\ell\bigl(y_i,\, \hat{y}_i(\theta)\bigr)</math>

The choice of loss function encodes the problem's structure — what kind of errors matter and how severely they should be penalised. A poorly chosen loss can lead to a model that optimises the wrong objective.

== Mean squared error ==

'''Mean squared error''' (MSE) is the default loss for regression tasks:

:<math>L_{\text{MSE}} = \frac{1}{N}\sum_{i=1}^{N}(y_i - \hat{y}_i)^2</math>

MSE penalises large errors quadratically, making it sensitive to outliers. Its gradient is straightforward:

:<math>\frac{\partial}{\partial \hat{y}_i} (y_i - \hat{y}_i)^2 = -2(y_i - \hat{y}_i)</math>

A closely related variant is '''mean absolute error''' (MAE), <math>\frac{1}{N}\sum|y_i - \hat{y}_i|</math>, which is more robust to outliers but has a non-smooth gradient at zero. The '''Huber loss''' combines both: it behaves like MSE for small errors and like MAE for large ones.

== Cross-entropy loss ==

'''Cross-entropy loss''' is the standard choice for classification tasks. It measures the dissimilarity between the predicted probability distribution and the true label distribution.

=== Binary cross-entropy ===

For binary classification with predicted probability <math>p</math> and true label <math>y \in \{0, 1\}</math>:

:<math>L_{\text{BCE}} = -\frac{1}{N}\sum_{i=1}^{N}\bigl[y_i \log p_i + (1 - y_i)\log(1 - p_i)\bigr]</math>

This loss is minimised when the predicted probability matches the true label perfectly (<math>p = 1</math> when <math>y = 1</math> and <math>p = 0</math> when <math>y = 0</math>).

=== Categorical cross-entropy ===

For multi-class classification with <math>C</math> classes and predicted probability vector <math>\hat{\mathbf{y}}</math>:

:<math>L_{\text{CE}} = -\frac{1}{N}\sum_{i=1}^{N}\sum_{c=1}^{C} y_{i,c} \log \hat{y}_{i,c}</math>

When the true labels are one-hot encoded, only the term corresponding to the correct class survives.

== Hinge loss ==

'''Hinge loss''' is associated with support vector machines (SVMs) and maximum-margin classifiers. For a binary classification problem with labels <math>y \in \{-1, +1\}</math> and raw model output <math>s</math>:

:<math>L_{\text{hinge}} = \frac{1}{N}\sum_{i=1}^{N}\max(0,\; 1 - y_i \, s_i)</math>

The hinge loss is zero when the prediction has the correct sign with margin at least 1, and increases linearly otherwise. Because it is not differentiable at the hinge point, subgradient methods are used for optimisation.

== Other common loss functions ==

{| class="wikitable"
|-
! Loss !! Formula !! Typical use
|-
| '''Huber''' || <math>\begin{cases}\tfrac{1}{2}(y-\hat{y})^2 & |y-\hat{y}|\leq\delta \\ \delta(|y-\hat{y}|-\tfrac{\delta}{2}) & \text{otherwise}\end{cases}</math> || Robust regression
|-
| '''KL divergence''' || <math>\sum_c p_c \log\frac{p_c}{q_c}</math> || Distribution matching, VAEs
|-
| '''Focal loss''' || <math>-\alpha(1-p_t)^\gamma \log p_t</math> || Imbalanced classification
|-
| '''CTC loss''' || Dynamic programming over alignments || Speech recognition, OCR
|-
| '''Triplet loss''' || <math>\max(0,\; d(a,p) - d(a,n) + m)</math> || Metric learning, face verification
|}

== Choosing the right loss ==

The appropriate loss function depends on the task:

* '''Regression''' — MSE is the default; switch to MAE or Huber if outliers are a concern.
* '''Binary classification''' — binary cross-entropy with sigmoid output.
* '''Multi-class classification''' — categorical cross-entropy with softmax output.
* '''Multi-label classification''' — binary cross-entropy applied independently per label.
* '''Ranking or retrieval''' — contrastive loss, triplet loss, or listwise ranking losses.

An important consideration is whether the loss is '''calibrated''' — i.e., whether minimising it yields well-calibrated predicted probabilities. Cross-entropy is a proper scoring rule and produces calibrated probabilities, while hinge loss does not.

== Regularisation terms ==

In practice, the total objective often includes a '''regularisation term''' that penalises model complexity:

:<math>J(\theta) = L(\theta) + \lambda \, R(\theta)</math>

where <math>\lambda</math> controls the strength of regularisation. Common choices include L2 regularisation (<math>R = \|\theta\|_2^2</math>) and L1 regularisation (<math>R = \|\theta\|_1</math>). See [[Overfitting and Regularization]] for more detail.

== See also ==

* [[Gradient Descent]]
* [[Neural Networks]]
* [[Backpropagation]]
* [[Overfitting and Regularization]]
* [[Stochastic Gradient Descent]]

== References ==

* Bishop, C. M. (2006). ''Pattern Recognition and Machine Learning'', Chapter 1. Springer.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapters 6 and 8. MIT Press.
* Lin, T.-Y. et al. (2017). "Focal Loss for Dense Object Detection". ''ICCV''.
* Murphy, K. P. (2022). ''Probabilistic Machine Learning: An Introduction''. MIT Press.

[[Category:Machine Learning]]
[[Category:Introductory]]

Linear Regression

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Linear Regression}}
{{ArticleInfobox | topic_area = Statistics | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Linear regression''' is a fundamental statistical method that models the relationship between a dependent variable and one or more independent variables by fitting a linear equation to observed data. It is one of the oldest and most widely used techniques in statistics and machine learning, serving as both a practical predictive tool and a building block for understanding more complex models.

== Problem Setup ==

Given a dataset of <math>N</math> observations <math>\{(\mathbf{x}_i, y_i)\}_{i=1}^{N}</math>, where <math>\mathbf{x}_i \in \mathbb{R}^d</math> is a feature vector and <math>y_i \in \mathbb{R}</math> is the target, linear regression assumes the relationship:

:<math>y_i = \mathbf{w}^{\!\top} \mathbf{x}_i + b + \epsilon_i</math>

where <math>\mathbf{w} \in \mathbb{R}^d</math> is the weight vector, <math>b</math> is the bias (intercept), and <math>\epsilon_i</math> is the error term. By absorbing the bias into the weight vector (appending a 1 to each <math>\mathbf{x}_i</math>), this simplifies to <math>y_i = \mathbf{w}^{\!\top} \mathbf{x}_i + \epsilon_i</math>.

== Ordinary Least Squares ==

The '''ordinary least squares''' (OLS) method finds the weights that minimize the sum of squared residuals:

:<math>\mathcal{L}(\mathbf{w}) = \sum_{i=1}^{N} (y_i - \mathbf{w}^{\!\top} \mathbf{x}_i)^2 = \|\mathbf{y} - X\mathbf{w}\|^2</math>

where <math>X \in \mathbb{R}^{N \times d}</math> is the design matrix and <math>\mathbf{y} \in \mathbb{R}^N</math> is the target vector.

=== Closed-Form Solution ===

Setting the gradient to zero yields the '''normal equations''':

:<math>\nabla_{\mathbf{w}} \mathcal{L} = -2 X^{\!\top}(\mathbf{y} - X\mathbf{w}) = 0</math>

:<math>\hat{\mathbf{w}} = (X^{\!\top} X)^{-1} X^{\!\top} \mathbf{y}</math>

This solution exists and is unique when <math>X^{\!\top} X</math> is invertible (i.e., the features are linearly independent). The computational cost is <math>O(Nd^2 + d^3)</math>, which is efficient for moderate <math>d</math> but becomes expensive for high-dimensional problems.

=== Gradient Descent Approach ===

When the closed-form solution is impractical (large <math>d</math> or <math>N</math>), iterative optimization via [[Stochastic Gradient Descent|gradient descent]] is used. The gradient is:

:<math>\nabla_{\mathbf{w}} \mathcal{L} = -\frac{2}{N} X^{\!\top}(\mathbf{y} - X\mathbf{w})</math>

The update rule is <math>\mathbf{w} \leftarrow \mathbf{w} - \eta \nabla_{\mathbf{w}} \mathcal{L}</math>, where <math>\eta</math> is the learning rate. Stochastic and mini-batch variants scale to millions of data points.

== Assumptions of OLS ==

The classical OLS estimator is '''BLUE''' (Best Linear Unbiased Estimator) under the Gauss-Markov conditions:

# '''Linearity''': The true relationship between features and target is linear.
# '''Independence''': Observations are independent of each other.
# '''Homoscedasticity''': The error variance <math>\mathrm{Var}(\epsilon_i) = \sigma^2</math> is constant across observations.
# '''No perfect multicollinearity''': No feature is an exact linear combination of others.
# '''Exogeneity''': <math>E[\epsilon_i \mid \mathbf{x}_i] = 0</math> — errors are uncorrelated with features.

Violations of these assumptions do not necessarily make linear regression useless, but they may invalidate confidence intervals and hypothesis tests derived from the model.

== Evaluation Metrics ==

{| class="wikitable"
|-
! Metric !! Formula !! Interpretation
|-
| '''MSE''' || <math>\frac{1}{N}\sum(y_i - \hat{y}_i)^2</math> || Average squared error; penalises large errors
|-
| '''RMSE''' || <math>\sqrt{\mathrm{MSE}}</math> || In the same units as the target
|-
| '''MAE''' || <math>\frac{1}{N}\sum|y_i - \hat{y}_i|</math> || Average absolute error; robust to outliers
|-
| '''R-squared''' || <math>1 - \frac{\sum(y_i - \hat{y}_i)^2}{\sum(y_i - \bar{y})^2}</math> || Proportion of variance explained (0 to 1)
|}

An <math>R^2</math> of 1 indicates perfect prediction, while <math>R^2 = 0</math> means the model does no better than predicting the mean. The '''adjusted R-squared''' penalises for the number of features, preventing artificial inflation from adding irrelevant predictors.

== Multiple Regression ==

When <math>d > 1</math>, the model is called '''multiple linear regression'''. Each coefficient <math>w_j</math> represents the expected change in <math>y</math> per unit change in <math>x_j</math>, holding all other features constant. Interpreting coefficients requires caution when features are correlated (multicollinearity), as individual coefficients may become unstable even though the overall model fits well.

== Regularized Variants ==

When the number of features is large relative to the number of observations, or when features are correlated, OLS can overfit. Regularization adds a penalty to the loss function:

=== Ridge Regression (L2) ===

:<math>\mathcal{L}_{\mathrm{ridge}} = \|\mathbf{y} - X\mathbf{w}\|^2 + \lambda \|\mathbf{w}\|_2^2</math>

The closed-form solution becomes <math>\hat{\mathbf{w}} = (X^{\!\top} X + \lambda I)^{-1} X^{\!\top} \mathbf{y}</math>. Ridge shrinks coefficients toward zero but never sets them exactly to zero.

=== Lasso Regression (L1) ===

:<math>\mathcal{L}_{\mathrm{lasso}} = \|\mathbf{y} - X\mathbf{w}\|^2 + \lambda \|\mathbf{w}\|_1</math>

Lasso can drive coefficients to exactly zero, performing automatic '''feature selection'''. It has no closed-form solution and is typically solved via coordinate descent.

=== Elastic Net ===

Elastic Net combines both penalties: <math>\lambda_1 \|\mathbf{w}\|_1 + \lambda_2 \|\mathbf{w}\|_2^2</math>, balancing sparsity and stability.

== Practical Considerations ==

* '''Feature scaling''': Standardizing features (zero mean, unit variance) improves gradient descent convergence and makes regularization fair across features.
* '''Polynomial features''': Adding polynomial terms (e.g., <math>x^2, x_1 x_2</math>) allows linear regression to capture nonlinear relationships.
* '''Outliers''': OLS is sensitive to outliers because of the squared loss. Robust alternatives include Huber regression and RANSAC.
* '''Diagnostic plots''': Residual plots help detect violations of assumptions (non-linearity, heteroscedasticity, non-normality).

== See also ==

* [[Stochastic Gradient Descent]]
* [[Logistic regression]]
* [[Loss Functions]]
* [[Overfitting and Regularization]]
* [[Neural Networks]]

== References ==

* Hastie, T., Tibshirani, R. and Friedman, J. (2009). ''The Elements of Statistical Learning''. Springer, Chapter 3.
* Montgomery, D. C., Peck, E. A. and Vining, G. G. (2012). ''Introduction to Linear Regression Analysis''. Wiley.
* Hoerl, A. E. and Kennard, R. W. (1970). "Ridge Regression: Biased Estimation for Nonorthogonal Problems". ''Technometrics''.
* Tibshirani, R. (1996). "Regression Shrinkage and Selection via the Lasso". ''Journal of the Royal Statistical Society, Series B''.

[[Category:Statistics]]
[[Category:Introductory]]

Gradient Descent

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Gradient Descent}}
{{ArticleInfobox | topic_area = Optimization | difficulty = Introductory | prerequisites = }}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Gradient descent''' is a first-order iterative optimisation algorithm for finding a local minimum of a differentiable function. It is the foundation of nearly all modern machine-learning training procedures, from simple linear regression to billion-parameter deep neural networks.

== Intuition ==

Imagine standing on a mountainside in thick fog. You cannot see the valley floor, but you can feel the slope beneath your feet. The most natural strategy is to take a step in the steepest downhill direction, then reassess. Gradient descent formalises precisely this idea: at each step, the algorithm computes the direction of steepest increase of the function (the '''gradient''') and moves in the opposite direction.

The size of each step is controlled by a scalar called the '''learning rate''' (often denoted <math>\eta</math>). A large learning rate covers ground quickly but risks overshooting the minimum; a small learning rate converges more reliably but may take prohibitively many steps.

== Mathematical formulation ==

Given a differentiable objective function <math>f:\mathbb{R}^n \to \mathbb{R}</math>, gradient descent generates a sequence of iterates by the '''update rule''':

:<math>\theta_{t+1} = \theta_t - \eta \, \nabla f(\theta_t)</math>

where <math>\nabla f(\theta_t)</math> is the gradient vector evaluated at the current point <math>\theta_t</math> and <math>\eta > 0</math> is the learning rate.

In the one-dimensional case this simplifies to:

:<math>\theta_{t+1} = \theta_t - \eta \, f'(\theta_t)</math>

The gradient <math>\nabla f</math> points in the direction of steepest ascent, so subtracting it moves the iterate downhill.

== Batch, stochastic, and mini-batch variants ==

When the objective has the form of an average over data points,

:<math>f(\theta) = \frac{1}{N}\sum_{i=1}^{N} \ell(\theta;\, x_i, y_i)</math>

three common strategies differ in how much data is used to estimate the gradient:

{| class="wikitable"
|-
! Variant !! Gradient computed over !! Per-step cost !! Gradient noise
|-
| '''Batch (full) gradient descent''' || All <math>N</math> samples || High || None
|-
| '''Stochastic gradient descent (SGD)''' || 1 random sample || Low || High
|-
| '''Mini-batch gradient descent''' || <math>B</math> random samples (<math>1 < B < N</math>) || Medium || Medium
|}

Full batch gradient descent computes the exact gradient and therefore follows a smooth trajectory toward the minimum. [[Stochastic Gradient Descent|Stochastic gradient descent]] uses a single sample to estimate the gradient, drastically reducing computation per step at the cost of a noisier trajectory. Mini-batch gradient descent strikes a balance and is the most common choice in practice, with typical batch sizes between 32 and 512.

== Convergence ==

=== Convex functions ===

For a convex function with Lipschitz-continuous gradients (constant <math>L</math>), gradient descent with a fixed learning rate <math>\eta \leq 1/L</math> converges at a rate of <math>O(1/t)</math>. If the function is additionally '''strongly convex''' with parameter <math>\mu > 0</math>, convergence accelerates to a linear (exponential) rate:

:<math>f(\theta_t) - f(\theta^*) \leq \left(1 - \frac{\mu}{L}\right)^t \bigl(f(\theta_0) - f(\theta^*)\bigr)</math>

The ratio <math>\kappa = L / \mu</math> is called the '''condition number''' and governs how quickly the algorithm converges. Ill-conditioned problems (large <math>\kappa</math>) converge slowly.

=== Non-convex functions ===

Most deep-learning objectives are non-convex. In this setting gradient descent is only guaranteed to converge to a stationary point (where <math>\nabla f = 0</math>), which could be a local minimum, saddle point, or even a local maximum. In practice, saddle points are more problematic than local minima in high-dimensional spaces.

== Learning rate selection ==

Choosing the learning rate is one of the most important practical decisions:

* '''Too large''' — the iterates oscillate or diverge.
* '''Too small''' — convergence is unacceptably slow.
* '''Learning rate schedules''' — many practitioners start with a larger rate and reduce it over time (step decay, exponential decay, cosine annealing).
* '''Line search''' — classical numerical methods choose <math>\eta</math> at each step to satisfy conditions such as the Wolfe or Armijo conditions, though this is rare in deep learning.

A common heuristic is to try several values on a logarithmic scale (e.g. <math>10^{-1}, 10^{-2}, 10^{-3}</math>) and pick the one that reduces the loss fastest without instability.

== Extensions and improvements ==

Several important modifications address limitations of vanilla gradient descent:

* '''Momentum''' — accumulates a velocity vector from past gradients, helping to accelerate convergence in ravine-like landscapes.
* '''Nesterov accelerated gradient''' — a momentum variant that evaluates the gradient at a look-ahead position, yielding better theoretical convergence rates.
* '''Adaptive methods''' (Adagrad, RMSProp, Adam) — maintain per-parameter learning rates that adapt based on the history of gradients.
* '''Second-order methods''' — algorithms like Newton's method and L-BFGS use curvature information (the Hessian or its approximation) for faster convergence, but are often too expensive for large-scale problems.

== Practical tips ==

* '''Feature scaling''' — normalising input features so they have similar ranges dramatically improves convergence, because the loss surface becomes more isotropic.
* '''Gradient clipping''' — capping the norm of the gradient prevents excessively large updates.
* '''Random initialisation''' — starting from a reasonable random initialisation (e.g. Xavier or He initialisation for neural networks) avoids symmetry-breaking issues.
* '''Monitoring the loss curve''' — plotting the training loss over iterations is the simplest diagnostic: a smoothly decreasing curve indicates healthy training; oscillations suggest the learning rate is too high.

== Applications ==

Gradient descent and its variants are used throughout science and engineering:

* Training machine-learning models (linear models, neural networks, support vector machines)
* Signal processing and control systems
* Inverse problems in physics and imaging
* Operations research and logistics optimisation
* Economics and game-theoretic equilibrium computation

== See also ==

* [[Stochastic Gradient Descent]]
* [[Backpropagation]]
* [[Loss Functions]]
* [[Neural Networks]]
* [[Overfitting and Regularization]]

== References ==

* Cauchy, A. (1847). "Méthode générale pour la résolution des systèmes d'équations simultanées". ''Comptes Rendus de l'Académie des Sciences''.
* Boyd, S. and Vandenberghe, L. (2004). ''Convex Optimization''. Cambridge University Press.
* Ruder, S. (2016). "An overview of gradient descent optimization algorithms". ''arXiv:1609.04747''.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 8. MIT Press.

[[Category:Optimization]]
[[Category:Introductory]]

Dropout

2026-04-24T07:08:59Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Dropout}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Overfitting and Regularization]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Dropout''' is a regularization technique for neural networks that randomly sets a fraction of neuron activations to zero during each training step. Introduced by Srivastava et al. (2014), dropout is one of the most widely used methods for preventing overfitting in deep learning.

== Motivation: Co-Adaptation ==

In large neural networks, neurons can develop complex '''co-adaptation''' patterns — groups of neurons that only function correctly in the presence of specific other neurons. This tight coupling makes the network brittle and prone to overfitting, since the learned features depend on the particular idiosyncrasies of the training data rather than capturing robust, general patterns.

Dropout breaks these co-adaptations by forcing each neuron to learn features that are useful in conjunction with many different random subsets of the other neurons.

== The Dropout Algorithm ==

=== During Training ===

At each training step, every neuron in a dropout layer is independently retained with probability <math>p</math> (the '''keep probability''') or set to zero with probability <math>1 - p</math>. Formally, for a layer with activation vector <math>\mathbf{h}</math>:

:<math>r_j \sim \mathrm{Bernoulli}(p)</math>

:<math>\tilde{h}_j = r_j \cdot h_j</math>

where <math>r_j</math> is a binary mask drawn independently for each neuron <math>j</math>. A typical keep probability is <math>p = 0.5</math> for hidden layers and <math>p = 0.8</math> or higher for the input layer.

Each training step effectively trains a different "thinned" sub-network sampled from the full architecture. With <math>n</math> neurons, there are <math>2^n</math> possible sub-networks, creating an implicit ensemble.

=== During Inference: Inverted Dropout ===

At inference time, all neurons are active, so the expected output of each neuron is scaled by a factor of <math>p</math> relative to training. Two approaches address this:

* '''Standard dropout''': Multiply all weights by <math>p</math> at test time.
* '''Inverted dropout''' (more common): During training, divide the retained activations by <math>p</math>:

:<math>\tilde{h}_j = \frac{r_j \cdot h_j}{p}</math>

Inverted dropout ensures that the expected value of <math>\tilde{h}_j</math> equals <math>h_j</math> during training, so no adjustment is needed at inference. This is the default implementation in frameworks such as PyTorch and TensorFlow.

== Theoretical Interpretation ==

=== Ensemble Perspective ===

Dropout can be viewed as training an exponentially large ensemble of sub-networks with extensive weight sharing. At test time, using the full network with scaled weights approximates the geometric mean of the predictions of all <math>2^n</math> sub-networks. This ensemble averaging reduces variance and improves generalization.

=== Bayesian Interpretation ===

Gal and Ghahramani (2016) showed that a neural network with dropout applied before every weight layer is mathematically equivalent to an approximation of a deep Gaussian process. Performing dropout at test time ('''Monte Carlo dropout''') yields a distribution over predictions, providing a practical estimate of model uncertainty.

== Dropout Variants ==

{| class="wikitable"
|-
! Variant !! Description !! Typical application
|-
| '''Standard dropout''' || Drops individual neurons || Fully connected layers
|-
| '''Spatial dropout''' || Drops entire feature maps (channels) || Convolutional networks
|-
| '''DropConnect''' || Drops individual weights instead of neurons || Dense layers
|-
| '''Variational dropout''' || Learns the dropout rate per neuron/weight || Bayesian deep learning
|-
| '''DropBlock''' || Drops contiguous regions of feature maps || Convolutional networks
|-
| '''Alpha dropout''' || Maintains self-normalizing property (for SELU activations) || Self-normalizing networks
|}

'''Spatial dropout''' (Tompson et al., 2015) is particularly important for convolutional networks. Standard dropout on convolutional feature maps is ineffective because adjacent activations are highly correlated; dropping individual pixels still leaves redundant spatial information. Spatial dropout instead drops entire channels, forcing the network to use diverse feature representations.

== Practical Guidelines ==

* '''Placement''': Apply dropout after the activation function in fully connected layers. In Transformers, dropout is applied to attention weights and after feed-forward sub-layers.
* '''Rate selection''': Start with <math>p = 0.5</math> for hidden layers. Use higher keep rates (lower dropout) for layers with fewer parameters. Increase dropout for larger models or smaller datasets.
* '''Interaction with BatchNorm''': Using dropout and [[Batch Normalization]] together requires care, as dropout introduces variance that can destabilize batch statistics. A common practice is to apply dropout only after the final batch-normalized layer.
* '''Scheduled dropout''': Some training regimes start with no dropout and gradually increase the rate, or vice versa, over the course of training.

== Effect on Training ==

Dropout typically increases training loss and slows convergence, since the effective model capacity is reduced at each step. However, it decreases the gap between training and validation performance, leading to better generalization. If training loss is already high (underfitting), dropout should be reduced or removed.

== See also ==

* [[Overfitting and Regularization]]
* [[Batch Normalization]]
* [[Neural Networks]]
* [[Backpropagation]]
* [[Bayesian deep learning]]

== References ==

* Srivastava, N. et al. (2014). "Dropout: A Simple Way to Prevent Neural Networks from Overfitting". ''Journal of Machine Learning Research'' 15(56):1929–1958.
* Gal, Y. and Ghahramani, Z. (2016). "Dropout as a Bayesian Approximation: Representing Model Uncertainty in Deep Learning". ''ICML''.
* Tompson, J. et al. (2015). "Efficient Object Localization Using Convolutional Networks". ''CVPR''.
* Wan, L. et al. (2013). "Regularization of Neural Networks using DropConnect". ''ICML''.
* Ghiasi, G., Lin, T.-Y. and Le, Q. V. (2018). "DropBlock: A regularization method for convolutional networks". ''NeurIPS''.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Cross-Entropy Loss

2026-04-24T07:08:58Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Cross-Entropy Loss}}
{{ArticleInfobox | topic_area = Machine Learning | difficulty = Intermediate | prerequisites = [[Loss Functions]], [[Softmax Function]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Cross-entropy loss''' (also called '''log loss''') is the most widely used loss function for classification tasks in machine learning. Rooted in information theory, it measures the dissimilarity between the true label distribution and the model's predicted probability distribution, providing a smooth, differentiable objective that drives probabilistic classifiers toward confident, correct predictions.

== Information-Theoretic Foundations ==

=== Entropy ===

The '''entropy''' of a discrete probability distribution <math>p</math> quantifies its uncertainty:

:<math>H(p) = -\sum_{k=1}^{K} p_k \log p_k</math>

For a deterministic distribution (one-hot label), <math>H(p) = 0</math>. Entropy is maximized when all outcomes are equally likely.

=== KL Divergence ===

The '''Kullback-Leibler divergence''' measures how one distribution <math>q</math> differs from a reference distribution <math>p</math>:

:<math>D_{\mathrm{KL}}(p \,\|\, q) = \sum_{k=1}^{K} p_k \log \frac{p_k}{q_k}</math>

KL divergence is non-negative and equals zero if and only if <math>p = q</math>.

=== Cross-Entropy ===

The '''cross-entropy''' between distributions <math>p</math> (true) and <math>q</math> (predicted) is:

:<math>H(p, q) = -\sum_{k=1}^{K} p_k \log q_k = H(p) + D_{\mathrm{KL}}(p \,\|\, q)</math>

Since <math>H(p)</math> is constant with respect to model parameters, minimizing cross-entropy is equivalent to minimizing KL divergence — i.e., making the predicted distribution <math>q</math> as close to the true distribution <math>p</math> as possible.

== Binary Cross-Entropy ==

For binary classification with true label <math>y \in \{0, 1\}</math> and predicted probability <math>\hat{y} = \sigma(z)</math> (where <math>\sigma</math> is the [[Softmax Function|sigmoid function]]):

:<math>\mathcal{L}_{\mathrm{BCE}} = -\bigl[y \log \hat{y} + (1 - y) \log(1 - \hat{y})\bigr]</math>

Over a dataset of <math>N</math> samples:

:<math>\mathcal{L} = -\frac{1}{N} \sum_{i=1}^{N} \bigl[y_i \log \hat{y}_i + (1 - y_i) \log(1 - \hat{y}_i)\bigr]</math>

The gradient with respect to the logit <math>z</math> takes the elegantly simple form <math>\hat{y} - y</math>, which is both intuitive and computationally efficient.

== Categorical Cross-Entropy ==

For multi-class classification with <math>K</math> classes, the true label is typically a one-hot vector <math>\mathbf{y}</math> with <math>y_c = 1</math> for the correct class <math>c</math>. The predicted probabilities <math>\hat{\mathbf{y}}</math> are obtained via the [[Softmax Function]]:

:<math>\mathcal{L}_{\mathrm{CE}} = -\sum_{k=1}^{K} y_k \log \hat{y}_k = -\log \hat{y}_c</math>

This reduces to the negative log-probability of the correct class, which is why categorical cross-entropy is also called '''negative log-likelihood''' in this context.

== Numerical Stability ==

=== The Log-Sum-Exp Trick ===

Naively computing <math>\log(\mathrm{softmax}(z_k))</math> involves exponentiating potentially large logits, causing overflow. The '''log-sum-exp''' trick avoids this:

:<math>\log \hat{y}_k = z_k - \log \sum_{j=1}^{K} e^{z_j} = z_k - \left(m + \log \sum_{j=1}^{K} e^{z_j - m}\right)</math>

where <math>m = \max_j z_j</math>. Subtracting the maximum logit ensures the largest exponent is zero, preventing overflow. All major deep learning frameworks implement this fused operation (e.g., PyTorch's <code>CrossEntropyLoss</code> accepts raw logits).

=== Clamping ===

Predicted probabilities should be clamped away from exactly 0 and 1 to avoid <math>\log(0) = -\infty</math>. A small epsilon (e.g., <math>10^{-7}</math>) is typically used.

== Label Smoothing ==

'''Label smoothing''' (Szegedy et al., 2016) replaces the hard one-hot target with a soft distribution:

:<math>y_k^{\mathrm{smooth}} = (1 - \alpha)\, y_k + \frac{\alpha}{K}</math>

where <math>\alpha</math> is a small constant (commonly 0.1). This prevents the model from becoming overconfident, improves calibration, and often yields better generalization. It is standard practice in training large image classifiers and Transformer models.

== Comparison with Other Losses ==

{| class="wikitable"
|-
! Loss !! Formula !! Typical use
|-
| '''Cross-entropy''' || <math>-\sum y_k \log \hat{y}_k</math> || Classification
|-
| '''Mean squared error''' || <math>\frac{1}{K}\sum(y_k - \hat{y}_k)^2</math> || Regression (poor for classification)
|-
| '''Hinge loss''' || <math>\max(0, 1 - y \cdot z)</math> || SVM-style classification
|-
| '''Focal loss''' || <math>-(1-\hat{y}_c)^\gamma \log \hat{y}_c</math> || Imbalanced classification
|}

Cross-entropy has steeper gradients than MSE when the prediction is confidently wrong, leading to faster correction of large errors.

== See also ==

* [[Loss Functions]]
* [[Softmax Function]]
* [[Logistic regression]]
* [[Information theory]]
* [[Neural Networks]]

== References ==

* Shannon, C. E. (1948). "A Mathematical Theory of Communication". ''Bell System Technical Journal''.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning''. MIT Press, Chapter 6.
* Szegedy, C. et al. (2016). "Rethinking the Inception Architecture for Computer Vision". ''CVPR''.
* Lin, T.-Y. et al. (2017). "Focal Loss for Dense Object Detection". ''ICCV''.

[[Category:Machine Learning]]
[[Category:Intermediate]]

Convolutional Neural Networks

2026-04-24T07:08:58Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Convolutional Neural Networks}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Backpropagation]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Convolutional neural networks''' ('''CNNs''' or '''ConvNets''') are a class of deep [[Neural Networks|neural networks]] specifically designed to process data with a grid-like topology, such as images (2D grids of pixels), audio spectrograms, and video. They exploit the spatial structure of the input through local connectivity, weight sharing, and pooling, making them far more efficient than fully connected networks for visual and spatial tasks.

== The convolution operation ==

The core building block is the '''discrete convolution'''. For a 2D input <math>\mathbf{X}</math> and a filter (kernel) <math>\mathbf{K}</math> of size <math>k \times k</math>, the output feature map <math>\mathbf{Y}</math> is:

:<math>Y_{i,j} = \sum_{m=0}^{k-1}\sum_{n=0}^{k-1} K_{m,n} \cdot X_{i+m,\, j+n} + b</math>

where <math>b</math> is a bias term. The filter slides (convolves) across the input, computing a dot product at each position. Technically, most implementations compute '''cross-correlation''' rather than true convolution (which would flip the kernel), but the distinction is immaterial since the kernel weights are learned.

Key hyperparameters controlling the convolution:

* '''Kernel size''' — the spatial extent of the filter (e.g. <math>3 \times 3</math>, <math>5 \times 5</math>).
* '''Stride''' — the step size between successive positions of the kernel. A stride of 2 halves the spatial dimensions.
* '''Padding''' — adding zeros around the border of the input to control the output size. "Same" padding preserves spatial dimensions; "valid" padding uses no padding.

== Filters and feature detection ==

Each filter learns to detect a specific local pattern. In early layers, filters typically respond to edges, corners, and colour gradients. Deeper layers compose these into higher-level features — textures, parts, and eventually entire objects.

A convolutional layer applies multiple filters in parallel, producing a stack of feature maps. If the input has <math>C_{\text{in}}</math> channels and the layer has <math>C_{\text{out}}</math> filters, the total number of learnable parameters is:

:<math>C_{\text{out}} \times (C_{\text{in}} \times k^2 + 1)</math>

This is dramatically fewer than a fully connected layer with the same input and output dimensions, because weights are shared across all spatial positions.

== Pooling ==

'''Pooling''' layers downsample the feature maps, reducing their spatial dimensions and providing a degree of translation invariance. Common pooling operations:

* '''Max pooling''' — takes the maximum value in each local window (e.g. <math>2 \times 2</math>).
* '''Average pooling''' — takes the mean value in each window.
* '''Global average pooling''' — averages each entire feature map to a single value, often used before the final classification layer.

Pooling reduces computational cost and helps prevent overfitting by progressively abstracting the representation.

== Architecture of a CNN ==

A typical CNN alternates convolutional layers and pooling layers, followed by one or more fully connected layers for the final prediction:

<pre>
Input → [Conv → ReLU → Pool] × N → Flatten → FC → FC → Output
</pre>

Each conv-pool block extracts increasingly abstract features, while the fully connected layers combine them for classification or regression.

== Landmark architectures ==

{| class="wikitable"
|-
! Architecture !! Year !! Key contribution !! Depth
|-
| '''LeNet-5''' || 1998 || Pioneered CNNs for handwritten digit recognition (MNIST) || 5 layers
|-
| '''AlexNet''' || 2012 || Won ImageNet; popularised ReLU, dropout, GPU training || 8 layers
|-
| '''VGGNet''' || 2014 || Showed depth matters; used only <math>3 \times 3</math> filters throughout || 16–19 layers
|-
| '''GoogLeNet (Inception)''' || 2014 || Introduced inception modules with parallel filter sizes || 22 layers
|-
| '''ResNet''' || 2015 || Introduced residual connections enabling very deep networks || 50–152+ layers
|-
| '''DenseNet''' || 2017 || Connected each layer to every subsequent layer via dense blocks || 121–264 layers
|-
| '''EfficientNet''' || 2019 || Compound scaling of depth, width, and resolution || Variable
|}

=== Residual connections ===

The '''residual connection''' (or skip connection) introduced by ResNet adds the input of a block directly to its output:

:<math>\mathbf{y} = \mathcal{F}(\mathbf{x}) + \mathbf{x}</math>

This allows gradients to flow directly through the identity path, mitigating the vanishing gradient problem and enabling the training of networks with hundreds of layers. Residual connections have become a standard component in nearly all modern architectures.

== Applications in computer vision ==

CNNs have achieved state-of-the-art performance across a wide range of vision tasks:

* '''Image classification''' — assigning a label to an entire image (ImageNet, CIFAR).
* '''Object detection''' — localising and classifying objects within an image (YOLO, Faster R-CNN, SSD).
* '''Semantic segmentation''' — assigning a class label to every pixel (U-Net, DeepLab).
* '''Instance segmentation''' — distinguishing individual instances of objects (Mask R-CNN).
* '''Image generation''' — generating realistic images using CNN-based generators (GANs, diffusion models).
* '''Medical imaging''' — tumour detection, retinal analysis, and radiology screening.

== Practical tips ==

* Use pretrained models (transfer learning) when labelled data is limited.
* Prefer small kernels (<math>3 \times 3</math>) stacked in depth — two <math>3 \times 3</math> layers have the same receptive field as one <math>5 \times 5</math> layer but with fewer parameters.
* Apply batch normalisation after convolution and before activation.
* Use data augmentation generously to reduce [[Overfitting and Regularization|overfitting]].
* Replace fully connected layers with global average pooling to reduce parameters.

== See also ==

* [[Neural Networks]]
* [[Backpropagation]]
* [[Overfitting and Regularization]]
* [[Recurrent Neural Networks]]
* [[Gradient Descent]]

== References ==

* LeCun, Y. et al. (1998). "Gradient-Based Learning Applied to Document Recognition". ''Proceedings of the IEEE''.
* Krizhevsky, A., Sutskever, I. and Hinton, G. E. (2012). "ImageNet Classification with Deep Convolutional Neural Networks". ''NeurIPS''.
* Simonyan, K. and Zisserman, A. (2015). "Very Deep Convolutional Networks for Large-Scale Image Recognition". ''ICLR''.
* He, K. et al. (2016). "Deep Residual Learning for Image Recognition". ''CVPR''.
* Tan, M. and Le, Q. V. (2019). "EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks". ''ICML''.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Batch Normalization

2026-04-24T07:08:58Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Batch Normalization}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Neural Networks]], [[Backpropagation]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Batch normalization''' (often abbreviated '''BatchNorm''' or '''BN''') is a technique for improving the speed, stability, and performance of deep neural networks by normalizing the inputs to each layer. Introduced by Ioffe and Szegedy in 2015, it has become a standard component in most modern deep learning architectures.

== Internal Covariate Shift ==

The original motivation for batch normalization was to address '''internal covariate shift''' — the phenomenon where the distribution of each layer's inputs changes during training as the parameters of preceding layers are updated. This shifting distribution forces each layer to continuously adapt, slowing down convergence and requiring careful initialization and small learning rates.

While the precise role of internal covariate shift has been debated (Santurkar et al., 2018, argued that BatchNorm's benefits stem more from smoothing the loss landscape), the practical effectiveness of the technique is well established.

== The Batch Normalization Algorithm ==

=== During Training ===

For a mini-batch <math>\mathcal{B} = \{x_1, \dots, x_m\}</math> of activations at a given layer, BatchNorm proceeds as follows:

'''Step 1.''' Compute the mini-batch mean and variance:

:<math>\mu_{\mathcal{B}} = \frac{1}{m} \sum_{i=1}^{m} x_i, \qquad \sigma_{\mathcal{B}}^2 = \frac{1}{m} \sum_{i=1}^{m} (x_i - \mu_{\mathcal{B}})^2</math>

'''Step 2.''' Normalize:

:<math>\hat{x}_i = \frac{x_i - \mu_{\mathcal{B}}}{\sqrt{\sigma_{\mathcal{B}}^2 + \epsilon}}</math>

where <math>\epsilon</math> is a small constant (e.g., <math>10^{-5}</math>) for numerical stability.

'''Step 3.''' Scale and shift with learned parameters <math>\gamma</math> and <math>\beta</math>:

:<math>y_i = \gamma \hat{x}_i + \beta</math>

The parameters <math>\gamma</math> and <math>\beta</math> are learned during training. They restore the network's ability to represent the identity transformation if that is optimal, ensuring that normalization does not reduce the model's expressiveness.

=== During Inference ===

At inference time, statistics from individual mini-batches are unreliable (the input may be a single example). Instead, BatchNorm uses running estimates of the population mean and variance accumulated during training via exponential moving averages:

:<math>\mu_{\mathrm{running}} \leftarrow (1 - \alpha)\, \mu_{\mathrm{running}} + \alpha\, \mu_{\mathcal{B}}</math>

:<math>\sigma^2_{\mathrm{running}} \leftarrow (1 - \alpha)\, \sigma^2_{\mathrm{running}} + \alpha\, \sigma^2_{\mathcal{B}}</math>

where <math>\alpha</math> is the momentum parameter (typically 0.1). These fixed statistics ensure deterministic outputs at inference.

== Benefits ==

* '''Higher learning rates''': By constraining activation distributions, BatchNorm allows larger step sizes without divergence.
* '''Reduced sensitivity to initialization''': Networks with BatchNorm are more forgiving of poor weight initialization.
* '''Regularization effect''': The noise introduced by mini-batch statistics acts as a mild regularizer, sometimes reducing the need for [[Dropout]].
* '''Faster convergence''': Training typically requires fewer epochs to reach a given level of performance.

== Placement ==

BatchNorm is typically applied '''before''' the activation function (as in the original paper), though some practitioners place it '''after''' the activation. For convolutional layers, normalization is performed per-channel across the spatial dimensions and the batch dimension.

== Normalization Alternatives ==

{| class="wikitable"
|-
! Method !! Normalizes over !! Use case
|-
| '''Batch Norm''' || Batch and spatial dims, per channel || CNNs with large batches
|-
| '''Layer Norm''' || All channels and spatial dims, per sample || Transformers, RNNs, small batches
|-
| '''Instance Norm''' || Spatial dims only, per sample per channel || Style transfer, image generation
|-
| '''Group Norm''' || Groups of channels, per sample || Object detection, small-batch training
|}

'''Layer normalization''' (Ba et al., 2016) normalizes across all features within a single sample, making it independent of batch size. It is the standard choice in Transformer architectures.

'''Group normalization''' (Wu and He, 2018) divides channels into groups and normalizes within each group per sample. It bridges the gap between Layer Norm and Instance Norm and performs well when batch sizes are too small for reliable batch statistics.

== Limitations ==

* Performance degrades with very small batch sizes, as batch statistics become noisy.
* Introduces a discrepancy between training (batch statistics) and inference (running statistics) behavior.
* Not directly applicable to variable-length sequences without padding or masking.
* The running statistics require careful handling when using distributed training across multiple devices.

== See also ==

* [[Neural Networks]]
* [[Backpropagation]]
* [[Dropout]]
* [[Stochastic Gradient Descent]]
* [[Transformer]]

== References ==

* Ioffe, S. and Szegedy, C. (2015). "Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift". ''ICML''.
* Ba, J. L., Kiros, J. R. and Hinton, G. E. (2016). "Layer Normalization". ''arXiv:1607.06450''.
* Wu, Y. and He, K. (2018). "Group Normalization". ''ECCV''.
* Santurkar, S. et al. (2018). "How Does Batch Normalization Help Optimization?". ''NeurIPS''.

[[Category:Deep Learning]]
[[Category:Intermediate]]
[[Category:Neural Networks]]

Backpropagation

2026-04-24T07:08:58Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Backpropagation}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Intermediate | prerequisites = [[Gradient Descent]], [[Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Backpropagation''' (short for '''backward propagation of errors''') is an algorithm for efficiently computing the gradient of a loss function with respect to every weight in a neural network. Combined with an optimisation method such as [[Gradient Descent|gradient descent]], it forms the standard training procedure for modern deep learning models.

== The chain rule ==

Backpropagation is fundamentally an application of the '''chain rule''' of calculus. If a variable <math>z</math> depends on <math>y</math>, which in turn depends on <math>x</math>, then:

:<math>\frac{\partial z}{\partial x} = \frac{\partial z}{\partial y} \cdot \frac{\partial y}{\partial x}</math>

In a neural network the loss <math>L</math> depends on the output, which depends on the activations of the last hidden layer, which depend on the activations of the previous layer, and so on back to the input. The chain rule allows us to decompose the gradient into a product of local derivatives, one for each layer.

== Forward pass ==

During the forward pass, input data propagates through the network layer by layer. For a fully connected layer <math>l</math>:

:<math>\mathbf{z}^{(l)} = \mathbf{W}^{(l)} \mathbf{a}^{(l-1)} + \mathbf{b}^{(l)}</math>

:<math>\mathbf{a}^{(l)} = g^{(l)}(\mathbf{z}^{(l)})</math>

where <math>\mathbf{a}^{(l-1)}</math> is the activation from the previous layer (with <math>\mathbf{a}^{(0)} = \mathbf{x}</math>), <math>\mathbf{W}^{(l)}</math> and <math>\mathbf{b}^{(l)}</math> are the weights and biases, and <math>g^{(l)}</math> is the activation function. The forward pass stores all intermediate values <math>\mathbf{z}^{(l)}</math> and <math>\mathbf{a}^{(l)}</math> because they are needed during the backward pass.

== Backward pass ==

The backward pass computes gradients starting from the loss and moving toward the input. Define the error signal at layer <math>l</math> as:

:<math>\boldsymbol{\delta}^{(l)} = \frac{\partial L}{\partial \mathbf{z}^{(l)}}</math>

For the output layer (layer <math>L_{\text{out}}</math>):

:<math>\boldsymbol{\delta}^{(L_{\text{out}})} = \frac{\partial L}{\partial \mathbf{a}^{(L_{\text{out}})}} \odot g'^{(L_{\text{out}})}(\mathbf{z}^{(L_{\text{out}})})</math>

For each earlier layer, the error propagates backward:

:<math>\boldsymbol{\delta}^{(l)} = \bigl(\mathbf{W}^{(l+1)}\bigr)^\top \boldsymbol{\delta}^{(l+1)} \odot g'^{(l)}(\mathbf{z}^{(l)})</math>

where <math>\odot</math> denotes element-wise multiplication. Once the error signal is known, the parameter gradients are:

:<math>\frac{\partial L}{\partial \mathbf{W}^{(l)}} = \boldsymbol{\delta}^{(l)} \bigl(\mathbf{a}^{(l-1)}\bigr)^\top, \qquad \frac{\partial L}{\partial \mathbf{b}^{(l)}} = \boldsymbol{\delta}^{(l)}</math>

== Computational graphs ==

Modern deep learning frameworks (PyTorch, TensorFlow, JAX) implement backpropagation by constructing a '''computational graph''' — a directed acyclic graph where each node represents an operation and each edge carries a tensor. The forward pass builds the graph; the backward pass traverses it in reverse topological order, applying the chain rule at every node.

This abstraction makes it possible to differentiate arbitrary compositions of operations, not just standard layer types. Two implementation strategies exist:

* '''Static graphs''' — the graph is defined once before execution (early TensorFlow). Enables aggressive compiler optimisations but is less flexible.
* '''Dynamic graphs''' — the graph is rebuilt on every forward pass (PyTorch, TensorFlow Eager mode). More intuitive for debugging and models with data-dependent control flow.

== Automatic differentiation ==

Backpropagation is a special case of '''reverse-mode automatic differentiation''' (AD). Unlike numerical differentiation (which is approximate) or symbolic differentiation (which can produce unwieldy expressions), AD computes exact derivatives by systematically applying the chain rule to elementary operations.

Reverse-mode AD computes the gradient of a scalar output with respect to all inputs in a single backward pass, making it ideally suited to neural networks where the loss is scalar but the parameters number in the millions.

The cost of the backward pass is typically 2–3 times that of the forward pass, because it must evaluate the local Jacobians and multiply them with the incoming error signal.

== Vanishing and exploding gradients ==

When a network has many layers, the gradient is a product of many local derivatives. If these factors are consistently less than 1, the gradient shrinks exponentially toward zero — the '''vanishing gradient''' problem. If they are consistently greater than 1, the gradient grows exponentially — the '''exploding gradient''' problem.

{| class="wikitable"
|-
! Problem !! Symptom !! Common mitigations
|-
| '''Vanishing gradients''' || Early layers learn extremely slowly || ReLU activations, residual connections, batch normalisation, careful initialisation
|-
| '''Exploding gradients''' || Loss diverges or produces NaN values || Gradient clipping, weight regularisation, lower learning rate
|}

These issues were major obstacles to training deep networks before the introduction of ReLU activations, residual connections (ResNets), and normalisation techniques.

== Practical considerations ==

* '''Memory''' — the forward pass must store all intermediate activations for the backward pass. For very deep networks this can be prohibitive; '''gradient checkpointing''' trades compute for memory by recomputing activations during the backward pass instead of storing them.
* '''Numerical stability''' — using log-sum-exp tricks and fused softmax-cross-entropy implementations avoids overflow and underflow.
* '''Higher-order gradients''' — differentiating through the backward pass itself yields second-order information (Hessian-vector products), useful for methods like natural gradient descent and meta-learning.
* '''Mixed precision''' — computing the forward pass in half precision while keeping a master copy of the weights in full precision speeds up training on modern GPUs.

== Historical development ==

The key ideas behind backpropagation were developed independently by several researchers. Seppo Linnainmaa described reverse-mode automatic differentiation in 1970. Paul Werbos applied it to neural networks in his 1974 PhD thesis. The algorithm achieved widespread adoption after the influential 1986 paper by Rumelhart, Hinton, and Williams, which demonstrated its effectiveness on multi-layer networks.

== See also ==

* [[Gradient Descent]]
* [[Stochastic Gradient Descent]]
* [[Neural Networks]]
* [[Loss Functions]]
* [[Convolutional Neural Networks]]
* [[Recurrent Neural Networks]]

== References ==

* Rumelhart, D. E., Hinton, G. E. and Williams, R. J. (1986). "Learning representations by back-propagating errors". ''Nature'', 323, 533–536.
* Linnainmaa, S. (1970). "The representation of the cumulative rounding error of an algorithm as a Taylor expansion of the local rounding errors". Master's thesis, University of Helsinki.
* Werbos, P. J. (1974). "Beyond Regression: New Tools for Prediction and Analysis in the Behavioral Sciences". PhD thesis, Harvard University.
* Baydin, A. G. et al. (2018). "Automatic Differentiation in Machine Learning: a Survey". ''JMLR'', 18(153), 1–43.
* Goodfellow, I., Bengio, Y. and Courville, A. (2016). ''Deep Learning'', Chapter 6. MIT Press.

[[Category:Deep Learning]]
[[Category:Intermediate]]

Attention Mechanisms

2026-04-24T07:08:58Z

DeployBot: [deploy-bot] Deploy from CI (8c92aeb)

{{LanguageBar | page = Attention Mechanisms}}
{{ArticleInfobox | topic_area = Deep Learning | difficulty = Advanced | prerequisites = [[Neural Networks]], [[Recurrent Neural Networks]]}}
{{ContentMeta | generated_by = claude-opus | model_used = claude-opus-4-6 | generated_date = 2026-03-13}}

'''Attention mechanisms''' are a family of techniques that allow neural networks to focus selectively on relevant parts of their input when producing each element of the output. Originally introduced to overcome the limitations of fixed-length context vectors in sequence-to-sequence models, attention has become the foundational building block of modern architectures such as the [[Transformer]].

== Motivation ==

Early sequence-to-sequence models encoded an entire input sequence into a single fixed-dimensional vector using a [[Recurrent Neural Networks|recurrent neural network]]. This ''bottleneck'' forced long-range dependencies to be compressed into a vector of constant size, degrading performance on long sequences. Attention resolves this by letting the decoder consult every encoder hidden state at each generation step, weighting them by learned relevance scores.

== Bahdanau (Additive) Attention ==

Bahdanau et al. (2015) proposed the first widely adopted attention mechanism for machine translation. Given encoder hidden states <math>h_1, \dots, h_T</math> and the decoder state <math>s_{t-1}</math>, the alignment score is computed as:

:<math>e_{t,i} = v^{\!\top} \tanh(W_s\, s_{t-1} + W_h\, h_i)</math>

where <math>W_s</math>, <math>W_h</math>, and <math>v</math> are learned parameters. The attention weights are obtained by applying softmax:

:<math>\alpha_{t,i} = \frac{\exp(e_{t,i})}{\sum_{j=1}^{T} \exp(e_{t,j})}</math>

The context vector is the weighted sum <math>c_t = \sum_{i=1}^{T} \alpha_{t,i}\, h_i</math>, which is concatenated with <math>s_{t-1}</math> and fed into the decoder.

== Luong (Multiplicative) Attention ==

Luong et al. (2015) simplified the scoring function by replacing the additive network with a dot product or a bilinear form:

{| class="wikitable"
|-
! Variant !! Score function
|-
| Dot || <math>e_{t,i} = s_t^{\!\top} h_i</math>
|-
| General || <math>e_{t,i} = s_t^{\!\top} W_a\, h_i</math>
|-
| Concat || <math>e_{t,i} = v^{\!\top} \tanh(W_a [s_t;\, h_i])</math>
|}

The dot variant requires encoder and decoder dimensions to match, while the general variant introduces a learnable weight matrix <math>W_a</math>.

== Scaled Dot-Product Attention ==

Vaswani et al. (2017) introduced the formulation used in the Transformer. Given matrices of queries <math>Q</math>, keys <math>K</math>, and values <math>V</math>:

:<math>\mathrm{Attention}(Q, K, V) = \mathrm{softmax}\!\left(\frac{Q K^{\!\top}}{\sqrt{d_k}}\right) V</math>

The scaling factor <math>\sqrt{d_k}</math> prevents the dot products from growing large in magnitude as the key dimension <math>d_k</math> increases, which would push the softmax into regions of extremely small gradients.

== Self-Attention ==

In '''self-attention''', the queries, keys, and values all derive from the same sequence. Each position attends to every other position (including itself), enabling the model to capture long-range dependencies in a single layer. For an input matrix <math>X \in \mathbb{R}^{n \times d}</math>:

:<math>Q = X W^Q, \quad K = X W^K, \quad V = X W^V</math>

Self-attention has <math>O(n^2 d)</math> complexity, which can be expensive for very long sequences. Efficient variants such as sparse attention and linear attention reduce this cost.

== Multi-Head Attention ==

Rather than performing a single attention function, '''multi-head attention''' runs <math>h</math> parallel attention heads with independent projections:

:<math>\mathrm{MultiHead}(Q, K, V) = \mathrm{Concat}(\mathrm{head}_1, \dots, \mathrm{head}_h)\, W^O</math>

where <math>\mathrm{head}_i = \mathrm{Attention}(Q W_i^Q,\, K W_i^K,\, V W_i^V)</math>. Each head can learn to attend to different aspects of the input — for example, one head might capture syntactic relationships while another captures semantic ones. Typical configurations use 8 or 16 heads.

== Positional Encoding ==

Because self-attention is permutation-invariant (it treats the input as an unordered set), positional information must be injected explicitly. The original Transformer uses sinusoidal encodings:

:<math>\mathrm{PE}(pos, 2i) = \sin\!\left(\frac{pos}{10000^{2i/d}}\right), \quad \mathrm{PE}(pos, 2i+1) = \cos\!\left(\frac{pos}{10000^{2i/d}}\right)</math>

Learned positional embeddings and relative positional encodings (e.g., RoPE, ALiBi) are common alternatives that can generalise better to unseen sequence lengths.

== Cross-Attention ==

'''Cross-attention''' is used when queries come from one sequence and keys/values come from another. In encoder-decoder Transformers, the decoder attends to encoder outputs via cross-attention, enabling the model to condition its generation on the full input context.

== Practical Considerations ==

* '''Masking''': In autoregressive decoding, future positions are masked (set to <math>-\infty</math> before softmax) to preserve the causal structure.
* '''Attention dropout''': Dropping attention weights randomly during training acts as a regulariser and reduces overfitting to specific alignment patterns.
* '''Key-value caching''': During inference, previously computed key and value vectors are cached to avoid redundant computation, significantly speeding up autoregressive generation.

== See also ==

* [[Transformer]]
* [[Recurrent Neural Networks]]
* [[Sequence-to-sequence models]]
* [[Self-supervised learning]]
* [[Softmax Function]]

== References ==

* Bahdanau, D., Cho, K. and Bengio, Y. (2015). "Neural Machine Translation by Jointly Learning to Align and Translate". ''ICLR''.
* Luong, M.-T., Pham, H. and Manning, C. D. (2015). "Effective Approaches to Attention-based Neural Machine Translation". ''EMNLP''.
* Vaswani, A. et al. (2017). "Attention Is All You Need". ''NeurIPS''.
* Shaw, P., Uszkoreit, J. and Vaswani, A. (2018). "Self-Attention with Relative Position Representations". ''NAACL''.
* Su, J. et al. (2021). "RoFormer: Enhanced Transformer with Rotary Position Embedding". ''arXiv:2104.09864''.

[[Category:Deep Learning]]
[[Category:Advanced]]
[[Category:Neural Networks]]

Template:GlossaryTranslation

2026-04-24T07:06:58Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
'''GlossaryTranslation''' — Template for language-specific glossary subpages.

== Usage ==

Place on subpages like <code>Glossary:Gradient_descent/es</code>:

<pre>
{{GlossaryTranslation
|surface_form=descenso de gradiente
|aliases=descenso por gradiente, método del gradiente
|definition_status=reviewed
}}

Translated definition goes here (1-3 sentences in the target language).
</pre>

== Parameters ==

{| class="wikitable"
|-
! Parameter !! Required !! Description
|-
| surface_form || Yes || The term as written in this language
|-
| aliases || No || Comma-separated alternate phrasings in this language
|-
| definition_status || No || draft, reviewed, or verified
|}

[[Category:Marovi templates]]
</noinclude><includeonly><div class="glossary-translation-box" style="border:1px solid #c8ccd1; border-radius:4px; padding:12px 16px; margin-bottom:12px; background:#f8f9fa;">
<div style="font-size:12px; color:#72777d; text-transform:uppercase; letter-spacing:0.5px; margin-bottom:4px;">Translation{{#if:{{{definition_status|}}}|&ensp;·&ensp;<span style="{{#ifeq:{{{definition_status|}}}|verified|color:#14866d|{{#ifeq:{{{definition_status|}}}|reviewed|color:#36c|color:#72777d}}}}">{{{definition_status|}}}</span>|}}</div>
<div style="font-size:15px; font-weight:600; margin-bottom:4px;">{{{surface_form|}}}</div>
{{#if:{{{aliases|}}}|<div style="font-size:13px; color:#54595d;"><strong>Also:</strong> {{{aliases|}}}</div>|}}
</div></includeonly>

Template:GlossaryConcept

2026-04-24T07:06:57Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
'''GlossaryConcept''' — Template for glossary entries in the Glossary: namespace.

== Usage ==

<pre>
{{GlossaryConcept
|concept_id=gradient_descent
|domain=machine learning, optimization
|aliases=GD, batch gradient descent
|related=Glossary:Stochastic_gradient_descent, Glossary:Learning_rate
|article=Gradient descent
|article_section=
|difficulty=intermediate
}}

Free-text definition goes here (1-3 sentences).
</pre>

== Parameters ==

{| class="wikitable"
|-
! Parameter !! Required !! Description
|-
| concept_id || Yes || Lowercase slug identifier for the concept
|-
| domain || Yes || Comma-separated domain tags (e.g. machine learning, linear algebra)
|-
| aliases || No || Comma-separated alternate English phrasings
|-
| related || No || Comma-separated links to related Glossary: entries
|-
| article || No || Title of the main wiki article for this concept
|-
| article_section || No || Anchor to a specific section in the article
|-
| difficulty || No || beginner, intermediate, or advanced
|}

[[Category:Marovi templates]]
</noinclude><includeonly><div class="glossary-concept-box" style="border:1px solid #c8ccd1; border-radius:4px; padding:12px 16px; margin-bottom:12px; background:#f8f9fa;">
<div style="font-size:12px; color:#72777d; text-transform:uppercase; letter-spacing:0.5px; margin-bottom:4px;">Glossary{{#if:{{{domain|}}}|&ensp;·&ensp;{{{domain|}}}|}}</div>
{{#if:{{{article|}}}|<div style="margin-bottom:6px;">📖 [[{{{article}}}{{#if:{{{article_section|}}}|#{{{article_section}}}|}}|Read full article]]</div>|}}
{{#if:{{{aliases|}}}|<div style="font-size:13px; color:#54595d;"><strong>Also known as:</strong> {{{aliases|}}}</div>|}}
{{#if:{{{related|}}}|<div style="font-size:13px; color:#54595d; margin-top:4px;"><strong>Related:</strong> {{{related|}}}</div>|}}
{{#if:{{{difficulty|}}}|<div style="margin-top:4px;"><span style="display:inline-block; background:#eaecf0; color:#54595d; padding:1px 8px; border-radius:3px; font-size:11px;">{{{difficulty|}}}</span></div>|}}
</div></includeonly>

Template:ArticleMeta

2026-04-24T07:06:55Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
== ArticleMeta ==
Hidden metadata template for Marovi content pages. Records provenance,
generation, and review information. Does not render any visible output.

=== Parameters ===
{| class="wikitable"
|-
! Parameter !! Description !! Example
|-
| content_type || paper, article, or summary || paper
|-
| source_url || URL of the original source || <nowiki>https://arxiv.org/abs/1706.03762</nowiki>
|-
| source_language || ISO language code of the source || en
|-
| generated_by || Bot key that created the content || claude-opus
|-
| generation_date || Date the content was generated || 2026-03-10
|-
| last_review_date || Date of last quality review || 2026-03-14
|-
| quality_score || Overall quality score (0.00–1.00) || 0.82
|-
| review_state || Current review state || reviewed
|}

=== Usage ===
<pre>
{{ArticleMeta
| content_type = paper
| source_url = https://arxiv.org/abs/1706.03762
| source_language = en
| generated_by = claude-opus
| generation_date = 2026-03-10
| last_review_date =
| quality_score =
| review_state = draft
}}
</pre>
</noinclude><includeonly></includeonly>

Template:SummaryInfobox

2026-04-24T07:06:54Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
Infobox template for summary subpages. Usage:
<pre>
{{SummaryInfobox
| parent_page = Gradient Descent
| parent_type = article
}}
</pre>
</noinclude><includeonly>{| class="infobox" style="border: 1px solid #aaa; background: #f9f9f9; padding: 0.5em; float: right; clear: right; margin: 0 0 1em 1em; width: 22em; font-size: 90%;"
|-
! colspan="2" style="background: #dcc; text-align: center; font-size: 110%;" | Summary
|-
| '''Full {{{parent_type|article}}}'''
| [[{{{parent_page}}}]]
|}</includeonly>

Template:PaperInfobox

2026-04-24T07:06:52Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
Infobox template for Marovi paper articles. Usage:
<pre>
{{PaperInfobox
| topic_area = NLP
| difficulty = Research
| authors = Vaswani, A.; Shazeer, N.; Parmar, N.
| year = 2017
| venue = NeurIPS 2017
| arxiv_id = 1706.03762
| source_url = https://arxiv.org/abs/1706.03762
| pdf_url = https://arxiv.org/pdf/1706.03762
}}
</pre>
</noinclude><includeonly>{| class="infobox" style="border: 1px solid #aaa; background: #f9f9f9; padding: 0.5em; float: right; clear: right; margin: 0 0 1em 1em; width: 22em; font-size: 90%;"
|-
! colspan="2" style="background: #cdc; text-align: center; font-size: 110%;" | Research Paper
|-
{{#if: {{{authors|}}} |
{{!}} '''Authors'''
{{!}} {{{authors}}}
}}
|-
{{#if: {{{year|}}} |
{{!}} '''Year'''
{{!}} {{{year}}}
}}
|-
{{#if: {{{venue|}}} |
{{!}} '''Venue'''
{{!}} {{{venue}}}
}}
|-
{{#if: {{{topic_area|}}} |
{{!}} '''Topic area'''
{{!}} [[:Category:{{{topic_area}}}|{{{topic_area}}}]]
}}
|-
{{#if: {{{difficulty|}}} |
{{!}} '''Difficulty'''
{{!}} [[:Category:{{{difficulty}}}|{{{difficulty}}}]]
}}
|-
{{#if: {{{arxiv_id|}}} |
{{!}} '''arXiv'''
{{!}} [{{{source_url|https://arxiv.org/abs/{{{arxiv_id}}}}}} {{{arxiv_id}}}]
}}
|-
{{#if: {{{pdf_url|}}} |
{{!}} '''PDF'''
{{!}} [{{{pdf_url}}} Download PDF]
}}
|}</includeonly>

Template:RelatedContent

2026-04-24T07:06:51Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
Displays a related content box at the bottom of a page linking to related articles and papers.

== Usage ==
<pre>
{{RelatedContent
|articles=Gradient descent, Backpropagation, Learning rate
|papers=Attention Is All You Need, BERT
}}
</pre>

== Parameters ==
* '''articles''' — Comma-separated list of related article page names.
* '''papers''' — Comma-separated list of related paper page names.

[[Category:Marovi templates]]
</noinclude><includeonly><div class="marovi-related">
<div class="marovi-related-header">Related Content</div>
<div class="marovi-related-columns">{{#if:{{{articles|}}}|
<div class="marovi-related-column">
<div class="marovi-related-column-title">Articles</div>
<ul>{{#arraymap:{{{articles|}}}|,|@@item@@|<li>[[@@item@@]]</li>|}}</ul>
</div>}}{{#if:{{{papers|}}}|
<div class="marovi-related-column">
<div class="marovi-related-column-title">Papers</div>
<ul>{{#arraymap:{{{papers|}}}|,|@@item@@|<li>[[@@item@@]]</li>|}}</ul>
</div>}}
</div>
</div></includeonly>

Template:TopicNav

2026-04-24T07:06:50Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
Displays a breadcrumb navigation bar above the article content.

== Usage ==
<pre>
{{TopicNav|field=Machine Learning|subfield=Optimization}}
</pre>

== Parameters ==
* '''field''' — Top-level field of study.
* '''subfield''' — Sub-topic within the field. Optional.

[[Category:Marovi templates]]
</noinclude><includeonly><div class="marovi-topicnav">[[:Category:Articles|Articles]]{{#if:{{{field|}}}|<span class="marovi-topicnav-separator">›</span>[[:Category:{{{field|}}}|{{{field|}}}]]}}{{#if:{{{subfield|}}}|<span class="marovi-topicnav-separator">›</span>[[:Category:{{{subfield|}}}|{{{subfield|}}}]]}}<span class="marovi-topicnav-separator">›</span>'''{{PAGENAME}}'''</div></includeonly>

Template:Term

2026-04-24T07:06:48Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
Wraps a technical term with glossary popup support. The term is looked up in [[Module:Glossary/data]] and rendered with a dotted underline. Hovering shows a popup with the definition.

== Usage ==
<pre>
{{Term|SGD}}
{{Term|SGD|stochastic gradient descent}}
{{Term|learning rate}}
</pre>

The first parameter is the lookup key. The optional second parameter is the display text.

[[Category:Marovi templates]]
</noinclude><includeonly>{{#invoke:Glossary|term}}</includeonly>

Template:Paper

2026-04-24T07:06:47Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
Displays a paper metadata infobox on the right side of the page.

== Usage ==
<pre>
{{Paper
|title=Attention Is All You Need
|authors=Vaswani et al.
|year=2017
|venue=NeurIPS
|arxiv=1706.03762
|doi=
|topics=Transformers, Attention, NLP
|related_articles=Transformer, Self-Attention
|languages=es, zh
}}
</pre>

== Parameters ==
* '''title''' — Paper title. Defaults to page name.
* '''authors''' — Author list.
* '''year''' — Publication year.
* '''venue''' — Conference or journal.
* '''arxiv''' — arXiv ID (just the number, e.g. 1706.03762).
* '''doi''' — DOI (without https://doi.org/ prefix).
* '''topics''' — Comma-separated topics.
* '''related_articles''' — Comma-separated related article page names.
* '''languages''' — Comma-separated ISO language codes with translations available.

[[Category:Marovi templates]]
</noinclude><includeonly><div class="marovi-infobox">
<div class="marovi-infobox-header marovi-infobox-header--paper">{{{title|{{PAGENAME}}}}}</div>
<div class="marovi-infobox-body">{{#if:{{{authors|}}}|
<div class="marovi-infobox-row">
<span class="marovi-infobox-label">Authors</span>
<span class="marovi-infobox-value">{{{authors|}}}</span>
</div>}}{{#if:{{{year|}}}|
<div class="marovi-infobox-row">
<span class="marovi-infobox-label">Year</span>
<span class="marovi-infobox-value">{{{year|}}}</span>
</div>}}{{#if:{{{venue|}}}|
<div class="marovi-infobox-row">
<span class="marovi-infobox-label">Venue</span>
<span class="marovi-infobox-value">{{{venue|}}}</span>
</div>}}{{#if:{{{arxiv|}}}|
<div class="marovi-infobox-row">
<span class="marovi-infobox-label">arXiv</span>
<span class="marovi-infobox-value">[https://arxiv.org/abs/{{{arxiv|}}} {{{arxiv|}}}]</span>
</div>}}{{#if:{{{doi|}}}|
<div class="marovi-infobox-row">
<span class="marovi-infobox-label">DOI</span>
<span class="marovi-infobox-value">[https://doi.org/{{{doi|}}} {{{doi|}}}]</span>
</div>}}{{#if:{{{topics|}}}|
<div class="marovi-infobox-row">
<span class="marovi-infobox-label">Topics</span>
<span class="marovi-infobox-value"><span class="marovi-infobox-tags">{{#arraymap:{{{topics|}}}|,|@@item@@|<span class="marovi-infobox-tag">@@item@@</span>|}}</span></span>
</div>}}{{#if:{{{related_articles|}}}|
<div class="marovi-infobox-links">
<div class="marovi-infobox-links-label">Related Articles</div>
<ul>{{#arraymap:{{{related_articles|}}}|,|@@item@@|<li>[[@@item@@]]</li>|}}</ul>
</div>}}{{#if:{{{languages|}}}|
<div class="marovi-infobox-links">
<div class="marovi-infobox-links-label">Languages</div>
<ul>{{#arraymap:{{{languages|}}}|,|@@item@@|<li>[[{{PAGENAME}}/@@item@@|@@item@@]]</li>|}}</ul>
</div>}}
</div>
</div></includeonly>

Template:Summary

2026-04-24T07:06:45Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
Displays an inline summary box at the top of an article or paper page.

== Usage ==
<pre>
{{Summary
|text=A concise summary of the article content.
|key_points=First key point; Second key point; Third key point
}}
</pre>

== Parameters ==
* '''text''' — Summary paragraph(s). Required.
* '''key_points''' — Semicolon-separated list of key takeaways. Optional.

[[Category:Marovi templates]]
</noinclude><includeonly><div class="marovi-summary">
<div class="marovi-summary-label">Summary</div>
<div class="marovi-summary-text">{{{text|}}}</div>{{#if:{{{key_points|}}}|
<ul class="marovi-summary-keypoints">{{#arraymap:{{{key_points|}}}|;|@@item@@|<li>@@item@@</li>|}}</ul>}}
</div></includeonly>

Template:Article

2026-04-24T07:06:44Z

DeployBot: [deploy-bot] Deploy template from PR #41 (v1.2.0)

<noinclude>
Displays an article metadata infobox on the right side of the page.

== Usage ==
<pre>
{{Article
|title=Stochastic Gradient Descent
|field=Machine Learning
|topics=Optimization, Neural Networks, Gradient Methods
|related_papers=Attention Is All You Need, BERT
|languages=es, zh
}}
</pre>

== Parameters ==
* '''title''' — Display title. Defaults to page name.
* '''field''' — Field of study.
* '''topics''' — Comma-separated list of topics (will be linked).
* '''related_papers''' — Comma-separated list of related paper page names.
* '''languages''' — Comma-separated ISO language codes with translations available.

[[Category:Marovi templates]]
</noinclude><includeonly><div class="marovi-infobox">
<div class="marovi-infobox-header">{{{title|{{PAGENAME}}}}}</div>
<div class="marovi-infobox-body">{{#if:{{{field|}}}|
<div class="marovi-infobox-row">
<span class="marovi-infobox-label">Field</span>
<span class="marovi-infobox-value">[[:Category:{{{field|}}}|{{{field|}}}]]</span>
</div>}}{{#if:{{{topics|}}}|
<div class="marovi-infobox-row">
<span class="marovi-infobox-label">Topics</span>
<span class="marovi-infobox-value"><span class="marovi-infobox-tags">{{#arraymap:{{{topics|}}}|,|@@item@@|<span class="marovi-infobox-tag">@@item@@</span>|}}</span></span>
</div>}}{{#if:{{{related_papers|}}}|
<div class="marovi-infobox-links">
<div class="marovi-infobox-links-label">Related Papers</div>
<ul>{{#arraymap:{{{related_papers|}}}|,|@@item@@|<li>[[@@item@@]]</li>|}}</ul>
</div>}}{{#if:{{{languages|}}}|
<div class="marovi-infobox-links">
<div class="marovi-infobox-links-label">Languages</div>
<ul>{{#arraymap:{{{languages|}}}|,|@@item@@|<li>[[{{PAGENAME}}/@@item@@|@@item@@]]</li>|}}</ul>
</div>}}
</div>
</div></includeonly>