Python打卡DAY34

知识点回归：

1. CPU性能的查看：看架构代际、核心数、线程数
2. GPU性能的查看：看显存、看级别、看架构代际
3. GPU训练的方法：数据和模型移动到GPU device上
4. 类的call方法：为什么定义前向传播时可以直接写作self.fc1(x)

GPU与CPU训练比较：

        对于非常小的数据集和简单的模型，CPU 通常会比 GPU 更快。实际上，这并非本质的原因。本质是因为GPU在计算的时候，相较于cpu多了3个时间上的开销

        1. 数据传输开销 (CPU 内存 <-> GPU 显存)

        2. 核心启动开销 (GPU 核心启动时间)

        3. 性能浪费：计算量和数据批次

具体而言：

1、数据传输开销 (CPU 内存 <-> GPU 显存)
        在 GPU 进行任何计算之前，数据（输入张量 X_train、y_train，模型参数）需要从计算机的主内存 (RAM) 复制到 GPU 专用的显存 (VRAM) 中。
        当结果传回 CPU 时（例如，使用 loss.item() 获取损失值用于打印或记录，或者获取最终预测结果），数据也需要从 GPU 显存复制回 CPU 内存。
        对于少量数据和非常快速的计算任务，这个传输时间可能比 GPU 通过并行计算节省下来的时间还要长。
        在上述代码中，循环里的 loss.item() 操作会在每个 epoch 都进行一次从 GPU 到 CPU 的数据同步和传输，以便获取标量损失值。对于20000个epoch来说，这会累积不少的传输开销。

2、核心启动开销 (GPU 核心启动时间)

        GPU 执行的每个操作（例如，一个线性层的前向传播、一个激活函数）都涉及到在 GPU 上启动一个“核心”(kernel)——一个在 GPU 众多计算单元上运行的小程序。
        启动每个核心都有一个小的、固定的开销。
        如果核心内的实际计算量非常小（本项目的小型网络和鸢尾花数据），这个启动开销在总时间中的占比就会比较大。相比之下，CPU 执行这些小操作的“调度”开销通常更低。

3、性能浪费：计算量和数据批次

        这个数据量太少，gpu的很多计算单元都没有被用到，即使用了全批次也没有用到的全部计算单元。

类的CALL方法

        在 Python 中，__call__ 方法是一个特殊的魔术方法（双下划线方法），它允许类的实例像函数一样被调用。这种特性使得对象可以表现得像函数，同时保留对象的内部状态。

class MLP(nn.Module): # 定义一个多层感知机（MLP）模型，继承父类nn.Module
    def __init__(self): # 初始化函数
        super(MLP, self).__init__() # 调用父类的初始化函数
 # 前三行是八股文，后面的是自定义的

        self.fc1 = nn.Linear(4, 10)  # 输入层到隐藏层
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(10, 3)  # 隐藏层到输出层
# 输出层不需要激活函数，因为后面会用到交叉熵函数cross_entropy，交叉熵函数内部有softmax函数，会把输出转化为概率

    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

        可以注意到，self.fc1 = nn.Linear(4, 10)  此时，是实例化了一个nn.Linear(4, 10)对象，并把这个对象赋值给了MLP的初始化函数中的self.fc1变量。

        在 Python 中，任何定义了 __call__ 方法的类，其实例都可以像函数一样被调用。当调用 self.fc1(x) 时，实际上执行的是：
        self.fc1.__call__(x)（Python 的隐式调用）
        而 nn.Module 的 __call__ 方法会调用子类的 forward 方法（即 self.fc1.forward(x)）。这个方法就是个前向计算方法。
        relu是torch.relu()这个函数为了保持写法一致，又封装成了nn.ReLU()这个类。来保证接口的一致性。
        PyTorch 官方强烈建议使用 self.fc1(x)，因为它会触发完整的前向传播流程（包括钩子函数）这是 PyTorch 的核心设计模式，几乎所有组件（如 nn.Conv2d、nn.ReLU、甚至整个模型）都可以这样调用。

# 不带参数的call方法
class Counter:
    def __init__(self):
        self.count = 0
    
    def __call__(self):
        self.count += 1
        return self.count

# 使用示例
counter = Counter()
print(counter())  # 输出: 1
print(counter())  # 输出: 2
print(counter.count)  # 输出: 2

# 带参数的call方法
class Adder:
    def __call__(self, a, b):
        print("唱跳篮球rap")
        return a + b

adder = Adder()
print(adder(3, 5))  # 输出: 8

@浙大疏锦行