深度学习

def step_function(x):
    if x > 0:
        return 1
    else:
        return 0

def step_function(x):
    return np.array(x > 0, dtype=int)

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

import numpy as np

def tanh(x):
    return np.tanh(x)

def relu(x):
    return np.maximum(0, x)

def softmax(x):
    return np.exp(x) / np.sum(np.exp(x))

def softmax(x):
    x = x - np.max(x)  # 溢出对策
    return np.exp(x) / np.sum(np.exp(x))

def softmax(x):
    if x.ndim == 2:
        x = x.T
        x = x - np.max(x, axis=0)
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T 

    x = x - np.max(x)  # 溢出对策
    return np.exp(x) / np.sum(np.exp(x))

import numpy as np
from dl_code.common.functions import sigmoid, identity_function

# 初始化网络
def init_network():
    network = {}
    network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
    network['b1'] = np.array([0.1, 0.2, 0.3])
    network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
    network['b2'] = np.array([0.1, 0.2])
    network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
    network['b3'] = np.array([0.1, 0.2])

    return network

# 前向传播
def forward(network, x):
    w1, w2, w3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']

    a1 = np.dot(x, w1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, w2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, w3) + b3
    y = identity_function(a3)

    return y

network = init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)

print(y)

import numpy as np
import pandas as pd
import joblib
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from dl_code.common.functions import sigmoid, softmax

# 读取数据
def load_data():
    # 1. 从文件读取数据
    data = pd.read_csv('../data/train.csv')
    # 2. 划分数据集
    X_train, X_test, y_train, y_test = train_test_split(data.drop('label', axis=1), data['label'], test_size=0.3,
                                                        random_state=42)
    # 3. 特征工程：归一化
    scaler = MinMaxScaler()
    X_train = scaler.fit_transform(X_train)
    X_test = scaler.transform(X_test)
    return X_test, y_test


# 初始化模型
def init_network():
    network = joblib.load('../data/nn_sample') # 训练好的参数模型
    return network


# 前向传播
def forward(network, x):
    w1, w2, w3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']
    # 逐层计算传递
    a1 = np.dot(x, w1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, w2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, w3) + b3
    y = softmax(a3)
    return y

# 主流程
# 1. 读取测试数据
x,y = load_data()
# print(x)
# print(y)
# print(x.shape)
# print(y.shape)

# 2. 加载模型（训练好的模型）
network = init_network()

# 3. 前向传播
y_proba = forward(network, x)
print(y_proba)
# 4. 将分类概率转为分类结果
y_pred = np.argmax(y_proba, axis=1) # argmax：返回最大值的索引
print(y_pred)

# 5. 计算准确率
acc = np.mean(y_pred == y) # 计算预测结果与真实标签匹配的比例，即准确率（平均值）
n = x.shape[0]   # 测试样本的总数
accuracy = np.sum(y_pred == y) / n  # 计算预测正确的样本数占总样本数的比例，也是准确率

print('准确率：', acc, accuracy)

import numpy as np
import pandas as pd
import joblib
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from dl_code.common.functions import sigmoid, softmax

# 读取数据
def load_data():
    # 1. 从文件读取数据
    data = pd.read_csv('../data/train.csv')
    # 2. 划分数据集
    X_train, X_test, y_train, y_test = train_test_split(data.drop('label', axis=1), data['label'], test_size=0.3,
                                                        random_state=42)
    # 3. 特征工程：归一化
    scaler = MinMaxScaler()
    X_train = scaler.fit_transform(X_train)
    X_test = scaler.transform(X_test)
    return X_test, y_test

# 初始化模型
def init_network():
    network = joblib.load('../data/nn_sample')
    return network

# 前向传播
def forward(network, x):
    w1, w2, w3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']
    # 逐层计算传递
    a1 = np.dot(x, w1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1, w2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2, w3) + b3
    y = softmax(a3)
    return y

# 主流程
# 1. 读取测试数据
x,y = load_data()
# print(x)
# print(y)
# print(x.shape)
# print(y.shape)

# 2. 加载模型（训练好的模型）
network = init_network()

# 3. 前向传播（批处理）
batch_size = 100 # 批处理窗口
accuracy_cnt = 0 # 预测正确的样本数
n = x.shape[0]   # 测试样本的总数

for i in range(0, n, batch_size):
    x_batch = x[i:i+batch_size] # i:i+batch_size:表示截取一个窗口的数据[i, i+batch_size)
    y_batch = y[i:i+batch_size]
    y_pred = np.argmax(forward(network, x_batch), axis=1)
    accuracy_cnt += np.sum(y_pred == y_batch)

# 4. 计算准确率
print('准确率：', accuracy_cnt / n)

def mean_squared_error(y, t):
    return 0.5 * np.sum((y - t) ** 2)

# 交叉熵误差
def cross_entropy(y, t):
    # 将y转为二维
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)
    # 将t转换为顺序编码（类别标签）
    if t.size == y.size:
        t = t.argmax(axis=1)
    n = y.shape[0]
    # 如果预测概率绝对等于 0，np.log(0) 会导致程序抛出 -inf（负无穷大）
    return -np.sum( np.log(y[np.arange(n), t] + 1e-10) ) / n 

def numerial_diff(f, x):
  h = 1e-4 *# 微小值 0.0001*
  return (f(x+h) - f(x-h)) / (2 * h)

def _numerical_gradient(f, x):
    h = 1e-4
    grad = np.zeros_like(x)  # 生成x的形状相同，全为0的向量
    # 遍历向量x中的特征xi
    for i in range(len(x)):
        xi = x[i]
        x[i] = xi + h
        fxh1 = f(x)  # 这里意为计算交叉熵误差
        x[i] = xi - h
        fxh2 = f(x)
        x[i] = xi
        # 利用中心差公式计算偏导数，即求导数，找出梯度下降最大方向，即损失函数最小的方向
        grad[i] = (fxh1 - fxh2) / (2 * h)
        # 恢复x向量的值
        x[i] = xi
    return grad

# 定义一个简单神经网络类
class SimpleNet:
    def __init__(self):
        self.W = np.random.randn(2,3)
    # 前向传播
    def forward(self, x):
        a = np.dot(x, self.W)
        y = softmax(a) # softmax为上文实现的函数
        return y
    # 损失函数
    def loss(self, x, t):
        y = self.forward(x)
        return cross_entropy(y, t) # cross_entropy为上文实现的函数

x = np.array([0.6, 0.9])
t = np.array([0, 0, 1])

net = SimpleNet()

f = lambda w: net.loss(x, t)
dW = numerical_gradient(f, net.W) # numerical_gradient为上文实现的函数

print(dW)

# 定义梯度下降法函数
def gradient_descent(f, init_x, lr=0.01, step_num=100):
    x = init_x
    # 定义列表保存梯度下降过程中每一步的参数x
    x_history = []
    # 循环迭代进行梯度下降
    for i in range(step_num):
        x_history.append(x.copy())
        # 计算梯度
        grad = numerical_gradient(f, x)
        # 更新参数x
        x -= lr * grad
    return x, np.array(x_history)

class TwoLayerNet:
    """
    两层神经网络
    """

    def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
        """
        初始化：针对权重矩阵W和偏置项b都使用随机的方式初始化，用于后期训练调整
        """
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size) # 生成一个服从标准正态分布（均值为0，标准差为1）的随机矩阵，形状为 (input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
        self.params['b2'] = np.zeros(output_size)

    def forward(self, x):
        """
        前向传播预测结果
        """
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        return y

    def loss(self, x, t):
        """
        计算损失：x:输入数据, t:监督数据
        """
        y = self.forward(x)
        return cross_entropy(y, t)

    def accuracy(self, x, t):
        """
        计算准确率
        """
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        t = np.argmax(t, axis=1)
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy

    def numerical_gradient(self, x, t):
        """
        数值微分计算梯度
        """
        loss_W = lambda W: self.loss(x, t) # 一个匿名函数 loss_W，它接受一个参数矩阵 W，并返回调用 self.loss(x, t) 的结果
        grads = {}
        # 遍历所有参数，计算梯度，并保存在 grads 中，key 为参数名，value 为梯度
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        return grads

def get_data():
    # 1. 从文件加载数据集
    data = pd.read_csv("../data/train.csv")
    # 2. 划分数据集
    X = data.drop("label", axis=1)
    y = data["label"]
    x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
    # 3. 特征工程：归一化
    scaler = MinMaxScaler()
    x_train = scaler.fit_transform(x_train)
    x_test = scaler.transform(x_test)
    # 4. 将数据都转成ndarray
    y_train = y_train.values
    y_test = y_test.values

    return x_train, x_test, y_train, y_test

import numpy as np
import matplotlib.pyplot as plt
from two_layer_net import TwoLayerNet

# 读入数据
x_train, x_test, t_train, t_test = get_data ()
# 创建一个二层神经网络
network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

# 设置超参数
iters_num = 10000  # 适当设定循环的次数
train_size = x_train.shape[0]
batch_size = 100 # 批量大小
learning_rate = 0.1 # 学习率

train_loss_list = [] # 损失值列表
train_acc_list = [] # 训练集准确率列表
test_acc_list = [] # 测试集准确率列表

iter_per_epoch = max(train_size / batch_size, 1) # 一个epoch的迭代次数
for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size) # 从 [0, train_size) 范围内随机选择 batch_size 个不重复的索引
    # print(batch_mask)
    x_batch = x_train[batch_mask]# 获取批量数据
    t_batch = t_train[batch_mask]
    # 计算梯度
    grads = network.numerical_gradient(x_batch, t_batch)

    # 更新参数
    for key in ('W1', 'b1', 'W2', 'b2'): # 遍历所有参数更新其值
        network.params[key] -= learning_rate * grads[key]
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)

    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))

# 绘制图形
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, label='train acc')
plt.plot(x, test_acc_list, label='test acc', linestyle='--')
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

class ReLU:
    # 初始化
    def __init__(self):
        # 内部属性，记录哪些x<=0
        self.mask = None
    # 前向传播
    def forward(self, x):
        self.mask = (x <= 0) # x<=0的索引值为true
        y = x.copy() # 创建一个和x相同的数组
        # 将x<=0的值设为0
        y[self.mask] = 0 # 索引为true的元素设为0
        return y
    # 反向传播
    def backward(self, dy):
        dx = dy.copy()
        dx[self.mask] = 0 # 索引为true的元素设为0
        return dx

class Sigmoid:
    # 创建一个Sigmoid对象
    def __init__(self):
        # 创建一个内部属性，记录输出值y，用于反向传播时计算梯度
        self.y = None
    # 前向传播
    def forward(self, x):
        y = sigmoid(x)
        self.y = y
        return y
    # 反向传播
    def backward(self, dy):
        dx = dy * (1.0 - self.y) * self.y # 梯度计算
        return dx

class Affine:
    # 创建一个仿射层对象
    def __init__(self, W, b):
        self.W = W
        self.b = b
        # 输入数据X做保存，方便反向传播计算梯度
        self.X = None
        self.original_x_shape = None
        # 将权重和偏置参数的梯度（偏导数）保存成属性，方便梯度极端
        self.dW = None
        self.db = None
    # 前向传播
    def forward(self, X):
        self.original_x_shape = X.shape
        self.X = X.reshape(X.shape[0], -1)
        y = np.dot(self.X, self.W) + self.b
        return y
    # 反向传播
    def backward(self, dy):
        dX = np.dot(dy, self.W.T)
        dX = dX.reshape(*self.original_x_shape)  # 还原输入数据的形状（对应张量）
        self.dW = np.dot(self.X.T, dy)
        self.db = np.sum(dy, axis=0)
        return dX

# SoftmaxWithLoss层 - 结合Softmax激活和交叉熵损失
# 用于多分类问题的输出层
class SoftmaxWithLoss:
    # 创建一个SoftmaxWithLoss对象
    def __init__(self):
        self.loss = None      # 存储计算的损失值
        self.y = None         # 存储softmax输出的概率分布
        self.t = None         # 存储真实标签
    # 前向传播：计算softmax概率和交叉熵损失
    def forward(self, X, t):
        self.t = t                    # 保存真实标签
        self.y = softmax(X)           # 计算softmax概率分布
        self.loss = cross_entropy(self.y, self.t)  # 计算交叉熵损失
        return self.loss              # 返回损失值
    # 反向传播：计算损失函数对输入的梯度
    # 返回梯度∇L/∂y = (y-t)/N，指示损失减小最快的方向
    def backward(self, dy=1):
        batch_size = self.t.shape[0]  # 获取批次大小

        # 如果是独热编码的标签，直接使用公式∇L/∂y = y - t
        if self.t.size == self.y.size:  # size表示数组元素个数
            dx = self.y - self.t

        # 如果是顺序编码的标签，需要找到对应位置进行计算
        else:
            dx = self.y.copy()  # 复制softmax输出作为初始梯度
            # 具体例子：batch_size=3, self.t=[1,0,2], self.y=[[0.2,0.7,0.1],[0.8,0.1,0.1],[0.1,0.2,0.7]]
            # 执行dx[np.arange(3), [1,0,2]] -= 1
            # 即：dx[0,1]-=1, dx[1,0]-=1, dx[2,2]-=1
            # 结果：dx=[[0.2,-0.3,0.1],[-0.2,0.1,0.1],[0.1,0.2,-0.3]]
            # 这相当于将顺序编码转换为稀疏的one-hot形式进行计算
            dx[np.arange(batch_size), self.t] -= 1
        return dx / batch_size  # 返回平均梯度

from common.gradient import numerical_gradient
from common.layers import *
from collections import OrderedDict     # 有序字典，用来保存层结构

class TwoLayerNet:
    def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
        """
        初始化：针对权重矩阵W和偏置项b都使用随机的方式初始化，用于后期训练调整
        """
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size) # 生成一个服从标准正态分布（均值为0，标准差为1）的随机矩阵，形状为 (input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
        self.params['b2'] = np.zeros(output_size)
        # 定义层结构
        self.layers = OrderedDict()
        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
        self.layers['Relu1'] = ReLU()
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])
        # 单独定义SoftmaxWithLoss层
        self.lastLayer = SoftmaxWithLoss()

    def forward(self, X):
        """
        前向传播
        """
        for layer in self.layers.values():
            X = layer.forward(X)
        return X

    def loss(self, x, t):
        """
        计算损失：x:输入数据, t:监督数据
        """
        y = self.forward(x)
        loss_value = self.lastLayer.forward(y, t)
        return loss_value

    def accuracy(self, x, t):
        """
        计算准确率
        """
        y_pred = self.forward(x) # 预测分类数值
        # 根据最大概率得到预测的分类号
        y = np.argmax(y_pred, axis=1)
        # 与正确解标签对比，得到准确率
        accuracy = np.sum(y == t) / x.shape[0]
        return accuracy

    def gradient(self, x, t):
        # 先做一次前向传播，直到计算损失
        self.loss(x, t)
        # 反向传播
        dy = 1
        dy = self.lastLayer.backward(dy)
        # 将神经网络中的所有层翻转处理
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dy = layer.backward(dy)
        # 提取各层参数的梯度
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
        return grads

import matplotlib.pyplot as plt

from common.load_data import get_data
from common.functions import *
from two_layer_net_bp import TwoLayerNet

# 读入数据
x_train, x_test, t_train, t_test = get_data ()
# 创建一个二层神经网络
network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

# 设置超参数
iters_num = 10000   # 适当设定循环的次数
train_size = x_train.shape[0]
batch_size = 100 # 批量大小
learning_rate = 0.1 # 学习率

train_loss_list = [] # 损失值列表
train_acc_list = [] # 训练集准确率列表
test_acc_list = [] # 测试集准确率列表

iter_per_epoch = max(train_size / batch_size, 1) # 一个epoch的迭代次数
# 随机梯度下降(SGD)训练过程。每次循环都会：
# 1. 随机选择一批新的数据 (batch_mask)
# 2. 对这批数据执行一次前向传播和反向传播 (grads = network.gradient(x_batch, t_batch))
# 3. 使用计算出的梯度更新网络参数
# 4. 继续下一轮循环
for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size) # 从 [0, train_size) 范围内随机选择 batch_size 个不重复的索引
    # print(batch_mask)
    x_batch = x_train[batch_mask]# 获取批量数据
    t_batch = t_train[batch_mask]
    # 计算梯度
    # grads = network.numerical_gradient(x_batch, t_batch) # 数值微分法
    grads = network.gradient(x_batch, t_batch) # 反向传播法

    # 更新参数
    for key in ('W1', 'b1', 'W2', 'b2'): # 遍历所有参数更新其值
        network.params[key] -= learning_rate * grads[key]
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)

    if i % iter_per_epoch == 0:
        train_acc = network.accuracy(x_train, t_train)
        test_acc = network.accuracy(x_test, t_test)
        train_acc_list.append(train_acc)
        test_acc_list.append(test_acc)
        print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))

# 绘制图形
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, label='train acc')
plt.plot(x, test_acc_list, label='test acc', linestyle='--')
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()

# SGD
class SGD:
    def __init__(self, lr=0.01):
        """
        初始化参数
        :param lr: 学习率
        """
        self.lr = lr
    def update(self, params, grads):
        """
        参数更新
        :param params: 模型参数
        :param grads: 梯度
        :return:
        """
        for key in params.keys():
            params[key] -= self.lr * grads[key]

# 动量法
class Momentum:
    def __init__(self, lr=0.01, momentum=0.9):
        """
        初始化参数
        :param lr: 学习率
        :param momentum: 动量因子
        """
        self.lr = lr
        self.momentum = momentum
        self.v = None  # 历史负梯度的加权和

    def update(self, params, grads):
        """
        参数更新
        :param params: 模型参数
        :param grads: 梯度
        :return:
        """
        if self.v is None:
            self.v = {}
            for key, val in params.items():
                self.v[key] = np.zeros_like(val)
        for key in params.keys():
            self.v[key] = self.momentum * self.v[key] - self.lr * grads[key]
            params[key] += self.v[key]

# AdaGrad
class AdaGrad:
    def __init__(self, lr=0.01):
        """
        初始化参数
        :param lr: 学习率
        """
        self.lr = lr
        self.h = None  # 存储每个参数的梯度平方

    def update(self, params, grads):
        """
        参数更新
        :param params: 模型参数
        :param grads: 梯度
        :return:
        """
        if self.h is None:  # 初始化
            self.h = {}
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)
        for key in params.keys():
            self.h[key] += grads[key] * grads[key]
            params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-8)

# RMSProp
class c:
    def __init__(self, lr=0.01, decay_rate=0.99):
        """
        初始化参数
        :param lr: 学习率
        :param decay_rate: 衰减率
        """
        self.lr = lr
        self.decay_rate = decay_rate
        self.h = None  # 存储每个参数的梯度平方

    def update(self, params, grads):
        """
        参数更新
        :param params: 模型参数
        :param grads: 梯度
        :return:
        """
        if self.h is None:  # 初始化
            self.h = {}
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)
        for key in params.keys():
            self.h[key] *= self.decay_rate
            self.h[key] += (1 - self.decay_rate) * grads[key] * grads[key]
            params[key] -= self.lr * grads[key] / (np.sqrt(self.h[key]) + 1e-8)

# Adam
class Adam:
    def __init__(self, lr=0.001, beta1=0.9, beta2=0.999):
        """
        初始化参数
        :param lr: 学习率
        :param beta1: 一阶矩估计的衰减率
        :param beta2: 二阶矩估计的衰减率
        """
        self.lr = lr  # 学习率
        self.beta1 = beta1
        self.beta2 = beta2
        self.iter = 0  # 迭代次数
        self.h = None
        self.v = None

    def update(self, params, grads):
        """
        参数更新
        :param params: 模型参数
        :param grads: 梯度
        :return:
        """
        if self.h is None:
            self.h, self.v = {}, {}
            for key, val in params.items():
                self.h[key] = np.zeros_like(val)
                self.v[key] = np.zeros_like(val)
        self.iter += 1
        lr_t = self.lr * np.sqrt(1.0 - self.beta2 ** self.iter) / (1.0 - self.beta1 ** self.iter)
        for key in params.keys():
            # 简化前：
            # self.v[key] = self.beta1 * self.v[key] + (1 - self.beta1) * grads[key]
            # self.h[key] = self.beta2 * self.h[key] + (1 - self.beta2) * grads[key] ** 2
            # 优化后：
            self.v[key] += (1 - self.beta1) * (grads[key] - self.v[key])
            self.h[key] += (1 - self.beta2) * (grads[key] ** 2 - self.h[key])
            params[key] -= lr_t * self.v[key] / (np.sqrt(self.h[key]) + 1e-8)

import torch
import numpy as np

# 从标量创建 0 维张量
tensor1 = torch.tensor(10)
print(tensor1)  # tensor(10)

# 从列表创建一维张量
tensor2 = torch.tensor([1, 2, 3])
print(tensor2)  # tensor([1, 2, 3])

# 从 NumPy 数组创建张量（复制数据，不共享内存）
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
tensor3 = torch.tensor(arr)
print(tensor3)

import torch

# 按形状创建：元素未初始化，默认 dtype=float32
tensor1 = torch.Tensor(3, 2, 4)
print(tensor1.shape, tensor1.dtype)  # torch.Size([3, 2, 4]) torch.float32

# 从嵌套列表创建二维张量
tensor2 = torch.Tensor([[1, 2, 3, 4], [5, 6, 7, 8]])
print(tensor2)

import torch

# 方式一：类型构造函数
a = torch.IntTensor(2, 3)           # int32，未初始化
b = torch.LongTensor([1, 2, 3])      # int64
c = torch.FloatTensor([9, 8, 7])    # float32
d = torch.DoubleTensor(2, 3, 1)     # float64，未初始化

# 方式二：torch.tensor + dtype（推荐，语义清晰）
e = torch.tensor([1, 2, 3], dtype=torch.int32)
f = torch.tensor([1, 2, 3], dtype=torch.int64)
g = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)

# 整型构造函数传入浮点：会做截断
h = torch.IntTensor([1.1, 2.2, 3.6])  # tensor([1, 2, 3])
print(h)

import torch

# [10, 30) 步长 2
tensor1 = torch.arange(10, 30, 2)
print(tensor1)  # tensor([10, 12, 14, ..., 28])

# [0, 6) 步长 1，即 [0,1,2,3,4,5]
tensor2 = torch.arange(6)
print(tensor2)  # tensor([0, 1, 2, 3, 4, 5])

import torch

# 在 [10, 30] 上均匀取 5 个点
tensor1 = torch.linspace(10, 30, 5)
print(tensor1)  # tensor([10., 15., 20., 25., 30.])

import torch

# 指数区间 [1,3]，3 个点，底数 2 → 即 2^1, 2^2, 2^3
tensor1 = torch.logspace(1, 3, 3, base=2)
print(tensor1)  # tensor([2., 4., 8.])

import torch

# 全 0 / 全 1 / 常数填充
tensor1 = torch.zeros(2, 3)
print(tensor1)
tensor2 = torch.ones_like(tensor1)
print(tensor2)
tensor3 = torch.full((2, 3), 6)
print(tensor3)

# empty 不保证数值，仅分配内存
tensor4 = torch.empty(2, 3)
tensor5 = torch.empty_like(tensor1)

# 单位矩阵：n×n 或 n×m
eye_n = torch.eye(3)       # 3×3 单位阵
eye_nm = torch.eye(3, 4)  # 3×4，前 3 列对角为 1
print(eye_n)
print(eye_nm)

import torch

# [0, 1) 均匀分布
tensor1 = torch.rand(2, 3)
print(tensor1)

# 与某张量同形状的 [1, 10) 整数
tensor2 = torch.randint_like(tensor1, 1, 10)
print(tensor2)

# 标准正态 N(0, 1)
tensor3 = torch.randn(4, 2)
print(tensor3)

# 正态 N(5, 1)，形状与 tensor3 相同
tensor4 = torch.normal(5, 1, size=tensor3.shape)
print(tensor4)

# 0~9 的随机排列
perm = torch.randperm(10)
print(perm)

# 固定种子以便复现
torch.manual_seed(42)
a = torch.rand(2, 2)
torch.manual_seed(42)
b = torch.rand(2, 2)
print(a.equal(b))  # True

import torch

tensor1 = torch.tensor([1, 2, 3])  # 默认 int64 或根据数据推断
print(tensor1.dtype)  # torch.int64

# 转为 float32
tensor1 = tensor1.type(torch.float32)
print(tensor1.dtype)  # torch.float32

# 便捷方法：double→float64, long→int64, int→int32
tensor1 = tensor1.double()
tensor1 = tensor1.long()
print(tensor1.dtype)  # torch.int64

import torch
import numpy as np

# Tensor → ndarray：默认共享内存（CPU）
tensor1 = torch.rand(3, 2)
arr = tensor1.numpy()
tensor1[:, 0] = 4
print(tensor1)
print(arr)  # arr 也会被修改

# 不共享：使用 .copy()
arr2 = tensor1.numpy().copy()
tensor1[:, 0] = -1
print(arr2)  # 不变

# ndarray → Tensor：from_numpy 共享，torch.tensor 不共享
arr3 = np.random.randn(3)
tensor2 = torch.from_numpy(arr3)
arr3[0] = 100
print(tensor2[0])  # 100，共享

tensor3 = torch.tensor(arr3)
arr3[0] = -1
print(tensor3[0])  # 仍为 100，不共享

import torch

tensor1 = torch.tensor(3.14)
scalar = tensor1.item()  # 得到 Python float
print(scalar, type(scalar))  # 3.14 <class 'float'>

tensor2 = torch.tensor(5)
print(tensor2.item())  # 5 <class 'int'>

import torch

tensor1 = torch.randint(1, 9, (2, 3))
print(tensor1)
# 运算符与 add 均不修改原张量
print(tensor1 + 10)
print(tensor1.add(10))
print(tensor1)  # 未变
# in-place：原张量被修改
print(tensor1.add_(10))
print(tensor1)  # 已加 10

import torch
tensor1 = torch.tensor([1, 2, 3])
print(-tensor1)        # tensor([-1, -2, -3])
print(tensor1.neg())  # 同上，tensor1 不变
print(tensor1.neg_()) # 同上，且 tensor1 被修改
print(tensor1)        # tensor([-1, -2, -3])

import torch
tensor1 = torch.tensor([1, 2, 3])
print(tensor1 ** 2)   # tensor([1, 4, 9])
print(tensor1.pow(2)) # 同上
tensor1.pow_(2)       # in-place
print(tensor1)        # tensor([1, 4, 9])

import torch
tensor1 = torch.tensor([1.0, 2.0, 3.0])
print(tensor1.sqrt())  # tensor([1., 1.414..., 1.732...])
tensor1.sqrt_()
print(tensor1)

import torch
tensor1 = torch.tensor([1.0, 2.0, 3.0])
print(tensor1.exp())  # e^1, e^2, e^3
print(tensor1.log())  # ln(1), ln(2), ln(3)

import torch
tensor1 = torch.tensor([[1, 2], [3, 4]])
tensor2 = torch.tensor([[1, 2], [3, 4]])
print(tensor1 * tensor2)   # [[1,4],[9,16]]
print(tensor1.mul(tensor2)) # 同上

import torch

# 2D
a = torch.tensor([[1, 2, 3], [4, 5, 6]])   # 2×3
b = torch.tensor([[1, 2], [3, 4], [5, 6]]) # 3×2
print(a.mm(b))    # 2×2
print(a @ b)     # 同上
print(a.matmul(b))

# 3D：按批次做矩阵乘，(batch, m, n) @ (batch, n, p) -> (batch, m, p)
x = torch.tensor([[[1, 2, 3], [4, 5, 6]], [[6, 5, 4], [3, 2, 1]]])  # (2,2,3)
y = torch.tensor([[[1, 2], [3, 4], [5, 6]], [[6, 5], [4, 3], [2, 1]]])  # (2,3,2)
print((x @ y).shape)  # (2, 2, 2)

import torch
X = torch.randint(1, 9, (3, 2, 4))
Y = torch.randint(1, 9, (3, 4, 1))
print(id(X))
X = X @ Y      # X 指向新对象，原内存可被回收
print(id(X))   # 与上面不同

X = torch.randint(1, 9, (3, 2, 4))
print(id(X))
X[:] = X @ Y   # 结果写回 X 的存储，id(X) 不变
print(id(X))

import torch
tensor1 = torch.randint(1, 9, (3, 2, 4)).float()

# 全局与按维求和/均值
print(tensor1.sum())           # 标量
print(tensor1.sum(dim=0))      # 沿 dim0 聚合，形状 (2,4)
print(tensor1.mean(dim=1))     # 沿 dim1 聚合，形状 (3,4)

# 最大值：可同时返回索引
print(tensor1.max())           # 全局最大
vals, idx = tensor1.max(dim=2)  # 每行最大及索引

# 最小值的线性索引、标准差、去重、排序
print(tensor1.argmin())        # 展平后最小值的下标
print(tensor1.std())
print(tensor1.unique())
print(tensor1.sort())          # (values, indices)

import torch
tensor1 = torch.randint(1, 9, (3, 5, 4))
print(tensor1[0].shape)      # (5, 4)：取第 0 维为 0 的片
print(tensor1[:, 1].shape)   # (3, 4)：第 1 维取 1
print(tensor1[2, 1, 3])      # 标量
print(tensor1[1:, 1:4, 0:3].shape)  # (2, 3, 3)：切片

import torch
tensor1 = torch.randint(1, 9, (3, 5, 4))
print(tensor1[1:].shape)           # (2, 5, 4)：第 0 维从 1 到末
print(tensor1[-1:, 1:4, 0:3].shape) # (1, 3, 3)：最后一行，第 1 维 1:4，第 2 维 0:3

import torch
tensor1 = torch.randint(1, 9, (3, 5, 4))
# 取 (0,1)、(1,2) 两行，结果形状 (2, 4)
print(tensor1[[0, 1], [1, 2]].shape)
# [[0],[1]] 与 [1,2] 广播，取 4 个位置，结果形状 (2, 2, 4)
print(tensor1[[[0], [1]], [1, 2]].shape)

#自定义环境 library/python3-be38bd9cb461ab775f44082e06df14e1
import torch
tensor1 = torch.randint(1, 9, (3, 5, 4))

print(tensor1)

print()

# 第 2 维第 0 列 > 5 的掩码 (3,5)，按掩码取出一维
print(tensor1[:, :, 0] > 5)
print(tensor1[tensor1[:, :, 0] > 5].shape)

print()

# 取 第1维第1大于5的，返回(dim0,dim2)形状的索引

mask = tensor1[:, 1, :] > 5
print(mask)

tensor2 = tensor1.permute(0, 2, 1)  # 转换维度为(dim0,dim2,dim1)
print(tensor2[mask])

tensor2 = tensor2[mask].permute(1, 0)  # 转换维度为(dim1,?)
print(tensor2)
print()

# 取 第1维第1，第2维第2大于5的，返回(dim0)形状的索引
print(tensor1[:, 1, 2] > 5)
print(tensor1[tensor1[:, 1, 2] > 5])

import torch
tensor1 = torch.randint(1, 9, (2, 3, 6))

# transpose：只交换第 1 维与第 2 维，结果形状 (2, 6, 3)
print(tensor1.transpose(1, 2))

# permute：按 (dim2, dim0, dim1) 重排，结果形状 (6, 2, 3)
print(tensor1.permute(2, 0, 1))

import torch
tensor1 = torch.randint(1, 9, (3, 5, 4))  # 共 60 个元素

print(tensor1.reshape(6, 10))   # 形状 (6, 10)
print(tensor1.reshape(3, -1))  # (3, 20)，-1 被推断为 20

import torch
tensor1 = torch.randint(1, 9, (3, 5, 4))
print(tensor1.is_contiguous())   # True
print(tensor1.view(-1, 10))     # 可直接 view

tensor1 = tensor1.permute(2, 0, 1)  # 交换后可能不连续
print(tensor1.is_contiguous())   # False
# tensor1.view(-1) 可能报错，先 contiguous 再 view
print(tensor1.contiguous().view(-1))

import torch
tensor1 = torch.tensor([1, 2, 3, 4, 5])  # shape (5,)

print(tensor1.unsqueeze(dim=0))   # (1, 5)
print(tensor1.unsqueeze(dim=1))   # (5, 1)
print(tensor1.unsqueeze(dim=-1))  # (5, 1)

import torch
tensor1 = torch.tensor([1, 2, 3, 4, 5])
tensor1 = tensor1.unsqueeze_(dim=0)  # (1, 5)
print(tensor1.squeeze())  # (5,)，删除所有大小为 1 的维

import torch
# cat：在 dim=1 上拼接，(2,2,5) 与 (2,1,5) -> (2,3,5)
tensor1 = torch.randint(1, 9, (2, 2, 5))
tensor2 = torch.randint(1, 9, (2, 1, 5))
print(torch.cat([tensor1, tensor2], dim=1).shape)  # (2, 3, 5)
# stack：在 dim=2 处堆叠，(3,1,5) 与 (3,1,5) -> (3,1,2,5)
tensor1 = torch.randint(1, 9, (3, 1, 5))
tensor2 = torch.randint(1, 9, (3, 1, 5))
tensor3 = torch.stack([tensor1, tensor2], dim=2)
print(tensor3.shape)  # (3, 1, 2, 5)

import torch

# 输入与目标（不需要梯度）
x = torch.tensor(10.0)
y = torch.tensor(3.0)
# 可训练参数：requires_grad=True 以记录运算并求梯度
w = torch.rand(1, 1, requires_grad=True)
b = torch.rand(1, 1, requires_grad=True)
z = w * x + b
# 损失函数与反向传播
loss_fn = torch.nn.MSELoss()
loss_value = loss_fn(z, y)
loss_value.backward()  # 计算图中所有 requires_grad=True 的叶子节点的梯度
print("w.grad:", w.grad)
print("b.grad:", b.grad)

print(x.is_leaf)        # True
print(w.is_leaf)        # True
print(b.is_leaf)        # True
print(z.is_leaf)        # False（z 由 w*x+b 计算得到）
print(y.is_leaf)        # True
print(loss_value.is_leaf)  # False

import torch

x = torch.ones(2, 2, requires_grad=True)
y = x * x
u = y.detach()   # 分离 y，得到与 y 同值但不追踪梯度的 u
z = u * x
z.sum().backward()
# 反向传播时 z = u*x 对 x 求偏导，u 被视为常数，故 dz/dx = u，即 x.grad == u
# 若未 detach，则 z = x*x*x，dz/dx = 3*x^2，与上述结果不同
print(x.grad == u)  # tensor([[True, True], [True, True]])

model.eval()
with torch.no_grad():
    pred = model(X_test)

#自定义环境 library/python3-be38bd9cb461ab775f44082e06df14e1
import torch
import matplotlib.pyplot as plt

from torch import nn, optim  # 模型、损失函数和优化器
from torch.utils.data import TensorDataset, DataLoader  #数据集和数据加载器

# 构建数据集
X = torch.randn(100, 1)  # 输入
w = torch.tensor([2.5])  # 权重
b = torch.tensor([5.2])  # 偏置
noise = torch.randn(100, 1) * 0.1  # 噪声
y = w * X + b + noise  # 目标
dataset = TensorDataset(X, y)  # 构造数据集对象
dataloader = DataLoader(dataset, batch_size=10, shuffle=True)  # 构造数据加载器对象，batch_size为每次训练的样本数，shuffle为是否打乱数据

# 构造模型
model = nn.Linear(in_features=1, out_features=1)  #线性回归模型，1个输入，1个输出

# 损失函数和优化器
loss = nn.MSELoss()  # 均方误差损失函数
optimizer = optim.SGD(model.parameters(), lr=1e-3)  #随机梯度下降，学习率0.001

# 模型训练
loss_list = []
for epoch in range(1000):
    total_loss = 0
    train_num = 0
    for x_train, y_train in dataloader:
        # 每次训练一个batch大小的数据
        y_pred = model(x_train)  # 模型预测
        loss_value = loss(y_pred, y_train)  # 计算损失
        total_loss += loss_value.item()
        train_num += len(y_train)
        optimizer.zero_grad()  # 梯度清零
        loss_value.backward()  # 反向传播
        optimizer.step()  # 更新参数
    loss_list.append(total_loss / train_num)

print(model.weight, model.bias)  # 打印权重和偏置
plt.plot(loss_list)
plt.xlabel("epoch")
plt.ylabel("loss")
plt.show()

# 整体流程：
# 1. 构造输入与画布 
# 2. 左图绘 sigmoid 曲线 
# 3. 反向传播求导 
# 4. 右图绘导数曲线

import torch
import matplotlib.pyplot as plt
x = torch.linspace(-10, 10, 1000, requires_grad=True)  # requires_grad=True 需梯度以便求导
fig, ax = plt.subplots(1, 2)  # 1 行 2 列子图
fig.set_size_inches(12, 4)
ax[0].plot(x.data, torch.sigmoid(x).data, "purple")  # 左图：sigmoid 函数值
ax[0].set_title("sigmoid(x)")
ax[0].spines["top"].set_visible(False)
ax[0].spines["right"].set_visible(False)
ax[0].spines["left"].set_position("zero")
ax[0].spines["bottom"].set_position("zero")
ax[0].axhline(0.5, color="gray", alpha=0.7, linewidth=1)
ax[0].axhline(1, color="gray", alpha=0.7, linewidth=1)
torch.sigmoid(x).sum().backward()  # 反向传播，使 x.grad 为 sigmoid 的导数
ax[1].plot(x.data, x.grad, "purple")  # 右图：导数
ax[1].set_title("sigmoid\'(x)")
ax[1].spines["top"].set_visible(False)
ax[1].spines["right"].set_visible(False)
ax[1].spines["left"].set_position("zero")
ax[1].spines["bottom"].set_position("zero")
ax[1].set_ylim(0, 0.3)
plt.show()

# 整体流程：同 Sigmoid，生成 x → 左图 tanh、右图 tanh 导数
import torch
import matplotlib.pyplot as plt
x = torch.linspace(-5, 5, 1000, requires_grad=True)
fig, ax = plt.subplots(1, 2)
fig.set_size_inches(12, 4)
ax[0].plot(x.data, torch.tanh(x).data, "purple")
ax[0].set_title("tanh(x)")
ax[0].spines["top"].set_visible(False)
ax[0].spines["right"].set_visible(False)
ax[0].spines["left"].set_position("zero")
ax[0].spines["bottom"].set_position("zero")
ax[0].axhline(-1, color="gray", alpha=0.7, linewidth=1)
ax[0].axhline(1, color="gray", alpha=0.7, linewidth=1)
torch.tanh(x).sum().backward()  # 反向传播求 tanh 的梯度
ax[1].plot(x.data, x.grad, "purple")
ax[1].set_title("tanh\'(x)")
ax[1].spines["top"].set_visible(False)
ax[1].spines["right"].set_visible(False)
ax[1].spines["left"].set_position("zero")
ax[1].spines["bottom"].set_position("zero")
plt.show()

# 整体流程：同 Sigmoid，左图 ReLU、右图 ReLU 导数（0 左侧为 0、右侧为 1）
import torch
import matplotlib.pyplot as plt
x = torch.linspace(-5, 5, 1000, requires_grad=True)

fig, ax = plt.subplots(1, 2)
fig.set_size_inches(12, 4)
ax[0].plot(x.data, torch.relu(x).data, "purple")
ax[0].set_title("relu(x)")
ax[0].spines["top"].set_visible(False)
ax[0].spines["right"].set_visible(False)
ax[0].spines["left"].set_position("zero")
ax[0].spines["bottom"].set_position("zero")
torch.relu(x).sum().backward()  # 反向传播求 ReLU 梯度
ax[1].plot(x.data, x.grad, "purple")
ax[1].set_title("relu\'(x)")
ax[1].spines["top"].set_visible(False)
ax[1].spines["right"].set_visible(False)
ax[1].spines["left"].set_position("zero")
ax[1].spines["bottom"].set_position("zero")
plt.show()

#自定义环境 library/python3-be38bd9cb461ab775f44082e06df14e1
# 整体流程：构造一维输入 → softmax 将原始值转为概率分布（和为 1）→ 打印对比
import torch
x = torch.tensor([2.0, 1.0, 0.1])
output = torch.softmax(x, dim=0)  # dim=0：沿第 0 维（唯一维）做 softmax
print("输入：", x)
print("Softmax输出：", output)  # 各元素 ∈ (0,1)，总和 = 1
print("输出之和：", output.sum())
# 二维示例：按行做 softmax（每行和为 1）
x2 = torch.tensor([[1.0, 2.0, 3.0],
                    [1.0, 1.0, 1.0]])
output2 = torch.softmax(x2, dim=1)  # dim=1：沿列方向（每行内部）做 softmax
print("二维Softmax输出：\n", output2)
print("每行之和：", output2.sum(dim=1))  # 均为 1

# 整体流程：导入模块 → 创建全连接层（5 个输入特征，2 个输出特征）
import torch
import torch.nn as nn
linear = nn.Linear(5, 2)  # in_features=5, out_features=2，内部有 weight(2,5) 和 bias(2)

# 整体流程：建全连接层 → 分别演示 zeros_/ones_/constant_ 三种常数初始化
linear = nn.Linear(5, 2)
# 全部参数初始化为 0（zeros_ 为原地操作，下划线表示修改 tensor 自身）
nn.init.zeros_(linear.weight)
print(linear.weight)
nn.init.ones_(linear.weight)  # 全部置 1
print(linear.weight)
nn.init.constant_(linear.weight, 10)  # 第二个参数 val：常数
print(linear.weight)

# 整体流程：建层 → 权重初始化为单位矩阵（要求二维，行/列取较小者构成单位块）
linear = nn.Linear(5, 2)
nn.init.eye_(linear.weight)  # weight 形状 (2,5)，得到 2x2 单位块
print(linear.weight)

# 整体流程：建层 → 按正态分布初始化权重
linear = nn.Linear(5, 2)
nn.init.normal_(linear.weight, mean=0.0, std=1.0)
print(linear.weight)

# 整体流程：建层 → 在区间 [a, b] 上均匀分布初始化
linear = nn.Linear(5, 2)
nn.init.uniform_(linear.weight, a=0, b=10)  # a 下界，b 上界
print(linear.weight)

# 整体流程：建层 → 分别用 Xavier 正态、Xavier 均匀初始化
linear = nn.Linear(5, 2)
nn.init.xavier_normal_(linear.weight)  # 按 n_in+n_out 缩放的正态分布
print(linear.weight)
nn.init.xavier_uniform_(linear.weight)  # 按 n_in+n_out 缩放的均匀分布
print(linear.weight)

# 整体流程：建层 → 分别用 He（Kaiming）正态、均匀初始化，适用于 ReLU
linear = nn.Linear(5, 2)
nn.init.kaiming_normal_(linear.weight)  # 默认 mode='fan_in', nonlinearity='relu'
print(linear.weight)
nn.init.kaiming_uniform_(linear.weight)
print(linear.weight)

# 整体流程：实例化 Dropout(p=0.5) → 生成输入 → 前向一次看“失活”效果（约一半置 0、其余放大）
import torch
dropout = torch.nn.Dropout(p=0.5)  # p：被置 0 的概率，训练时生效
x = torch.randint(1, 10, (10,), dtype=torch.float32)  # 随机整数张量，仅作演示
print("Dropout前：", x)
print("Dropout后：", dropout(x))  # 每次调用随机掩码不同

# 整体流程：
# 1. 继承 nn.Module 定义模型（__init__ 建层与初始化，forward 写前向） 
# 2. 实例化并前向 
# 3. 用 named_parameters/state_dict 查看参数
import torch
import torch.nn as nn
class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()  # 必须调用，注册子模块与参数
        self.linear1 = nn.Linear(3, 4)  # 第1隐藏层：3 入 4 出
        nn.init.xavier_normal_(self.linear1.weight)  # Xavier 正态，适合 Tanh
        self.linear2 = nn.Linear(4, 4)
        nn.init.kaiming_normal_(self.linear2.weight)  # He 正态，适合 ReLU
        self.out = nn.Linear(4, 2)  # 输出层：2 类
    def forward(self, x):
        x = self.linear1(x)
        x = torch.tanh(x)  # 激活
        x = self.linear2(x)
        x = torch.relu(x)
        x = self.out(x)
        x = torch.softmax(x, dim=1)  # dim=1：在特征维做 softmax，每行和为 1
        return x
model = Model()
output = model(torch.randn(10, 3))  # 10 样本、3 特征，randn 标准正态
print("输出：\\n", output)
print("模型参数：")
for name, param in model.named_parameters():  # 返回 (名字, 张量)
    print(name, param)
print("模型参数：\\n", model.state_dict())  # 有序字典，用于保存/加载

# 整体流程：导入 summary → 传入已建好的 model、输入形状、batch_size、设备，打印结构与参数量
from torchsummary import summary
summary(model, input_size=(3,), batch_size=10, device="cpu")  # (3,) 表示单样本 3 维输入

# 整体流程：用 Sequential 按顺序堆叠层 → 定义 init_weights 并用 apply 初始化 → 前向得到输出
import torch
import torch.nn as nn
model = nn.Sequential(  # *args：按顺序的多个 Module，输入依次经过
    nn.Linear(3, 4),
    nn.Tanh(),
    nn.Linear(4, 4),
    nn.ReLU(),
    nn.Linear(4, 2),
    nn.Softmax(dim=1),  # dim=1 在特征维做 softmax
)
def init_weights(m):  # 每个子模块会作为 m 传入
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
        m.bias.data.fill_(0.01)  # 偏置置为 0.01
model.apply(init_weights)  # 对每个子模块调用 init_weights 一次
output = model(torch.randn(10, 3))
print("输出：\\n", output)

# 整体流程：准备真实标签与预测概率（经 sigmoid）→ 实例化 BCELoss → 计算标量损失
import torch
import torch.nn as nn
target = torch.tensor([[1], [0], [0]], dtype=torch.float32)  # 真实标签 0/1
input = torch.randn((3, 1))  # 3 样本 1 维 logits
prediction = torch.sigmoid(input)  # BCELoss 要求输入为概率
loss = nn.BCELoss()  # reduction 默认 'mean'
print(loss(prediction, target))  # 传入 (预测, 目标)，顺序不可反

# 整体流程：准备 logits 与标签（或软标签）→ 实例化 CrossEntropyLoss → 计算损失（内部含 Softmax，无需先 softmax）
import torch
import torch.nn as nn
# 用法一：目标为类别索引（长整型，范围 [0, C-1]）
target = torch.tensor([1, 0, 3, 2, 5, 4])  # 6 个样本的类别下标
input = torch.randn((6, 8))  # 6 样本 8 类，未做 softmax 的 logits
loss = nn.CrossEntropyLoss()
print(loss(input, target))
# 用法二：目标为概率分布（软标签）
target = torch.randn(6, 8).softmax(dim=1)  # 每行和为 1
input = torch.randn((6, 8))
print(loss(input, target))

# 整体流程：定义模型（手动赋 weight/bias）→ 前向算 loss → backward → 优化器 step → zero_grad；演示一次迭代
import torch
import torch.nn as nn
import torch.optim as optim

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.linear1 = nn.Linear(5, 3)  # 5 入 3 出
        self.linear1.weight.data = torch.tensor(
            [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9],
             [0.10, 1.1, 1.2], [1.3, 1.4, 1.5]]).T  # 手动设权重，.T 转成 (3,5)
        self.linear1.bias.data = torch.tensor([1.0, 2.0, 3.0])
    def forward(self, x):
        return self.linear1(x)

model = Model()
X = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], dtype=torch.float)  # 2 样本 5 特征
target = torch.tensor([[0, 0, 0], [0, 0, 0]], dtype=torch.float)
output = model(X)

loss_fn = nn.MSELoss()  # 均方误差，reduction 默认 'mean'
loss_fn(output, target).backward()  # 反向传播，梯度写入各 param.grad
optimizer = optim.SGD(model.parameters(), lr=1)  # params：要更新的参数，lr 学习率
optimizer.step()  # 按梯度更新参数
optimizer.zero_grad()  # 清空梯度，下次 backward 前必须调
for i in model.state_dict():
    print(i, model.state_dict()[i])

# 辅助函数：梯度下降迭代，返回优化轨迹 X_arr（需在外部定义 w、n_iters）
def gradient_descent(X, optimizer, n_iters):
    import numpy as np
    X_arr = X.detach().numpy().copy()
    for epoch in range(n_iters):
        y = X**2 @ w
        y.backward()
        optimizer.step()
        optimizer.zero_grad()
        X_arr = np.vstack([X_arr, X.detach().numpy()])
    return X_arr

# 整体流程：定义变量与优化器 → 用 gradient_descent 跑 SGD 与 Momentum → 画等高线+轨迹对比
import numpy as np
import matplotlib.pyplot as plt
import torch

X = torch.tensor([-7.0, 2.0], requires_grad=True)  # 初始点
w = torch.tensor([[0.05], [1.0]], requires_grad=True)  # 目标函数系数，不更新
lr = 1e-2
n_iters = 500

# 普通 SGD（无动量）
X_clone = X.clone().detach().requires_grad_(True)
X_arr1 = gradient_descent(X_clone, torch.optim.SGD([X_clone], lr=lr), n_iters=n_iters)
plt.plot(X_arr1[:, 0], X_arr1[:, 1], "r")

# 动量法：momentum=0.9 表示历史梯度权重
X_clone = X.clone().detach().requires_grad_(True)
X_arr2 = gradient_descent(X_clone, torch.optim.SGD([X_clone], lr=lr, momentum=0.9), n_iters=n_iters)
plt.plot(X_arr2[:, 0], X_arr2[:, 1], "b")

x1_grid, x2_grid = np.meshgrid(np.linspace(-7, 7, 100), np.linspace(-2, 2, 100))
y_grid = w.detach().numpy()[0, 0] * x1_grid**2 + w.detach().numpy()[1, 0] * x2_grid**2
plt.contour(x1_grid, x2_grid, y_grid, levels=30, colors="gray")
plt.legend(["SGD", "Momentum"])
plt.show()

# 整体流程：建优化器与 StepLR → 每步 optimizer.step 后 scheduler_lr.step() → 左图轨迹、右图学习率曲线
import numpy as np
import matplotlib.pyplot as plt
import torch

X = torch.tensor([-7.0, 2.0], dtype=torch.float32, requires_grad=True)
w = torch.tensor([[0.05], [1.0]], requires_grad=True)
lr = 0.9
n_iters = 1000
optimizer = torch.optim.SGD([X], lr=lr)
scheduler_lr = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.7)  # 每 20 步 lr*=0.7
X_arr = X.detach().numpy().copy()
lr_list = []

for epoch in range(n_iters):
    y = X**2 @ w
    y.backward()
    optimizer.step()
    optimizer.zero_grad()
    X_arr = np.vstack([X_arr, X.detach().numpy()])
    lr_list.append(optimizer.param_groups[0]["lr"])  # 当前学习率
    scheduler_lr.step()  # 每 epoch 调用一次，到 step_size 的倍数时衰减

plt.rcParams["font.sans-serif"] = ["KaiTi"]
plt.rcParams["axes.unicode_minus"] = False
fig, ax = plt.subplots(1, 2, figsize=(12, 4))
x1_grid, x2_grid = np.meshgrid(np.linspace(-7, 7, 100), np.linspace(-2, 2, 100))
y_grid = w.detach().numpy()[0, 0] * x1_grid**2 + w.detach().numpy()[1, 0] * x2_grid**2
ax[0].contour(x1_grid, x2_grid, y_grid, levels=30, colors="gray")
ax[0].plot(X_arr[:, 0], X_arr[:, 1], "r")
ax[0].set_title("梯度下降过程")
ax[1].plot(lr_list, "k")
ax[1].set_title("学习率衰减")
plt.show()

# 整体流程：MultiStepLR 在 milestones 指定的 epoch 处衰减（如 10、50、200 步时 lr*=0.7）
import numpy as np
import matplotlib.pyplot as plt
import torch

X = torch.tensor([-7.0, 2.0], dtype=torch.float32, requires_grad=True)
w = torch.tensor([[0.05], [1.0]], requires_grad=True)
lr = 0.9
n_iters = 400
optimizer = torch.optim.SGD([X], lr=lr)
scheduler_lr = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[10, 50, 200], gamma=0.7)
X_arr = X.detach().numpy().copy()
lr_list = []

for epoch in range(n_iters):
    y = X**2 @ w
    y.backward()
    optimizer.step()
    optimizer.zero_grad()
    X_arr = np.vstack([X_arr, X.detach().numpy()])
    lr_list.append(optimizer.param_groups[0]["lr"])
    scheduler_lr.step()

plt.rcParams["font.sans-serif"] = ["KaiTi"]
plt.rcParams["axes.unicode_minus"] = False
fig, ax = plt.subplots(1, 2, figsize=(12, 4))
x1_grid, x2_grid = np.meshgrid(np.linspace(-7, 7, 100), np.linspace(-2, 2, 100))
y_grid = w.detach().numpy()[0, 0] * x1_grid**2 + w.detach().numpy()[1, 0] * x2_grid**2
ax[0].contour(x1_grid, x2_grid, y_grid, levels=30, colors="gray")
ax[0].plot(X_arr[:, 0], X_arr[:, 1], "r")
ax[0].set_title("梯度下降过程")
ax[1].plot(lr_list, "k")
ax[1].set_title("学习率衰减")
plt.show()

# 整体流程：ExponentialLR 每步 lr *= gamma（0.99），即指数衰减
import numpy as np
import matplotlib.pyplot as plt
import torch

X = torch.tensor([-7.0, 2.0], dtype=torch.float32, requires_grad=True)
w = torch.tensor([[0.05], [1.0]], requires_grad=True)
lr = 0.9
n_iters = 400
optimizer = torch.optim.SGD([X], lr=lr)
scheduler_lr = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.99)  # 每 epoch lr *= 0.99
X_arr = X.detach().numpy().copy()
lr_list = []

for epoch in range(n_iters):
    y = X**2 @ w
    y.backward()
    optimizer.step()
    optimizer.zero_grad()
    X_arr = np.vstack([X_arr, X.detach().numpy()])
    lr_list.append(optimizer.param_groups[0]["lr"])
    scheduler_lr.step()

plt.rcParams["font.sans-serif"] = ["KaiTi"]
plt.rcParams["axes.unicode_minus"] = False
fig, ax = plt.subplots(1, 2, figsize=(12, 4))
x1_grid, x2_grid = np.meshgrid(np.linspace(-7, 7, 100), np.linspace(-2, 2, 100))
y_grid = w.detach().numpy()[0, 0] * x1_grid**2 + w.detach().numpy()[1, 0] * x2_grid**2
ax[0].contour(x1_grid, x2_grid, y_grid, levels=30, colors="gray")
ax[0].plot(X_arr[:, 0], X_arr[:, 1], "r")
ax[0].set_title("梯度下降过程")
ax[1].plot(lr_list, "k")
ax[1].set_title("学习率衰减")
plt.show()

# 整体流程：定义 adagrad 手动实现与 gradient_descent → 同一起点跑 SGD / Adagrad / 手写 AdaGrad → 画三条轨迹
import numpy as np
import matplotlib.pyplot as plt
import torch

def adagrad(X, lr, n_iters):
    """AdaGrad 手动实现：H 累积梯度平方和，更新时用 lr/sqrt(H) 做自适应步长"""
    X_arr = X.detach().numpy().copy()
    H = torch.zeros_like(X)  # 历史梯度平方和
    for epoch in range(n_iters):
        grad = 2 * X * w.T  # 当前梯度（对该二次函数求导）
        grad.squeeze_()
        H += grad**2
        X.data -= lr / (torch.sqrt(H) + 1e-8) * grad  # 1e-8 防除零
        X_arr = np.vstack([X_arr, X.detach().numpy()])
    return X_arr

def gradient_descent(X, optimizer, n_iters):
    X_arr = X.detach().numpy().copy()
    for epoch in range(n_iters):
        y = X**2 @ w
        y.backward()
        optimizer.step()
        optimizer.zero_grad()
        X_arr = np.vstack([X_arr, X.detach().numpy()])
    return X_arr

X = torch.tensor([-7.0, 2.0], dtype=torch.float32, requires_grad=True)
w = torch.tensor([[0.05], [1.0]], requires_grad=True)
lr = 0.9
n_iters = 500
X_clone = X.clone().detach().requires_grad_(True)
X_arr1 = gradient_descent(X_clone, torch.optim.SGD([X_clone], lr=lr), n_iters=n_iters)
plt.plot(X_arr1[:, 0], X_arr1[:, 1], "r")
X_clone = X.clone().detach().requires_grad_(True)
X_arr2 = gradient_descent(X_clone, torch.optim.Adagrad([X_clone], lr=lr), n_iters=n_iters)  # Adagrad 自适应 lr
plt.plot(X_arr2[:, 0], X_arr2[:, 1], "b")
X_clone = X.clone().detach().requires_grad_(True)
X_arr1 = adagrad(X_clone, lr=lr, n_iters=n_iters)
plt.plot(X_arr1[:, 0], X_arr1[:, 1], c="orange", linestyle="--", linewidth=3)
x1_grid, x2_grid = np.meshgrid(np.linspace(-7, 7, 100), np.linspace(-2, 2, 100))
y_grid = w.detach().numpy()[0, 0] * x1_grid**2 + w.detach().numpy()[1, 0] * x2_grid**2
plt.contour(x1_grid, x2_grid, y_grid, levels=30, colors="gray")
plt.legend(["SGD", "AdaGrad", "Manual AdaGrad"])
plt.show()

# 整体流程：手写 RMSProp（H 为梯度平方的指数移动平均）与 gradient_descent → 对比 SGD / RMSProp / 手写
import numpy as np
import matplotlib.pyplot as plt
import torch

def rmspropp(X, lr, alpha, n_iters):
    """RMSProp：H = alpha*H + (1-alpha)*grad^2，步长 lr/sqrt(H)，alpha 为衰减系数"""
    X_arr = X.detach().numpy().copy()
    H = torch.zeros_like(X)
    for epoch in range(n_iters):
        grad = 2 * X * w.T
        grad.squeeze_()
        H = alpha * H + (1 - alpha) * grad**2  # 指数移动平均，非简单累加
        X.data -= lr / (torch.sqrt(H) + 1e-8) * grad
        X_arr = np.vstack([X_arr, X.detach().numpy()])
    return X_arr

def gradient_descent(X, optimizer, n_iters):
    X_arr = X.detach().numpy().copy()
    for epoch in range(n_iters):
        y = X**2 @ w
        y.backward()
        optimizer.step()
        optimizer.zero_grad()
        X_arr = np.vstack([X_arr, X.detach().numpy()])
    return X_arr

X = torch.tensor([-7.0, 2.0], dtype=torch.float32, requires_grad=True)
w = torch.tensor([[0.05], [1.0]], requires_grad=True)
lr = 1e-1
n_iters = 1000
X_clone = X.clone().detach().requires_grad_(True)
X_arr1 = gradient_descent(X_clone, torch.optim.SGD([X_clone], lr=lr), n_iters=n_iters)
plt.plot(X_arr1[:, 0], X_arr1[:, 1], "r")
X_clone = X.clone().detach().requires_grad_(True)
X_arr2 = gradient_descent(X_clone, torch.optim.RMSprop([X_clone], lr=lr, alpha=0.99), n_iters=n_iters)  # alpha 平滑系数
plt.plot(X_arr2[:, 0], X_arr2[:, 1], "b")
X_clone = X.clone().detach().requires_grad_(True)
X_arr1 = rmspropp(X_clone, lr=lr, alpha=0.99, n_iters=n_iters)
plt.plot(X_arr1[:, 0], X_arr1[:, 1], c="orange", linestyle="--", linewidth=3)
x1_grid, x2_grid = np.meshgrid(np.linspace(-7, 7, 100), np.linspace(-2, 2, 100))
y_grid = w.detach().numpy()[0, 0] * x1_grid**2 + w.detach().numpy()[1, 0] * x2_grid**2
plt.contour(x1_grid, x2_grid, y_grid, levels=30, colors="gray")
plt.legend(["SGD", "RMSProp", "Manual RMSProp"])
plt.show()

# 整体流程：手写 Adam（V 一阶矩、H 二阶矩，偏置修正后更新）与 gradient_descent → 对比 SGD / Adam / 手写
import numpy as np
import matplotlib.pyplot as plt
import torch

def adam(X, lr, betas, n_iters):
    """Adam：V 一阶矩，H 二阶矩；V_hat/H_hat 为偏置修正，betas=(β1, β2) 通常 (0.9, 0.999)"""
    X_arr = X.detach().numpy().copy()
    V = torch.zeros_like(X)
    H = torch.zeros_like(X)
    for epoch in range(n_iters):
        grad = 2 * X * w.T
        grad.squeeze_()
        V = betas[0] * V + (1 - betas[0]) * grad  # 一阶矩
        H = betas[1] * H + (1 - betas[1]) * grad**2  # 二阶矩
        V_hat = V / (1 - betas[0] ** (epoch + 1))  # 偏置修正
        H_hat = H / (1 - betas[1] ** (epoch + 1))
        X.data -= lr * V_hat / (torch.sqrt(H_hat) + 1e-8)
        X_arr = np.vstack([X_arr, X.detach().numpy()])
    return X_arr

def gradient_descent(X, optimizer, n_iters):
    X_arr = X.detach().numpy().copy()
    for epoch in range(n_iters):
        y = X**2 @ w
        y.backward()
        optimizer.step()
        optimizer.zero_grad()
        X_arr = np.vstack([X_arr, X.detach().numpy()])
    return X_arr

X = torch.tensor([-7.0, 2.0], dtype=torch.float32, requires_grad=True)
w = torch.tensor([[0.05], [1.0]], requires_grad=True)
lr = 1e-1
n_iters = 1000
X_clone = X.clone().detach().requires_grad_(True)

X_arr1 = gradient_descent(X_clone, torch.optim.SGD([X_clone], lr=lr), n_iters=n_iters)
plt.plot(X_arr1[:, 0], X_arr1[:, 1], "r")
X_clone = X.clone().detach().requires_grad_(True)

X_arr2 = gradient_descent(X_clone, torch.optim.Adam([X_clone], lr=lr, betas=(0.9, 0.999)), n_iters=n_iters)  # betas 一阶、二阶矩衰减
plt.plot(X_arr2[:, 0], X_arr2[:, 1], "b")
X_clone = X.clone().detach().requires_grad_(True)

X_arr1 = adam(X_clone, lr=lr, betas=(0.9, 0.999), n_iters=n_iters)
plt.plot(X_arr1[:, 0], X_arr1[:, 1], c="orange", linestyle="--", linewidth=3, alpha=0.7)
x1_grid, x2_grid = np.meshgrid(np.linspace(-7, 7, 100), np.linspace(-2, 2, 100))
y_grid = w.detach().numpy()[0, 0] * x1_grid**2 + w.detach().numpy()[1, 0] * x2_grid**2
plt.contour(x1_grid, x2_grid, y_grid, levels=30, colors="gray")
plt.legend(["SGD", "Adam", "Manual Adam"])
plt.show()

# 整体流程：读数据 → 划分特征/目标与数值/类别 → train_test_split → 数值用均值填充+标准化、类别用 NaN 填充+独热 → ColumnTransformer 组合 → TensorDataset
def create_dataset():
    import pandas as pd
    import torch
    from sklearn.model_selection import train_test_split
    from sklearn.pipeline import Pipeline
    from sklearn.impute import SimpleImputer
    from sklearn.preprocessing import StandardScaler, OneHotEncoder
    from sklearn.compose import ColumnTransformer
    from torch.utils.data import TensorDataset
    data = pd.read_csv("data/house_prices.csv")
    data.drop(["Id"], axis=1, inplace=True)  # axis=1 按列删，inplace 原地修改
    X = data.drop("SalePrice", axis=1)
    y = data["SalePrice"]
    numerical_features = X.select_dtypes(exclude="object").columns  # 数值列
    categorical_features = X.select_dtypes(include="object").columns  # 类别列
    x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    numerical_transformer = Pipeline(
        steps=[
            ("fillna", SimpleImputer(strategy="mean")),  # 缺失值用均值填
            ("std", StandardScaler()),  # 标准化
        ]
    )
    categorical_transformer = Pipeline(
        steps=[
            ("fillna", SimpleImputer(strategy="constant", fill_value="NaN")),
            ("onehot", OneHotEncoder(handle_unknown="ignore")),  # 未知类别忽略
        ]
    )
    preprocessor = ColumnTransformer(
        transformers=[
            ("num", numerical_transformer, numerical_features),
            ("cat", categorical_transformer, categorical_features),
        ]
    )
    x_train = pd.DataFrame(preprocessor.fit_transform(x_train).toarray(), columns=preprocessor.get_feature_names_out())
    x_test = pd.DataFrame(preprocessor.transform(x_test).toarray(), columns=preprocessor.get_feature_names_out())
    train_dataset = TensorDataset(torch.tensor(x_train.values).float(), torch.tensor(y_train.values).float())  # 特征+标签成对
    test_dataset = TensorDataset(torch.tensor(x_test.values).float(), torch.tensor(y_test.values).float())
    return train_dataset, test_dataset, x_train.shape[1]  # 最后一维为特征数
train_dataset, test_dataset, feature_num = create_dataset()

# 整体流程：全连接 → BatchNorm → ReLU → Dropout → 输出 1 维（房价）
model = nn.Sequential(
    nn.Linear(feature_num, 128),  # 输入特征数由 create_dataset 得到
    nn.BatchNorm1d(128),  # 一维 BN，稳定训练
    nn.ReLU(),
    nn.Dropout(0.2),  # 20% 失活防过拟合
    nn.Linear(128, 1),  # 回归输出 1 个数
)

# 整体流程：对预测与目标取 log 再算 RMSE，使相对误差更受关注；clamp 保证 log 合法
def log_rmse(pred, target):
    mse = nn.MSELoss()
    pred.squeeze_()  # 去掉多余维
    pred = torch.clamp(pred, 1, float("inf"))  # 限制 ≥1，避免 log≤0
    return torch.sqrt(mse(torch.log(pred), torch.log(target)))

# 整体流程：Xavier 初始化 → 每 epoch 训练（DataLoader 批训练、log_rmse、backward、step）→ 验证（eval+no_grad）→ 记录并画 loss 曲线
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

def train(model, train_dataset, test_dataset, lr, epoch_num, batch_size, device):
    def init_weight(layer):
        if type(layer) == nn.Linear:
            nn.init.xavier_normal_(layer.weight)

    model.apply(init_weight)
    model = model.to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    train_loss_list = []
    test_loss_list = []

    for epoch in range(epoch_num):
        model.train()  # Dropout/BatchNorm 按训练行为
        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
        train_loss_accumulate = 0

        for batch_count, (X, y) in enumerate(train_loader):
            X, y = X.to(device), y.to(device)
            output = model(X)
            loss_value = log_rmse(output, y)
            optimizer.zero_grad()
            loss_value.backward()
            optimizer.step()
            train_loss_accumulate += loss_value.item()
            print(f"\repoch:{epoch:0>3}[{'='*int((batch_count+1)/len(train_loader)*50):<50}]", end="")
        this_train_loss = train_loss_accumulate / len(train_loader)
        train_loss_list.append(this_train_loss)

        model.eval()  # 评估模式，Dropout 关闭等
        test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=True)
        test_loss_accumulate = 0
        with torch.no_grad():  # 验证不计算梯度
            for X, y in test_loader:
                X, y = X.to(device), y.to(device)
                output = model(X)
                test_loss_accumulate += log_rmse(output, y).item()  # 用当前 batch 的 loss
        this_test_loss = test_loss_accumulate / len(test_loader)
        test_loss_list.append(this_test_loss)

        print(f" train_loss:{this_train_loss:.6f}, test_loss:{this_test_loss:.6f}")

    return train_loss_list, test_loss_list

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_loss_list, test_loss_list = train(model, train_dataset, test_dataset, 0.1, 200, 64, device)
plt.plot(train_loss_list, "r-", label="train_loss", linewidth=3)
plt.plot(test_loss_list, "k--", label="test_loss", linewidth=2)
plt.legend()
plt.show()

import torch
import matplotlib.pyplot as plt

img = plt.imread("data/duck.jpg") # 改为其他任意图片均可
print("图片数据形状：", img.shape)
input = torch.tensor(img).permute(2, 0, 1).float() # permute(2, 0, 1) 用于将 (H, W, C) 格式的图像数据转换为 (C, H, W) 格式，以便符合 Conv2d 层的输入要求
print("输入特征图形状：", input.shape)
conv = torch.nn.Conv2d(in_channels=3, out_channels=3, kernel_size=9, stride=3, padding=0, bias=False) # bias=False 用于简化模型，去除偏置项
output = conv(input)
print("输出特征图形状：", output.shape)
output = torch.clamp(output.int(), 0, 255).permute(1, 2, 0).detach().numpy()

fig, ax = plt.subplots(1, 2, figsize=(10, 5))
ax[0].imshow(img)
ax[1].imshow(output)
plt.axis("off")
plt.show()

import torch
import matplotlib.pyplot as plt

img = plt.imread("../data/duck.jpg")
print("图片数据形状：", img.shape)

input = torch.tensor(img).permute(2, 0, 1).float()
print("输入特征图形状：", input.shape)

conv = torch.nn.Conv2d(
    in_channels=3, # 输入通道数
    out_channels=3, # 输出通道数
    kernel_size=4, # 卷积核大小
    stride=1, # 步长
    padding=0, # 填充
    bias=False # 禁用偏置项
)

output1 = conv(input)
print("卷积后输出特征图形状：", output1.shape)

pool = torch.nn.AvgPool2d(
    kernel_size=6, # 池化核大小
    stride=6, # 步长
    padding=1 # 填充
)
output2 = pool(output1)
print("池化后输出特征图形状：", output2.shape)

output1 = torch.clamp(output1.int(), 0, 255)
output1 = output1.permute(1, 2, 0).detach().numpy()
output2 = torch.clamp(output2.int(), 0, 255)
output2 = output2.permute(1, 2, 0).detach().numpy()

fig, ax = plt.subplots(1, 3, figsize=(15, 5))
ax[0].imshow(img)
ax[1].imshow(output1)
ax[2].imshow(output2)
plt.axis("off")
plt.show()

import torch
import pandas as pd
import matplotlib.pyplot as plt
from torch.utils.data import TensorDataset, DataLoader

# ---------- 1. 读取 CSV ----------
# 每行：第 1 列为标签(0~9)，第 2~785 列为 784 像素(28×28 展平)
fashion_mnist_train = pd.read_csv("data/fashion-mnist_train.csv")
fashion_mnist_test = pd.read_csv("data/fashion-mnist_test.csv")

# ---------- 2. 转为 Tensor 并调整为 NCHW ----------
# 像素 iloc[:, 1:] → float32，reshape 为 (N, 1, 28, 28)；标签 iloc[:, 0] → int64
X_train = torch.tensor(fashion_mnist_train.iloc[:, 1:].values, dtype=torch.float32).reshape(-1, 1, 28, 28)
y_train = torch.tensor(fashion_mnist_train.iloc[:, 0].values, dtype=torch.int64)
X_test = torch.tensor(fashion_mnist_test.iloc[:, 1:].values, dtype=torch.float32).reshape(-1, 1, 28, 28)
y_test = torch.tensor(fashion_mnist_test.iloc[:, 0].values, dtype=torch.int64)

# ---------- 3. 可选：查看某张图 ----------
plt.imshow(X_train[12345, 0, :, :], cmap="gray")  # 第 0 通道即灰度
plt.show()

# ---------- 4. 构建 Dataset，供 DataLoader 按 batch 读取 ----------
train_dataset = TensorDataset(X_train, y_train)
test_dataset = TensorDataset(X_test, y_test)

import torch
import torch.nn as nn

# 按结构顺序堆叠：卷积 → 激活 → 池化 → … → 展平 → 全连接
model = nn.Sequential(
    # 第一段：1 通道 → 6 通道，5×5 卷积，padding=2 使高宽不变仍为 28×28
    nn.Conv2d(1, 6, kernel_size=5, padding=2),
    nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),   # 28×28 → 14×14
    # 第二段：6 → 16 通道，5×5 卷积（无 padding），再池化
    nn.Conv2d(6, 16, kernel_size=5),
    nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),   # 10×10 → 5×5，展平后 16×5×5=400
    nn.Flatten(),
    # 全连接：400 → 120 → 84 → 10（10 类）
    nn.Linear(400, 120),
    nn.Sigmoid(),
    nn.Linear(120, 84),
    nn.Sigmoid(),
    nn.Linear(84, 10),
)

# 调试用：逐层前向，打印每层输出形状，便于核对 400 等尺寸
X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)
for layer in model:
    X = layer(X)
    print(f"{layer.__class__.__name__:<12} output shape: {X.shape}")

def train(model, train_dataset, test_dataset, lr, epoch_num, batch_size, device):
    # ---------- 初始化 ----------
    def init_weights(layer):
        if type(layer) == nn.Linear or type(layer) == nn.Conv2d:
            nn.init.xavier_uniform_(layer.weight)
    model.apply(init_weights)
    model.to(device)
    loss_fn = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=lr)

    for epoch in range(epoch_num):
        # ---------- 训练阶段 ----------
        model.train()  # 启用 Dropout 等训练行为
        train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
        loss_accumulate = 0.0
        train_correct_accumulate = 0
        for batch_count, (X, y) in enumerate(train_loader):
            X, y = X.to(device), y.to(device)
            output = model(X)
            loss_value = loss_fn(output, y)
            optimizer.zero_grad()
            loss_value.backward()
            optimizer.step()
            loss_accumulate += loss_value.item()
            _, pred = output.max(1)  # 预测类别
            train_correct_accumulate += pred.eq(y).sum().item()
            # 进度条
            print(f"\repoch:{epoch:02d}[{'='*int((batch_count+1)/len(train_loader)*50):<50}]", end="")
        this_loss = loss_accumulate / len(train_loader)
        this_train_acc = train_correct_accumulate / len(train_dataset)

        # ---------- 验证阶段 ----------
        model.eval()  # 关闭 Dropout 等，使用确定性子层
        test_loader = DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)
        test_correct_accumulate = 0
        with torch.no_grad():  # 不计算梯度，省显存、提速
            for X, y in test_loader:
                X, y = X.to(device), y.to(device)
                output = model(X)
                _, pred = output.max(1)
                test_correct_accumulate += pred.eq(y).sum().item()
        this_test_acc = test_correct_accumulate / len(test_dataset)
        print(f" loss:{this_loss:.6f}, train_acc:{this_train_acc:.6f}, test_acc:{this_test_acc:.6f}")

# 有 GPU 用 cuda，否则 cpu；按 batch 训练
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train(model, train_dataset, test_dataset, lr=0.9, epoch_num=20, batch_size=256, device=device)