第1章 深度学习概述

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

┌─────────────────────────────────────┐
│        人工智能（AI）                 │
│  ┌───────────────────────────────┐  │
│  │     机器学习（ML）              │  │
│  │  ┌─────────────────────────┐  │  │
│  │  │   深度学习（DL）          │  │  │
│  │  │                         │  │  │
│  │  │  神经网络                │  │  │
│  │  └─────────────────────────┘  │  │
│  └───────────────────────────────┘  │
└─────────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

## 输入层：原始数据
raw_data = [图片的像素值, 声音的波形, 文本的字符]

## 隐藏层：特征提取（抽象理解）
hidden_layer_1 = [边缘检测, 颜色分布, 纹理特征]  ## 低级特征
hidden_layer_2 = [眼睛, 鼻子, 耳朵]               ## 中级特征
hidden_layer_3 = [人脸, 猫脸, 狗脸]                ## 高级特征

## 输出层：最终结果
output = "这是一张人脸照片"

1
2
3
4
5
6

1980年代 ──── 2012年 ──── 2016年 ──── 2020年 ──── 2023年 ──── 2026年
   │           │           │           │           │           │
   ▼           ▼           ▼           ▼           ▼           ▼
 神经网络    AlexNet     AlphaGo     GPT-3      GPT-4/Gemini  具身智能
  诞生      图像识别     战胜李世石   大语言     多模态大模型   机器人爆发
           重大突破                  模型爆发                元年

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

                    ┌─────────────────┐
                    │   具身智能机器人  │
                    └────────┬────────┘
                             │
         ┌──────────────────┼──────────────────┐
         ▼                  ▼                  ▼
   ┌───────────┐    ┌───────────┐    ┌───────────┐
   │  计算机视觉 │    │   强化学习  │    │  自然语言  │
   │           │    │           │    │   处理     │
   │ 看世界：    │    │ 控制身体：  │    │ 理解指令：  │
   │ 识别障碍物、 │    │ 保持平衡、  │    │ 听懂"后空翻"│
   │ 判断距离    │    │ 规划动作   │    │ 与人对话   │
   └───────────┘    └───────────┘    └───────────┘
         ▼                  ▼                  ▼
   ┌───────────┐    ┌───────────┐    ┌───────────┐
   │  CNN模型   │    │ 强化学习   │    │ Transformer│
   │           │    │ 算法       │    │ 模型       │
   └───────────┘    └───────────┘    └───────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

## 通俗理解：深度学习在做什么
输入数据 = {
    '气象数据': ['昨天温度', '今天湿度', '明天降雨概率'],
    '人口流动': ['火车站客流', '机场人数', '地铁刷卡量'],
    '历史病例': ['去年同期发病数', '上周发病数', '附近城市发病数']
}

## 深度学习模型（时间序列分析）
模型任务 = "学习这些数据与疾病爆发的隐藏关系"

输出结果 = {
    '预警级别': '黄色预警',
    '高风险区域': ['XX区', 'YY街道'],
    '建议措施': '加强监测，准备疫苗'
}

1
2
3
4
5
6

【传统OCR】          【深度学习OCR】
   ↓                        ↓
只能识别清晰的        能识别磨损的、
标准印刷体            反光的、字体扭曲的标签
   ↓                        ↓
准确率低（50%）        准确率高（95%+）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

生物神经元                   人工神经元
    ↓                           ↓
┌─────────┐               ┌─────────┐
│  树突   │ ───接受信号→   │  输入   │  x1,x2,x3
└─────────┘               └─────────┘
    ↓                           ↓
┌─────────┐               ┌─────────┐
│  细胞体 │ ───处理信号→   │  加权求和│  w1*x1 + w2*x2 + ...
└─────────┘               └─────────┘
    ↓                           ↓
┌─────────┐               ┌─────────┐
│  轴突   │ ───输出信号→   │  激活函数│  f(加权和)
└─────────┘               └─────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import math

def simple_neuron(inputs, weights, bias):
    """
    一个最简单的神经元模型
    inputs: 输入值列表 [x1, x2, x3]
    weights: 权重列表 [w1, w2, w3]
    bias: 偏置项
    """
    ## 1. 加权求和
    weighted_sum = 0
    for x, w in zip(inputs, weights):
        weighted_sum += x * w
    weighted_sum += bias
    
    ## 2. 激活函数（这里用sigmoid）
    def sigmoid(x):
        return 1 / (1 + math.exp(-x))
    
    output = sigmoid(weighted_sum)
    return output

## 测试：判断是否应该带伞（输入：阴天、湿度、天气预报）
inputs = [1, 0.8, 0.6]  ## 阴天=1，湿度80%，降水概率60%
weights = [0.5, 0.3, 0.4]  ## 各个因素的重要性
bias = -0.2  ## 偏置项

result = simple_neuron(inputs, weights, bias)
print(f"神经元输出：{result:.4f}")
print(f"判断结果：{'带伞' if result > 0.5 else '不带伞'}")

1
2

神经元输出：0.6857
判断结果：带伞

1
2
3
4
5
6
7
8
9

识别一张人脸照片的过程：

第1层（低级特征）：看到横线、竖线、斜线、颜色块
        ↓
第2层（中级特征）：看到眼睛、鼻子、嘴巴的局部
        ↓
第3层（高级特征）：看到完整的人脸轮廓
        ↓
输出层：这是张三的脸，概率98%

1
2
3
4
5
6

理解一句话："今天下雨，所以我带了____"

RNN的过程：
看到"今天下雨" → 记住"下雨"这个信息
看到"所以我带了" → 结合之前的"下雨"信息
预测后面的词 → "伞"的概率最大

1
2
3
4

分析一句话："他昨天买了苹果，今天吃了香蕉"

CNN方式：只看局部"昨天买了苹果"和"今天吃了香蕉"
Transformer方式：同时看所有词，发现"他"既关联"买了"也关联"吃了"

1
2
3
4
5
6
7
8

## 伪代码：没有框架的痛苦
class MyNeuralNetwork:
    def __init__(self):
        ## 手动实现每一层的数学运算
        self.w1 = 随机初始化()
        self.b1 = 随机初始化()
        ## ... 还要实现反向传播、梯度下降、自动求导...
        ## 几百行代码后，还容易出错

1
2
3
4
5
6
7
8

## 有框架的快乐
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])
## 几行代码搞定！

1
2
3
4
5
6

【PyTorch的优势】
- 动态计算图：改代码就像改Python一样直观
- Debug方便：可以用print直接打印中间结果
- "Pythonic"：写起来就像写普通Python代码

比喻：PyTorch就像手动挡汽车，想怎么开就怎么开，适合赛车手（研究员）

1
2
3
4
5
6
7

【TensorFlow的优势】
- 静态计算图：编译后运行更快，适合生产环境
- 部署生态完善：Web、手机、嵌入式一条龙
- 模型版本管理：TensorFlow Serving 很方便
- 可视化：TensorBoard 很强大

比喻：TensorFlow就像自动挡汽车，虽然不能随心所欲，但稳定可靠，适合通勤（工业应用）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

## TensorFlow 2.x 最大的改进：官方集成了Keras
import tensorflow as tf

## 以前的TensorFlow（1.x）：写起来很复杂
## 现在的TensorFlow（2.x）：简单如Keras

model = tf.keras.Sequential([  ## 这就是Keras风格！
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

## 编译、训练都非常简单
model.compile(optimizer='adam', loss='categorical_crossentropy')

1
2
3

重要选项：
☑ Add Anaconda to my PATH environment variable（建议勾选）
☑ Register Anaconda as my default Python

1
2
3

## 打开命令行（CMD或PowerShell）
conda --version
## 应该显示：conda 23.x.x 或更高

1
2
3
4
5
6
7

## 创建名为tf_course的环境，Python版本3.9
conda create -n tf_course python=3.9 -y

## 激活环境
conda activate tf_course

## 看到提示符变成 (tf_course) 就成功了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

## 1. 先升级pip（避免安装问题）
python -m pip install --upgrade pip

## 2. 安装TensorFlow（CPU版本，适合大多数学生）
pip install tensorflow -i https://pypi.tuna.tsinghua.edu.cn/simple

## 3. 安装常用辅助库
pip install matplotlib pandas numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

## 4. 验证安装
python -c "import tensorflow as tf; print(tf.__version__)"

1
2
3
4

## 方法1：永久配置清华源
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

## 方法2：每次临时使用（已经用-i参数实现）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

## 先确认是否有显卡：打开任务管理器 -> 性能 -> GPU
## 如果有NVIDIA显卡，安装GPU版本（需要先安装CUDA和cuDNN）

## 步骤1：检查显卡驱动是否支持
nvidia-smi  ## 查看CUDA版本要求

## 步骤2：安装GPU版本TensorFlow
pip install tensorflow[and-cuda]  ## TensorFlow 2.15+ 支持自动安装CUDA

## 或者手动指定
pip install tensorflow-gpu -i https://pypi.tuna.tsinghua.edu.cn/simple

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

"""
TensorFlow 版本演进（了解即可）
--------------------------------
TensorFlow 1.x (2015-2019): 静态图，写起来复杂，需要session.run()
TensorFlow 2.x (2019-现在): 动态图，默认开启Eager Execution，集成Keras

本课程使用：TensorFlow 2.15+ (2024-2026最新稳定版)
特点：
- 默认开启Eager Execution（像PyTorch一样直观）
- Keras作为官方高级API（写代码超简单）
- 性能优化，内存占用更小
"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

"""
文件名：check_tf_env.py
功能：验证TensorFlow环境是否安装成功
"""

import sys
import platform

print("=" * 60)
print("TensorFlow 深度学习环境检查工具")
print("=" * 60)

## 1. 检查Python版本
print(f"\n✅ Python版本: {sys.version.split()[0]}")
print(f"✅ 操作系统: {platform.system()} {platform.release()}")

## 2. 尝试导入TensorFlow
try:
    import tensorflow as tf
    print(f"\n✅ TensorFlow版本: {tf.__version__}")
    
    ## 检查Keras（TensorFlow的高级API）
    print(f"✅ Keras版本: {tf.keras.__version__}")
    
    ## 检查是否有GPU
    gpus = tf.config.list_physical_devices('GPU')
    if gpus:
        print(f"✅ GPU可用: {len(gpus)} 个")
        for i, gpu in enumerate(gpus):
            print(f"   - GPU {i}: {gpu.name}")
    else:
        print("ℹ️ 使用CPU进行计算（没有检测到GPU）")
    
    ## 简单测试：创建张量
    hello = tf.constant('Hello, TensorFlow!')
    print(f"\n✅ 测试张量: {hello.numpy().decode()}")
    
    ## 测试基本运算
    a = tf.constant(5)
    b = tf.constant(3)
    c = a + b
    print(f"✅ 基本运算: 5 + 3 = {c.numpy()}")
    
except ImportError as e:
    print(f"\n❌ TensorFlow导入失败: {e}")
    print("请检查是否已安装或在正确的虚拟环境中")
    print("安装命令: pip install tensorflow")

## 3. 检查其他常用库
libraries = {
    'numpy': 'np',
    'pandas': 'pd',
    'matplotlib': 'plt'
}

print("\n" + "-" * 40)
print("检查辅助库:")
for lib_name, alias in libraries.items():
    try:
        lib = __import__(lib_name)
        version = getattr(lib, '__version__', '未知')
        print(f"✅ {lib_name} 版本: {version}")
    except ImportError:
        print(f"❌ {lib_name} 未安装")

print("\n" + "=" * 60)
print("环境检查完成！")
print("=" * 60)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

============================================================
TensorFlow 深度学习环境检查工具
============================================================

✅ Python版本: 3.9.13
✅ 操作系统: Windows 10

✅ TensorFlow版本: 2.15.0
✅ Keras版本: 2.15.0
ℹ️ 使用CPU进行计算（没有检测到GPU）

✅ 测试张量: Hello, TensorFlow!
✅ 基本运算: 5 + 3 = 8

----------------------------------------
检查辅助库:
✅ numpy 版本: 1.24.3
✅ pandas 版本: 2.0.3
✅ matplotlib 版本: 3.7.2

============================================================
环境检查完成！
============================================================

1
2
3
4
5

## 解决方案：使用国内镜像
pip install tensorflow -i https://pypi.tuna.tsinghua.edu.cn/simple

## 永久配置
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

## 解决方案
## 1. 检查是否在正确的虚拟环境中
conda activate tf_course

## 2. 确认是否安装
pip list | findstr tensorflow  ## Windows
pip list | grep tensorflow      ## Mac/Linux

## 3. 如果没安装，重新安装
pip install tensorflow

1
2
3
4
5
6
7
8
9

## 错误：还在用TensorFlow 1.x的方式
## sess = tf.Session()  ## ❌ 旧版写法

## 正确：TensorFlow 2.x默认Eager Execution
import tensorflow as tf
a = tf.constant(5)
b = tf.constant(3)
c = a + b
print(c.numpy())  ## ✅ 直接输出8

1
2
3

## 如果遇到版本冲突，可以指定版本安装
pip install tensorflow==2.15.0
pip install numpy==1.24.3  ## TensorFlow 2.15兼容的numpy版本

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

## 解决方案：限制TensorFlow内存使用
import tensorflow as tf

## 限制GPU内存使用（如果有GPU）
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    try:
        for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
        ## 或者限制固定内存
        ## tf.config.set_logical_device_configuration(
        ##     gpus[0],
        ##     [tf.config.LogicalDeviceConfiguration(memory_limit=2048)]
        ## )
    except RuntimeError as e:
        print(e)

## CPU模式下减少batch size
## model.fit(x_train, y_train, batch_size=32)  ## 如果内存不够，改小batch_size

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

┌─────────────────────────────────────────────────────────┐
│                    第1章 深度学习概述                     │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  1. 什么是深度学习？                                      │
│      ├─ 从AI到ML再到DL：俄罗斯套娃关系                      │
│      ├─ 三层结构：输入层→隐藏层→输出层                       │
│      └─ 火起来的原因：数据+算力+算法                        │
│                                                         │
│  2. 能做什么？                                           │
│      ├─ 案例1：具身智能机器人（2026年最火）                  │
│      ├─ 案例2：AI疾控预警（守护健康）                       │
│      └─ 案例3：电子垃圾分拣（守护地球）                      │
│                                                         │
│  3. 常见模型                                             │
│      ├─ CNN：图像专家，看局部特征                           │
│      ├─ RNN：序列专家，有记忆                              │
│      └─ Transformer：全能学霸，全局视野                     │
│                                                         │
│  4. 框架对比：TensorFlow vs PyTorch                       │
│      ├─ TensorFlow：Google开发，工业界主流，部署方便         │
│      ├─ PyTorch：Meta开发，学术界常用，调试灵活              │
│      └─ 本课程选择TensorFlow的原因                          │
│                                                         │
│  5. 环境搭建（TensorFlow版）                               │
│      ├─ Anaconda：管理环境和包                            │
│      ├─ TensorFlow：本课程深度学习框架                      │
│      └─ 第一个程序：线性回归（TensorFlow Hello World）       │
│                                                         │
└─────────────────────────────────────────────────────────┘