当前位置：首页 > news >正文

TensorFlow学习入门

news 2025/10/27 9:07:25

TensorFlow的发展历程

Google 主导开发的开源机器学习框架，其发展历程围绕 “技术迭代、生态扩张、应对竞争” 三大核心主线，从内部工具逐步成长为支撑全球工业级 AI 应用与科研创新的综合性平台。

以下是其关键发展阶段与里程碑事件：

起源与雏形（2009-2015）：从内部工具到开源发布

前身 DistBelief（2009-2011）：
TensorFlow 的技术根源可追溯至 2009 年 Geoffery Hinton 带领团队开发的 DistBelief 项目，这是 Google Brain 内部用于深度神经网络训练的专有系统。该系统实现了广义反向传播算法，使 Google 内部语音识别错误率降低 25%，并广泛应用于搜索、广告等核心业务，但未对外开源。

重构与更名（2011-2015）：
由于 DistBelief 扩展性不足，Google 调动 Jeff Dean 等顶尖工程师对其重构，目标是打造更稳健、通用、支持多平台的工业级框架。重构后的框架基于 “计算图 + 张量流动” 的核心设计，命名为 “TensorFlow”（意为 “张量在计算图中的流动”）。

开源发布（2015.11）：
Google 正式发布 TensorFlow 0.1 版本及白皮书，以 Apache 2.0 许可证开源。初期版本支持 CPU/GPU 异构计算、分布式训练，且可部署于 iOS/Android 等移动设备，凭借 Google 的技术背书迅速引发行业关注。

静态图时代的崛起与垄断（2015-2019）：1.x 系列奠定工业级地位

关键版本迭代：
2016.4：发布 0.8 版本，正式支持分布式训练，在 100 个 GPU 上仅用 65 小时完成图像分类训练，正确率达 78%，标志着其具备大规模产业应用能力。
2016.6：0.9 版本新增 iOS 平台支持，开启多终端部署布局。
2017.2：发布 1.0 稳定版，核心改进包括性能优化、引入 tf.layers/tf.metrics 高级 API、兼容 Keras 框架，同时保障 Python API 稳定性，大幅降低企业开发门槛。

生态扩张与行业垄断：
2017.12：联合 Cisco、Red Hat 等推出 Kubeflow，简化 TensorFlow 在 Kubernetes 上的部署与运维，强化企业级支持。
这一阶段，TensorFlow 凭借静态计算图的高效优化、完善的文档与工业级工具链，成为 GitHub 最受欢迎的开源 AI 框架，占据市场主导地位，广泛应用于 Google 搜索引擎、自动驾驶等核心业务，以及全球企业的 AI 生产系统。

潜在危机：
1.x 系列的静态图模式需先定义计算图再执行，调试难度大；API 设计繁杂、稳定性不足，为后续 PyTorch 的崛起留下空间。

动态图转型与生态完善（2019 至今）：2.x 系列应对竞争与全场景覆盖

2.0 版本的革命性升级（2019.10）：
核心变化：引入 Eager Execution 即时执行模式，支持动态图编程，解决了 1.x 调试困难的痛点；将 Keras 设为官方默认高层 API，统一模型构建接口，大幅提升易用性。
性能与兼容性：优化分布式训练效率，支持混合精度训练；保持对 1.x 代码的向下兼容，降低用户迁移成本。
行业反响：被称为 “新时代机器学习平台”，吸引 PyTorch 生态用户回流，成为科研与工业的双重选择。

生态系统全面扩张：
端侧部署：
TensorFlow Lite 成熟，支持移动设备、边缘设备（如物联网终端）的模型压缩与高效推理
应用于三星 Galaxy 手机 AI 相机、特斯拉 Autopilot 实时目标检测等场景。

全流程工具链：
TensorFlow Extended（TFX）提供数据预处理、模型训练、部署、监控的端到端企业级流水线
TensorFlow.js 支持浏览器端 AI 应用开发，TensorFlow Probability 拓展概率编程场景

大模型支持：
优化对大规模预训练模型的支持，Google 曾用 TensorFlow 在 16,000 个 TPU 上训练出 1.6 万亿参数的 Switch Transformer
适配大模型时代的训练与部署需求

持续迭代与行业共生：
版本更新：2021 年发布 2.4.1 稳定版，后续持续优化性能、修复漏洞，保持框架稳定性
竞争与互补：与 PyTorch 形成 “双雄并立” 格局，TensorFlow 仍以工业级部署能力、多平台兼容性为核心优势，PyTorch 则在科研快速迭代场景更具优势，行业逐渐形成 “PyTorch 研发、TensorFlow 部署” 的混合架构模式

eager ˈiːɡə(r) 热切的，渴望的，渴求的
pilot ˈpaɪlət 飞行员；领航员；（船只的）领航员；（电视）试播节目；常燃小火；航海手册；<非正式>职业骑师；<古>向导；（火车头前端的）排障器

发展核心逻辑总结

TensorFlow 的历程本质是 “技术适配需求” 的演进：
从内部工具 DistBelief 满足 Google 自身大规模训练需求，到 1.x 系列以静态图占领工业级市场，再到 2.x 系列以动态图转型应对科研用户需求，最终形成 “科研 - 生产 - 端侧” 全场景覆盖的生态体系

其核心竞争力始终围绕 “兼容性（多平台、多硬件）、效率（分布式、性能优化）、易用性（API 统一、调试友好）” 三大维度，成为 AI 技术从实验室走向产业落地的关键基础设施

TensorFlow的概念

张量（Tensor）

张量是 TensorFlow 中数据的基本单位，可理解为 “多维数组”，用于表示数据的维度和数值
维度（阶数）：

0 维是标量（如 3.14）
1 维是向量（如 [1, 2, 3]）
2 维是矩阵（如 [[1,2],[3,4]]）
更高维则是多维数组（如图片的 [height, width, channels]）

动态形状与静态形状：
静态形状是创建时定义的维度（可能部分未知），动态形状是运行时实际的维度

计算图（Computational Graph）

计算图是 TensorFlow 中 “定义计算流程” 的抽象表示，是 TensorFlow 所有运算的 “骨架”
由节点（Nodes）和边（Edges）组成有向无环图（DAG）：

节点：表示操作（如加法、矩阵乘法、激活函数等）
边：表示节点之间的数据流动（即张量）

特点：
定义与执行分离：先定义图（“构建阶段”，即运算逻辑），再通过会话执行图中的操作（“运行阶段”，即执行计算）
可优化：图可被自动优化（如并行计算、内存复用），适合分布式训练

注意：
TensorFlow 2.x 虽支持动态图，但底层仍依赖计算图优化

核心优势：

并行化与分布式支持：计算图可自动分析独立节点（无依赖关系的运算），将其分配到不同设备或进程中并行执行，是大规模深度学习（如千亿参数模型）的基础
可移植性：定义好的计算图可序列化（如保存为 .pb 文件），无需依赖原代码，直接在服务器、移动端、嵌入式设备上部署（如 TensorFlow Lite）

会话（Session）

会话是执行计算图的环境，负责分配资源（如 CPU/GPU）并运行操作
作用：将计算图的节点在具体设备上执行，返回张量的实际值
示例（旧版 TensorFlow 1.x）：

import tensorflow as tf
a = tf.constant(2)
b = tf.constant(3)
c = a + b
with tf.Session() as sess:print(sess.run(c))  # 输出 5

注意：TensorFlow 2.x 已默认启用 “即时执行（Eager Execution）”，无需显式会话，更接近 Python 原生语法

变量（Variable）

变量是用于存储和更新模型参数（如权重、偏置）的张量，在训练过程中会被持续修改
必须初始化后才能使用（2.x 中可自动初始化），常通过 tf.Variable() 创建
示例：

w = tf.Variable(tf.random.normal([3, 2]))  # 初始化一个 3x2 的随机矩阵作为权重

Variable是TensorFlow的一种特殊Tensor，用来表示可训练参数

占位符（Placeholder，TF1.x）

TF1.x 中用于 “预留输入数据的位置”，运行时通过 feed_dict 传入实际数据，类似函数的参数
TF2.x 因即时执行机制，已移除占位符，直接使用 Python 变量即可

Placeholder是TensorFlow的一种特殊Tensor，用来表示输入数据
Placeholder可以在Graph中定义，然后在Session中传递实际的输入数据

操作（Operation，Op）

计算图中的节点即为操作，代表一种具体的计算（如加减乘除、卷积、池化、激活函数等）
操作可以接收张量作为输入，输出新的张量

自动微分（Automatic Differentiation）

深度学习的核心是通过梯度下降最小化损失函数（如 MSE、交叉熵），而梯度计算的效率直接决定训练速度
TensorFlow 无需手动推导导数公式，而是通过反向模式自动微分（Reverse-Mode Autodiff）高效计算所有参数的梯度，这是其支持复杂模型（如 CNN、Transformer）训练的关键

differentiation ˌdɪfəˌrenʃiˈeɪʃn 区分，差异化
gradient ˈɡreɪdiənt （尤指道路或铁路的）斜坡，坡度；（温度或压力变化的）梯度；（数学）斜率；梯度，梯度率；（数学）梯度算子

TensorFlow 提供自动计算导数的机制，是反向传播（训练神经网络的核心）的基础
通过 tf.GradientTape 记录计算过程，再求解梯度：

x = tf.Variable(3.0)
with tf.GradientTape() as tape:y = x **2
dy_dx = tape.gradient(y, x)  # 求 y 对 x 的导数，结果为 6.0

自动微分的原理：“计算图反向遍历”

自动微分的本质是 “链式法则” 的工程化实现，分为前向传播（Forward Pass）和反向传播（Backward Pass）两步
在这里插入图片描述

数据集（Dataset）

用于高效处理输入数据的 API，支持批量读取、预处理（如打乱、映射）、迭代等，适合大规模数据

dataset = tf.data.Dataset.from_tensor_slices([1, 2, 3, 4])
for element in dataset:print(element.numpy())  # 输出 1,2,3,4

模型（Model）与层（Layer）

层（Layer）是神经网络的基本组件，封装了一组操作和变量（如 Dense 全连接层、Conv2D 卷积层）
模型（Model）由多个层组合而成，通过 tf.keras.Model 或 tf.keras.Sequential 构建，提供训练（fit）、评估（evaluate）等接口

高效执行的核心：计算优化与设备调度

TensorFlow 能支撑大规模模型训练（如 GPT、BERT），关键在于底层的计算优化和跨设备调度能力，核心依赖以下技术：

计算优化：减少冗余运算

算子融合（Operator Fusion）：
将多个独立小运算（如 “加法 + 激活函数”、“卷积 + 批归一化”）融合为一个大算子，减少内存读写开销（内存访问速度远慢于计算速度）
例如，tf.nn.relu(tf.add(x, b)) 会被融合为一个 加法 - relu 算子

常量折叠（Constant Folding）：
在图编译阶段，提前计算所有常量参与的运算（如 2+3、W·常量矩阵），将结果存储为常量，避免 runtime 重复计算

稀疏计算优化：
对稀疏张量（如自然语言处理中的 one-hot 向量）提供专用算子（如 tf.sparse.matmul），仅计算非零元素，减少计算量

设备调度，充分利用硬件资源，支持自动将计算图分配到 CPU、GPU、TPU 等设备执行，核心通过 tf.device() 或自动设备 placement 实现

GPU 加速：将矩阵乘法、卷积等计算密集型运算分配到 GPU（并行计算能力远超 CPU），而数据预处理、控制逻辑等分配到 CPU
多 GPU 分布式训练：通过 tf.distribute.MirroredStrategy 等策略，将模型参数复制到多个 GPU，每个 GPU 处理不同批次的数据（数据并行），大幅提升训练速度
TPU 支持：针对谷歌 TPU（专用深度学习芯片）优化算子，支持超大规模模型的高效训练（如 TPU v4 支持千亿参数模型的训练）

附录

什么是 TPU

TPU（Tensor Processing Unit，张量处理单元）是由谷歌（Google）专为加速人工智能（AI）和机器学习（ML）任务设计的专用集成电路（ASIC），核心定位是高效处理 “张量”（机器学习中数据运算的核心格式），尤其针对深度学习模型的训练与推理场景优化。

TPU 的核心定位：为 “深度学习” 而生
传统通用处理器（如 CPU、GPU）虽能处理 AI 任务，但存在 “通用性与 AI 效率失衡” 的问题

CPU 擅长复杂逻辑控制但并行计算能力弱
GPU 虽提升了并行性但仍需兼容图形渲染等非 AI 任务
TPU 则是 “量身定制” 的 AI 加速器，所有硬件设计都围绕深度学习的核心需求展开

核心处理对象：张量（Tensor），即多维数组（如图片数据的 “宽 × 高 × 通道数”、文本数据的 “序列长度 × 嵌入维度”），这是深度学习中数据存储和运算的基本单位

核心优化场景：深度学习的两大核心环节
推理（Inference）：用训练好的模型对新数据做预测（如手机拍照识别、语音助手理解指令），需低延迟、高吞吐量
训练（Training）：用海量数据迭代优化模型参数（如训练 GPT、图像生成模型），需超高并行计算能力和大内存带宽

图片的Channel

图片数据中，“通道”（Channel）是指图像中存储特定类型信息的独立数据层：

颜色通道：
最常见的彩色图像通常由三个颜色通道组成，即红色（R）、绿色（G）和蓝色（B）。
每通道是一个二维矩阵，矩阵中每个元素（像素）是一个 8 位无符号整数，通常范围 0~255，表示该位置对应颜色强度
当这三个通道组合在一起时，就形成了看到的彩色图像
例如，纯红色的像素在红色通道的值为 255，在绿色和蓝色通道的值为 0，即 (255, 0, 0)

Alpha 通道：
用于存储透明度信息，常见于 RGBA 图像格式中
Alpha 通道的值通常也是 0~255，其中 0 表示全透明，255 表示不透明
例如，(255, 0, 0, 128) 表示半透明的红色

深度通道：
存储每个像素的深度信息，如在 3D 图像中，用于表示像素点在三维空间中的位置信息

多光谱或高光谱通道：
在卫星图像、医学影像等领域，图像可能包含多个波段，每个波段都可以被视为一个通道
例如，Landsat 卫星图像可能包含 11 个波段，即 11 个通道，每个波段捕捉不同波长的光，提供不同的地物信息。

文本数据的 “序列长度 × 嵌入维度”

在文本数据的向量表示（尤其是深度学习处理场景，如 Transformer、RNN）中，“序列长度 × 嵌入维度” 是描述文本向量矩阵的核心维度，两者分别对应文本的 “时序 / 数量特征” 和 “语义 / 特征维度”，共同构成计算机可理解的文本数值形式。

第一个维度：序列长度（Sequence Length）——“文本有多少个基本单位”

序列长度（通常用 L 表示）描述的是：将文本拆分为 “基本语义单元” 后，单元的总数量，本质是文本的 “长度尺度”

核心定义：文本的 “离散化单元数”
计算机无法直接处理连续的文本字符串，必须先将文本拆分为最小的、可独立编码的 “基本单元”（称为 “token”）
序列长度就是这些 token 的总数

常见的 token 类型包括：
字（Character）：以单个汉字 / 字母为单位（如 “我爱 NLP” 拆分为【我、爱、N、L、P】，序列长度 = 5）
词（Word）：以完整词汇为单位（如 “我爱 NLP” 拆分为【我、爱、NLP】，序列长度 = 3）
子词（Subword）：介于字和词之间的单位（如英文 “unhappiness” 拆分为【un、happy、ness】，解决生僻词 / 未登录词问题，是 BERT、GPT 等模型的默认选择）

关键作用：定义文本的 “时序范围”
深度学习模型中，序列长度决定了模型需要 “处理多少个连续的 token”，比如：

RNN 会按序列长度逐个 token 传递信息
Transformer 的自注意力机制会计算 “序列长度 × 序列长度” 的注意力矩阵（每个 token 与其他所有 token 的关联）

注意点：序列长度的统一化
真实文本的长度是不固定的（如一条短评可能 10 个词，一篇文章可能 1000 个词），因此在模型训练前必须做长度统一：

短文本：用 “填充符（Padding，如 [PAD]）” 补到指定长度
长文本：截断（Truncation）到指定长度（如 BERT 默认最大序列长度为 512，超过则截断）

第二个维度：嵌入维度（Embedding Dimension）——“每个基本单位有多少个特征”

嵌入维度（通常用 D 表示）描述的是：
每个 token 被编码成的 “数值向量的维度数”，本质是 token 的 “语义特征丰富度”
维度越高，理论上能承载的语义信息越细

核心定义：token 的 “语义向量维度”
自然语言中的每个 token（如 “猫”“狗”“开心”）都有其语义（比如 “猫” 关联 “哺乳动物、宠物、有毛” 等特征）
嵌入维度就是用 “多少个数值特征” 来量化这些语义
例如：
若嵌入维度 = 3，“猫” 可能被编码为 [0.2, 0.8, -0.1]，其中每个数值代表一个抽象的语义特征
如第一个数值可能对应 “是否为宠物”，第二个对应 “是否为哺乳动物”
关键作用：决定语义的 “区分度”
嵌入维度过低（如 D=2）：不同 token 的向量容易重叠（比如 “猫” 和 “狗” 的向量几乎一样），模型无法区分语义
嵌入维度过高（如 D=1000）：虽然语义区分度高，但会导致模型参数爆炸（计算量剧增），还可能引发过拟合
常见取值：行业默认经验
不同模型的嵌入维度有默认设计，本质是 “语义需求” 与 “计算成本” 的平衡：

轻量级模型（如 TextCNN）：D=128~256
通用预训练模型（如 BERT-base）：D=768
大模型（如 BERT-large/GPT-3）：D=1024~4096（维度越高，需要的训练数据和计算资源越多）

“序列长度 × 嵌入维度” 的矩阵含义

当文本被编码为向量时，最终会形成一个 L 行 × D 列的矩阵（或三维张量，批量处理时为【批量大小，L, D】）

假设处理句子 “我喜欢深度学习”：
第一步：分词（确定序列长度 L）拆分为 token：【我、喜欢、深度、学习】→ L=4（序列长度 = 4）
第二步：嵌入编码（确定嵌入维度 D）假设选择 D=5（每个 token 用 5 维向量表示），编码后每个 token 的向量如下：

“我”：[0.12, 0.34, -0.05, 0.21, 0.56]
“喜欢”：[0.78, -0.23, 0.45, -0.11, 0.33]
“深度”：[-0.09, 0.67, 0.22, -0.34, 0.18]
“学习”：[0.51, -0.17, 0.38, 0.49, -0.02]

最终矩阵：4 行 × 5 列这个矩阵就是计算机可处理的文本表示

其中：
每一行：对应一个 token 的语义向量（嵌入维度 D=5 承载的语义特征）
每一列：对应所有 token 在 “某一个语义维度” 上的特征值（如第 2 列可能统一代表 “情感倾向”）

前向传播（算结果）和反向传播（调参数）

前向传播：算出模型的预测值和损失

想象要做一个 “预测房价” 的简单模型
模型的公式是预测房价 y = 权重W × 房屋面积x + 偏置b
损失 L是用来衡量 “预测房价和真实房价y_true的差距”，这里用的是 L = (y - y_true)²（差距的平方，差距越大损失越大）

前向传播就是一步步计算出 y 和 L，并把中间用到的 W、x、b、y 都记下来：
第一步：用当前的 W、x、b 算出 y = W·x + b（比如 W 是 10，x 是 50，b 是 200，那 y=10×50+200=700）
第二步：用算出的 y 和真实房价y_true（比如真实房价是 750）算出损失L = (700-750)² = 2500
同时，把 W、x、b、y 这些数值都 “保存下来”，后面反向传播要用

反向传播：调整参数让损失变小

反向传播核心是找出 “每个参数（W 和 b）对损失 L 的影响程度”（即梯度），调整参数来降低损失，这个过程靠链式法则和梯度下降实现。
以刚才的例子（y=700，y_true=750，x=50）来一步步看：

步骤 1：算 “损失 L 对预测值 y 的梯度”（∂L/∂y）
梯度可以理解为 “L 对 y 的变化有多敏感”。对 L = (y - y_true)² 求导，得到 ∂L/∂y = 2·(y - y_true)
代入数值：∂L/∂y = 2×(700-750) = -100

步骤 2：算 “预测值 y 对每个参数的梯度”（∂y/∂W、∂y/∂b）
因为y = W·x + b，所以：
对 W 求导：∂y/∂W = x（比如 x 是 50，所以∂y/∂W=50）
对 b 求导：∂y/∂b = 1（因为 b 的系数是 1）

步骤 3：用链式法则算 “损失 L 对每个参数的梯度”（∂L/∂W、∂L/∂b）
链式法则的逻辑是：“L 对 W 的影响” = “L 对 y 的影响” × “y 对 W 的影响”
对 W 的梯度：∂L/∂W = ∂L/∂y × ∂y/∂W = (-100)×50 = -5000
对 b 的梯度：∂L/∂b = ∂L/∂y × ∂y/∂b = (-100)×1 = -100

步骤 4：用梯度下降更新参数（让损失变小）
梯度下降的逻辑是 “参数往梯度的反方向调整”（因为梯度是 “上升最快的方向”，反方向就是 “下降最快的方向”，能让损失 L 变小）
调整的幅度由学习率 lr（可以理解为 “每一步迈多大步”）控制
假设学习率 lr 是 0.001，那么：
W 的更新：W = W - lr×∂L/∂W（比如原来 W 是 10，那新 W=10 - 0.001×(-5000)=10+5=15）
b 的更新：b = b - lr×∂L/∂b（比如原来 b 是 200，那新 b=200 - 0.001×(-100)=200+0.1=200.1）
更新后，下一次前向传播时，用新的 W 和 b 计算 y，损失 L 就会更接近 0（预测更准确）

学习率 lr ：
直接沿着梯度反方向调整，步子可能太大（导致震荡）或太小（收敛太慢）
学习率 lr 是用来控制 “调整幅度” 的超参数，它决定了每一步参数更新的 “步长”

总结

前向传播是 “从输入到输出算结果”，反向传播是 “从输出往回算参数的调整方向，然后更新参数”，两者循环进行，直到模型预测足够准确

稀疏张量

sparsity ˈspɑːsətɪ 稀疏，稀少；贫乏
indices ˈɪndɪsiːz 指数、目录、索引（es）

稀疏性（Sparsity）：“大部分元素为 0” 的特性
对于一个张量，若其绝大多数元素的值为 0，仅有极少数非零元素，则称该张量具有 “稀疏性”
反之，若大部分元素非零，则称为 “稠密张量（Dense Tensor）”

稀疏性的核心衡量指标是稀疏度：稀疏度 = 1 - (非零元素数量 / 总元素数量)
例如，一个长度为 10000 的 One-Hot 向量（仅 1 个 1，其余 9999 个 0），其稀疏度为 1 - 1/10000 = 99.99%，属于极高稀疏性

稀疏张量的存储与处理：为何不能直接存 “全量 0”？
由于稀疏张量的 0 元素占比极高，若按 “稠密张量” 的方式存储（即保存所有元素），会造成巨大的内存浪费（例如 10 万维的 One-Hot 向量，需存 10 万个浮点数，其中 99999 个是 0）
因此，稀疏张量通常采用 非零元素 + 位置索引 的压缩存储格式，主流格式包括：

COO（Coordinate Format，坐标格式）：存储 3 个列表 ——values（非零元素的值）、row_indices（非零元素的行索引）、col_indices（非零元素的列索引），适合高维稀疏矩阵
CSR（Compressed Sparse Row，行压缩格式）：先按行分组，存储values（非零值）、col_indices（列索引）、row_ptr（每行第一个非零元素在values中的起始位置），适合行优先的计算（如矩阵乘法）
LIL（List of Lists，列表格式）：每行存储一个列表（包含该行的非零元素列索引和值），适合动态修改稀疏张量（如构建词袋矩阵时）

损失函数 - Loss Function

在机器学习和深度学习中，最小化损失函数是模型训练的核心目标
损失函数（Loss Function）衡量模型预测值与真实值之间的差异
最小化损失本质是通过调整模型参数，让这种差异尽可能小，从而提升模型的预测能力

损失函数的值越小，说明模型的预测结果与真实情况越接近，泛化能力（对新数据的预测能力）可能越强（需避免过拟合）
例如：用线性回归预测房价时，若预测值与真实房价的平均误差（MSE）从 100 万降到 10 万，说明模型对房价的估计更准确

常见的损失函数

均方误差（Mean Squared Error, MSE）：适用于回归任务

squared skweəd 方格的；成正方形的；带有方格图案的；使成正方形；求平方值；挺直身子；打成平局；贿赂，收买
在这里插入图片描述
回归任务的目标是预测连续值（如房价、温度），MSE 衡量预测值与真实值的平方差的平均值

对 outliers（异常值）敏感（平方会放大误差），适合数据较干净的场景
数学性质好（连续、可导），便于用梯度下降等方法优化

交叉熵（Cross-Entropy）：适用于分类任务

entropy ˈentrəpi 熵
stochastic stɒˈkæstɪk [数] 随机的；猜测的
categorical ˌkætəˈɡɒrɪk(ə)l 绝对的（名词categoricalness，副词categorically，异体字categoric）；直截了当的；无条件的；属于某一范畴的
momentum məˈmentəm 冲力，推力；动力，势头；动量，冲量
η 伊塔

分类任务的目标是预测离散标签（如 “猫 / 狗”“垃圾邮件 / 正常邮件”），交叉熵衡量两个概率分布（真实标签分布与模型预测的概率分布）的差异，分为二分类和多分类两种形式：

在这里插入图片描述