Update deeplearning.md

ml/deeplearning.md

@@ -1,4 +1,3 @@
-
 ## 深度学习
 
 
@@ -20,158 +19,6 @@
 - **优化器**：根据损失函数的梯度更新神经网络的权重，以最小化损失。常见的优化器有随机梯度下降（SGD）、Adam、RMSProp 等。
 
 
-# 二、深度学习框架
-目前有许多深度学习框架可供选择，以下是几个常用的：
-- **TensorFlow**：由 Google 开发，功能强大且灵活，提供了从简单到复杂的各种深度学习模型的实现。
-- **PyTorch**：以其动态计算图和易于使用的接口而受到欢迎，特别适合研究和开发。
-- **Keras**：一个高级的神经网络 API，可以在 TensorFlow 或 Theano 上运行，提供了简洁的接口，适合快速开发。
-
-
-# 三、深度学习入门步骤
-
-## （一）环境搭建
-以下是使用 PyTorch 搭建深度学习环境的示例：
-```bash
-pip install torch torchvision torchtext
-```
-
-
-## （二）数据准备
-深度学习的第一步是准备数据。以图像分类任务为例，我们可以使用 `torchvision` 中的 `MNIST` 数据集。
-```python
-import torch
-import torchvision
-import torchvision.transforms as transforms
-
-# 定义数据预处理
-transform = transforms.Compose(
-    [transforms.ToTensor(),
-     transforms.Normalize((0.5,), (0.5,))]
-)
-
-# 下载训练集和测试集
-trainset = torchvision.datasets.MNIST(root='./data', train=True,
-                                download=True, transform=transform)
-trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
-                                    shuffle=True, num_workers=2)
-
-testset = torchvision.datasets.MNIST(root='./data', train=False,
-                               download=True, transform=transform)
-testloader = torch.utils.data.DataLoader(testset, batch_size=64,
-                                   shuffle=False, num_workers=2)
-```
-- **解释**：
-  - `transforms.ToTensor()` 将图像转换为 PyTorch 的 `Tensor` 类型。
-  - `transforms.Normalize((0.5,), (0.5,))` 对数据进行标准化，使其范围在 -1 到 1 之间。
-  - `torch.utils.data.DataLoader` 用于将数据集封装为可迭代的数据加载器，便于批量处理。
-
-
-## （三）构建神经网络
-下面是一个简单的全连接神经网络的 PyTorch 实现：
-```python
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class SimpleNet(nn.Module):
-    def __init__(self):
-        super(SimpleNet, self).__init__()
-        self.fc1 = nn.Linear(28 * 28, 128)  # 输入层到第一个隐藏层
-        self.fc2 = nn.Linear(128, 64)    # 第一个隐藏层到第二个隐藏层
-        self.fc3 = nn.Linear(64, 10)     # 第二个隐藏层到输出层
-
-    def forward(self, x):
-        x = x.view(-1, 28 * 28)  # 将图像展平
-        x = F.relu(self.fc1(x))  # 第一个隐藏层，使用 ReLU 激活函数
-        x = F.relu(self.fc2(x))  # 第二个隐藏层，使用 ReLU 激活函数
-        x = self.fc3(x)        # 输出层
-        return x
-
-
-net = SimpleNet()
-```
-- **解释**：
-  - `nn.Linear` 表示全连接层。
-  - `forward` 方法定义了数据的前向传播路径，将输入通过各层和激活函数。
-
-
-## （四）定义损失函数和优化器
-选择合适的损失函数和优化器：
-```python
-import torch.optim as optim
-
-criterion = nn.CrossEntropyLoss()
-optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
-```
-- **解释**：
-  - `nn.CrossEntropyLoss()` 用于多分类任务。
-  - `optim.SGD` 是随机梯度下降优化器，`lr` 是学习率，`momentum` 可以加速收敛。
-
-
-## （五）训练模型
-以下是训练网络的代码：
-```python
-# 训练周期
-epochs = 10
-
-for epoch in range(epochs):
-    running_loss = 0.0
-    for i, data in enumerate(trainloader, 0):
-        inputs, labels = data
-        # 清零梯度
-        optimizer.zero_grad()
-
-        # 前向传播
-        outputs = net(inputs)
-        loss = criterion(outputs, labels)
-
-        # 反向传播和优化
-        loss.backward()
-        optimizer.step()
-
-        running_loss += loss.item()
-        if i % 200 == 199:
-            print(f'Epoch {epoch + 1}, Batch {i + 1}, Loss: {running_loss / 200:.3f}')
-            running_loss = 0.0
-
-print('Finished Training')
-```
-- **解释**：
-  - 每个 `epoch` 遍历整个数据集，`optimizer.zero_grad()` 清除梯度。
-  - `outputs = net(inputs)` 是前向传播，`loss.backward()` 是反向传播，`optimizer.step()` 更新权重。
-
-
-## （六）测试模型
-以下是测试模型性能的代码：
-```python
-correct = 0
-total = 0
-with torch.no_grad():
-    for data in testloader:
-        inputs, labels = data
-        outputs = net(inputs)
-        _, predicted = torch.max(outputs.data, 1)
-        total += labels.size(0)
-        correct += (predicted == labels).sum().item()
-
-print(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')
-```
-- **解释**：
-  - `torch.no_grad()` 表示在测试阶段不计算梯度。
-  - `torch.max(outputs.data, 1)` 找出每个样本输出概率最大的类别作为预测类别。
-
-
-## （七）保存和加载模型
-保存和加载训练好的模型：
-```python
-# 保存模型
-torch.save(net.state_dict(), 'simplenet.pth')
-
-# 加载模型
-net = SimpleNet()
-net.load_state_dict(torch.load('simplenet.pth'))
-```
-
 
 ### 深度学习常见算法
 
@@ -603,6 +450,164 @@ for epoch in range(100):
 这些深度学习算法是深度学习领域的基础，每个算法都有其独特的特点和适用场景，在实际应用中，可根据具体任务选择合适的算法并进行相应的调参和优化。
 
 深度学习领域在不断发展，新的算法和改进不断涌现，你可以通过阅读学术论文、参加在线课程、参与开源项目等方式不断更新知识，提升技能。
+
+
+### 深度学习一般都是一个流程，所以很容易就会发明 框架
+
+
+
+# 二、深度学习框架
+目前有许多深度学习框架可供选择，以下是几个常用的：
+- **TensorFlow**：由 Google 开发，功能强大且灵活，提供了从简单到复杂的各种深度学习模型的实现。
+- **PyTorch**：以其动态计算图和易于使用的接口而受到欢迎，特别适合研究和开发。
+- **Keras**：一个高级的神经网络 API，可以在 TensorFlow 或 Theano 上运行，提供了简洁的接口，适合快速开发。
+
+
+# 三、深度学习入门步骤
+
+## （一）环境搭建
+以下是使用 PyTorch 搭建深度学习环境的示例：
+```bash
+pip install torch torchvision torchtext
+```
+
+
+## （二）数据准备
+深度学习的第一步是准备数据。以图像分类任务为例，我们可以使用 `torchvision` 中的 `MNIST` 数据集。
+```python
+import torch
+import torchvision
+import torchvision.transforms as transforms
+
+# 定义数据预处理
+transform = transforms.Compose(
+    [transforms.ToTensor(),
+     transforms.Normalize((0.5,), (0.5,))]
+)
+
+# 下载训练集和测试集
+trainset = torchvision.datasets.MNIST(root='./data', train=True,
+                                download=True, transform=transform)
+trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
+                                    shuffle=True, num_workers=2)
+
+testset = torchvision.datasets.MNIST(root='./data', train=False,
+                               download=True, transform=transform)
+testloader = torch.utils.data.DataLoader(testset, batch_size=64,
+                                   shuffle=False, num_workers=2)
+```
+- **解释**：
+  - `transforms.ToTensor()` 将图像转换为 PyTorch 的 `Tensor` 类型。
+  - `transforms.Normalize((0.5,), (0.5,))` 对数据进行标准化，使其范围在 -1 到 1 之间。
+  - `torch.utils.data.DataLoader` 用于将数据集封装为可迭代的数据加载器，便于批量处理。
+
+
+## （三）构建神经网络
+下面是一个简单的全连接神经网络的 PyTorch 实现：
+```python
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class SimpleNet(nn.Module):
+    def __init__(self):
+        super(SimpleNet, self).__init__()
+        self.fc1 = nn.Linear(28 * 28, 128)  # 输入层到第一个隐藏层
+        self.fc2 = nn.Linear(128, 64)    # 第一个隐藏层到第二个隐藏层
+        self.fc3 = nn.Linear(64, 10)     # 第二个隐藏层到输出层
+
+    def forward(self, x):
+        x = x.view(-1, 28 * 28)  # 将图像展平
+        x = F.relu(self.fc1(x))  # 第一个隐藏层，使用 ReLU 激活函数
+        x = F.relu(self.fc2(x))  # 第二个隐藏层，使用 ReLU 激活函数
+        x = self.fc3(x)        # 输出层
+        return x
+
+
+net = SimpleNet()
+```
+- **解释**：
+  - `nn.Linear` 表示全连接层。
+  - `forward` 方法定义了数据的前向传播路径，将输入通过各层和激活函数。
+
+
+## （四）定义损失函数和优化器
+选择合适的损失函数和优化器：
+```python
+import torch.optim as optim
+
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
+```
+- **解释**：
+  - `nn.CrossEntropyLoss()` 用于多分类任务。
+  - `optim.SGD` 是随机梯度下降优化器，`lr` 是学习率，`momentum` 可以加速收敛。
+
+
+## （五）训练模型
+以下是训练网络的代码：
+```python
+# 训练周期
+epochs = 10
+
+for epoch in range(epochs):
+    running_loss = 0.0
+    for i, data in enumerate(trainloader, 0):
+        inputs, labels = data
+        # 清零梯度
+        optimizer.zero_grad()
+
+        # 前向传播
+        outputs = net(inputs)
+        loss = criterion(outputs, labels)
+
+        # 反向传播和优化
+        loss.backward()
+        optimizer.step()
+
+        running_loss += loss.item()
+        if i % 200 == 199:
+            print(f'Epoch {epoch + 1}, Batch {i + 1}, Loss: {running_loss / 200:.3f}')
+            running_loss = 0.0
+
+print('Finished Training')
+```
+- **解释**：
+  - 每个 `epoch` 遍历整个数据集，`optimizer.zero_grad()` 清除梯度。
+  - `outputs = net(inputs)` 是前向传播，`loss.backward()` 是反向传播，`optimizer.step()` 更新权重。
+
+
+## （六）测试模型
+以下是测试模型性能的代码：
+```python
+correct = 0
+total = 0
+with torch.no_grad():
+    for data in testloader:
+        inputs, labels = data
+        outputs = net(inputs)
+        _, predicted = torch.max(outputs.data, 1)
+        total += labels.size(0)
+        correct += (predicted == labels).sum().item()
+
+print(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')
+```
+- **解释**：
+  - `torch.no_grad()` 表示在测试阶段不计算梯度。
+  - `torch.max(outputs.data, 1)` 找出每个样本输出概率最大的类别作为预测类别。
+
+
+## （七）保存和加载模型
+保存和加载训练好的模型：
+```python
+# 保存模型
+torch.save(net.state_dict(), 'simplenet.pth')
+
+# 加载模型
+net = SimpleNet()
+net.load_state_dict(torch.load('simplenet.pth'))
+```
+
  
 
 # 四、深度学习的应用