深度学习入门

入门路线：

1. 李宏毅深度学习课程

   2022最新版-李宏毅机器学习深度学习课程_哔哩哔哩_bilibili

   http://www.youtube.com/c/HungyiLeeNtu

前言

笔者目前研一在读，AI交叉专业，之前没怎么接触过深度学习，所以借此机会，记录一下自己学习深度学习的过程，既是记笔记的一个过程，也希望可以给有需要的朋友一点借鉴。学习资料为上文链接。

---

名词解释：

专有名词	解读
Anomaly Detection	异常检测
Explainable AI	可解释AI
Model Attack	模型攻击
Domain Adaptation	领域自适应
Network Compression	模型压缩
Life-long Learning	长期学习
Meta Learning	元学习
Few-shot Learning	少样本学习
threshold	阈值
discriminative	判别
generative	生成

深度学习——李宏毅

ch1 机器学习与深度学习基本概念

Machine Learning = Looking for Function

Deep Learning是形如类神经网络的function

机器学习步骤：

• function with unknown （写一个函数，我们会根据自己已有的知识去假设函数，比如说我们查看数据的直方图，认为可能是个二次函数或一次函数）
• define loss from training data （定义损失函数）
• optimization （优化）

​ 很多情况下，数据的分布是一个分段函数，我们并不知道每一段的函数应该如何去表示，而事实上，我们可以用同一个函数的不同参数去逼近一个分段函数

​ 例如，我们想得到红色的函数，那我们可以用这些蓝色的函数叠加起来从而逼近红色的函数

​ 而蓝色的函数来自这里Sigmod函数

​ 这时我们的问题就变为了如何得到合适的参数来求解上述方程，我们就可以采用梯度下降的方法来求解上面的未知数。求解完成后，假设我们得到了合适的参数，那么我们如果想验证我们的计算结果就可以采用下面的计算步骤

（问题背景：探究当天点赞量与过去点赞量的关系，这里我们假设当天的点赞量与前三天的点赞量有关，那么输入x1，x2，x3分别代表前三天的点赞量。)

优化注意事项：

​ 我们刚刚提到可以通过计算Loss来更新参数，传统更新loss的方式是计算所有数据的差异，但是我们今天的做法是将所有的数据随机分成N个batch，每次更新只计算一个batch。一个epoch要更新N次参数。（epoch指的是训练的轮数）

​ 我们这里提到的batch也好、epoch也好，都是自己设置的，像这样的参数我们称为超参数。（hyperparameter)

ch2 pytorch教程

1. pytorch是什么

深度学习框架，具有以下两个优点

• 高维度的矩阵运算可以交给GPU
• 自动的梯度计算

2. Dataset & DataLoader

# torch的简单应用
x = torch.tensor([[1., 0], [-1, 1]], requires_grad = True)
z = x.pow(2).sum()
z.backward()
print(x.grad)

3. pytorch定义神经网络

# 一个简单的神经网络（两种不同的写法)

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(10, 32),
            nn.Sigmoid(),
            nn.Linear(32, 1)
        )

    def forward(self, x):
        return self.net(x)
    


class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.layer1 = nn.Linear(10, 5)
        self.layer2 = nn.Linear(5, 1)
    
    def forward(self, x):
        x = self.layer1(x)
        x = torch.relu(x)
        x = self.layer2(x)
        return x

# super(SimpleModel, self).__init__()这一句代码是在调用父类的构造函数，父类本身有一些初始化和管理功能
# super()是python中一个用来调用父类方法的内置函数

4. 深度学习训练过程

dataset = MyDataset(file)
tr_set = DataLoader(dataset, 16, shuffle = True)
model = MyModel().to(device)
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), 0.1)

for epoch in range(n_epochs):
    # 训练过程
    model.train()
    for x, y in tr_set:
        optimizer.zero_grad()
        x, y = x.to(device), y.to(device)
        pre = model(x)
        loss =  criterion(pred, y)
        loss.backward()
        optimizer.step()
        
model.eval()
# 验证过程
preds = []
for x in tt_set:
    x = x.to(device)
    with torch.no_grad():
        pred = model(x)
        preds.append(pred.cpu())

5. 第一次作业代码

import os
import pandas as pd
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm


class My_model(nn.Module):
    def __init__(self, input_dim):
        super(My_model, self).__init__()
        self.layers = nn.Sequential(
            nn.Linear(input_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1)
        )

    def forward(self, x):
        x = self.layers(x)
        x = x.squeeze()
        return x

class COVID9Dataset(Dataset):
    def __init__(self, x, y=None):
        self.x = torch.FloatTensor(x)
        if y is None:
            self.y = y
        else:
            self.y = torch.FloatTensor(y)

    def __getitem__(self, idx):
        if self.y is None:
            return self.x[idx]
        else:
            return self.x[idx], self.y[idx]

    def __len__(self):
        return len(self.x)

def train_model():
    root_path = r"D:\work\work_python\home_work\my_HomeWork\work1"
    data_path = os.path.join(root_path, "covid.train.csv")

    train_data = pd.read_csv(data_path).drop(columns={'id'}).values
    x_train, y_train = train_data[:, :-1], train_data[:, -1]



    train_dataset = COVID9Dataset(x_train, y_train)
    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, pin_memory=True)



    model = My_model(input_dim=x_train.shape[1]).to('cuda')
    criterion = torch.nn.MSELoss(reduction='mean')
    optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, momentum=0.9)

    for epoch in range(10):
        model.train()
        epoch_loss = 0.0

        train_pbar = tqdm(train_loader, position=0, leave=True)
        for x, y in train_pbar:
            x, y = x.to('cuda'), y.to('cuda')
            pred = model(x)
            loss = criterion(pred, y)

            epoch_loss += loss.item()

            loss.backward()
            optimizer.step()
            optimizer.zero_grad()

        avg_loss = epoch_loss / len(train_loader)
        print(f"Epoch {epoch + 1}, Average Loss: {avg_loss:.4f}")

    # 保存模型
    torch.save(model.state_dict(), 'covid_model.pth')

if __name__ == '__main__':
    train_model()

import torch
import pandas as pd
from torch.utils.data import DataLoader, Dataset
import numpy as np
from home_work1 import My_model  # 只导入模型定义

# 预测数据集类
class COVID9Dataset(Dataset):
    def __init__(self, x):
        self.x = torch.FloatTensor(x)

    def __getitem__(self, idx):
        return self.x[idx]

    def __len__(self):
        return len(self.x)

# 加载新的输入数据（假设是一个csv文件）
new_data = pd.read_csv(r"D:\work\work_python\home_work\my_HomeWork\work1\covid.test.csv").drop(columns={'id'}).values
x_new = new_data  # 直接使用数据

# 创建数据集和数据加载器
dataset = COVID9Dataset(x_new)
data_loader = DataLoader(dataset, batch_size=32, shuffle=False)

# 加载训练好的模型
model = My_model(input_dim=x_new.shape[1]).to('cuda')  # input_dim应与训练时一致
model.load_state_dict(torch.load('covid_model.pth'))
model.eval()  # 设置为评估模式，避免Dropout等操作

# 推理过程
predictions = []
with torch.no_grad():  # 关闭梯度计算，因为我们不需要训练
    for x in data_loader:
        x = x.to('cuda')  # 将数据移到GPU
        pred = model(x)  # 使用模型进行预测
        predictions.append(pred.cpu().numpy())  # 将结果从GPU转移回CPU

# 将预测结果合并
predictions = np.concatenate(predictions, axis=0)

for i in predictions:
    print(i)

# # 将预测结果保存为 DataFrame
# predictions_df = pd.DataFrame(predictions, columns=['Prediction'])
#
# # 保存到 CSV 文件
# predictions_df.to_csv(r"D:\work\work_python\home_work\my_HomeWork\work1\predictions.csv", index=False)
#
# # 输出提示信息
# print("Predictions saved to 'predictions.csv'")

ch3 Google Colab教程

这一部分暂时跳过，可以用自己实验室的服务器

选修——深度学习

发展历史

1. perceptron(感知机) linear model
2. perceptron has limitation
3. multi-layer perceptron

• do not have significant difference from DNN today

4. backpropagation
5. Deep = Many hidden layers

反向传播

这一部分是教怎么计算微分，从而更新参数

预测神奇宝贝

避免过拟合的方式：正则化

使用正则化，帮助我们获得更小的参数

α越大，我们的function越平滑

CNN

spatial transformer layer(can also transform feature map)

cnn is not invariant to scaling and rotation

RNN

• slot filling

RNN存在memory

（随着时间的推移，早期的记忆会衰减）