【神经网络与深度学习day04-线性回归】

关于神经网络深度学习的几个实验 目录 前言 一、MNIST-全连接 二、CNN卷积神经网络 三、RNN-文本分类 四、CGAN-MNIST-数字识别 五、ResNet-残差神经网络 Stack-AE AutoEncoder 六、Stack-AE AutoEncoder 总结 前言 提示:这里可以添加本文要记录的大概内容: 例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。 提示:以下是本篇文章正文内容,下面案例可供参考 一、MNIST 阅读详情


一、基于Logistic函数回归的二分类任务

1.1数据集构建

1.1.1导入基本库

import math
import copy 
import torch
import numpy as np

Logistic函数定义为:
在这里插入图片描述

1.1.2生成带噪音的弯月形状数据集函数

def make_moons(n_samples=1000, shuffle=True, noise=None):
    """
    生成带噪音的弯月形状数据
    输入:
        - n_samples:数据量大小,数据类型为int
        - shuffle:是否打乱数据,数据类型为bool
        - noise:以多大的程度增加噪声,数据类型为None或float,noise为None时表示不增加噪声
    输出:
        - X:特征数据,shape=[n_samples,2]
        - y:标签数据, shape=[n_samples]
    """
    #将采样数目对半分,每个类别n_samples//2个数目
    n_samples_out = n_samples // 2
    n_samples_in = n_samples - n_samples_out

    # 采集第1类数据,特征为(x,y)
    # 使用'torch.linspace'在0到pi上均匀取n_samples_out个值
    # 使用'torch.cos'计算上述取值的余弦值作为特征1,使用'torch.sin'计算上述取值的正弦值作为特征2
    outer_circ_x = torch.cos(torch.linspace(0, math.pi, n_samples_out))
    outer_circ_y = torch.sin(torch.linspace(0, math.pi, n_samples_out))

    inner_circ_x = 1 - torch.cos(torch.linspace(0, math.pi, n_samples_in))
    inner_circ_y = 0.5 - torch.sin(torch.linspace(0, math.pi, n_samples_in))
    
    print('outer_circ_x.shape:', outer_circ_x.shape, 'outer_circ_y.shape:', outer_circ_y.shape)
    print('inner_circ_x.shape:', inner_circ_x.shape, 'inner_circ_y.shape:', inner_circ_y.shape)
    
    # 使用'torch.concat'将两类数据的特征1和特征2分别延维度0拼接在一起,得到全部特征1和特征2
    # 使用'torch.stack'将两类特征延维度1堆叠在一起
    X = torch.stack(
        [torch.cat([outer_circ_x, inner_circ_x]),
        torch.cat([outer_circ_y, inner_circ_y])],
        dim=1
    )

    print('after concat shape:', torch.cat([outer_circ_x, inner_circ_x]).shape)
    print('X shape:', X.shape)

    # 使用'torch. zeros'将第一类数据的标签全部设置为0
    # 使用'torch. ones'将第一类数据的标签全部设置为1
    y = torch.cat(
        [torch.zeros([n_samples_out]), torch.ones([n_samples_in])]
    )

    print('y shape:', y.shape)

    # 如果shuffle为True,将所有数据打乱
    if shuffle:
        # 使用'torch.randperm'生成一个数值在0到X.shape[0],随机排列的一维Tensor做索引值,用于打乱数据
        idx = torch.randperm(X.shape[0])
        X = X[idx]
        y = y[idx]

    # 如果noise不为None,则给特征值加入噪声
    if noise is not None:
        # 使用'torch.normal'生成符合正态分布的随机Tensor作为噪声,并加到原始特征上
        X += torch.normal(mean=0.0, std=noise, size=X.shape)

    return X, y

1.1.3采集样本测试函数

#采集1000个样本点
n_samples = 1000
X, y = make_moons(n_samples=n_samples, shuffle=True, noise=0.5)

1.1.4可视化数据集

其中,为了方便使用,我们使用到了Jupyter,而%matplotlib inline这一行代码可有可无哈。

# 可视化生产的数据集,不同颜色代表不同类别
%matplotlib inline
import matplotlib.pyplot as plt

plt.figure(figsize=(5,5))
plt.scatter(x=X[:, 0].tolist(), y=X[:, 1].tolist(), marker='*', c=y.tolist())
plt.xlim(-3,4)
plt.ylim(-3,4)
plt.savefig('linear-dataset-vis.pdf')
plt.show()

可视化:
在这里插入图片描述

1.1.5划分训练集、验证集、测试集

#拆分训练集,验证集,测试集
num_train = 640  #训练集个数
num_dev = 160    #验证集个数
num_test = 200   #测试集个数

X_train, y_train = X[:num_train], y[:num_train]
X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]

y_train = y_train.reshape([-1,1])
y_dev = y_dev.reshape([-1,1])
y_test = y_test.reshape([-1,1])

1.2模型构建

1.2.1定义Logistic函数

#3.1.2
#我们基于Logistic函数构建线性回归的模型
# 定义Logistic函数
def logistic(x):
    return 1 / (1 + torch.exp(-x))

# 在[-10,10]的范围内生成一系列的输入值,用于绘制函数曲线
x = torch.linspace(-10, 10, 10000)
plt.figure()
plt.plot(x.tolist(), logistic(x).tolist(), color="#E20079", label="Logistic Function")
# 设置坐标轴
ax = plt.gca()
# 取消右侧和上侧坐标轴
ax.spines['top'].set_color('none')
ax.spines['right'].set_color('none')
# 设置默认的x轴和y轴方向
ax.xaxis.set_ticks_position('bottom') 
ax.yaxis.set_ticks_position('left')
# 设置坐标原点为(0,0)
ax.spines['left'].set_position(('data',0))
ax.spines['bottom'].set_position(('data',0))
# 添加图例
plt.legend()
plt.savefig('linear-logistic.pdf')
plt.show()

Logistic函数可视化:
在这里插入图片描述

1.2.2构建Logistic回归算子

from nndl import op
#构建Logistic回归算子

class model_LR(op.Op):
    def __init__(self, input_dim):
        super(model_LR, self).__init__()
        self.params = {}
        # 将线性层的权重参数全部初始化为0
        self.params['w'] = torch.zeros([input_dim, 1])
        # self.params['w'] = torch.normal(mean=0, std=0.01, shape=[input_dim, 1])
        # 将线性层的偏置参数初始化为0
        self.params['b'] = torch.zeros([1])

    def __call__(self, inputs):
        return self.forward(inputs)

    def forward(self, inputs):
        """
        输入:
            - inputs: shape=[N,D], N是样本数量,D为特征维度
        输出:
            - outputs:预测标签为1的概率,shape=[N,1]
        """
        # 线性计算
        score = torch.matmul(inputs, self.params['w']) + self.params['b']
        # Logistic 函数
        outputs = logistic(score)
        return outputs
#模型构建完成

1.2.3 Logistic回归算子测试

#简单测试一下
# 固定随机种子,保持每次运行结果一致
torch.manual_seed(0)
# 随机生成3条长度为4的数据
inputs = torch.randn([3,4])
print('Input is:', inputs)
# 实例化模型
model = model_LR(4)
outputs = model(inputs)
print('Output is:', outputs)
#模型构建完成

测试结果:
在这里插入图片描述

1.3损失函数

1.3.1实现交叉熵损失函数

交叉熵损失:
在这里插入图片描述
代码实现:

# 实现交叉熵损失函数
class BinaryCrossEntropyLoss(op.Op):
    def __init__(self):
        self.predicts = None
        self.labels = None
        self.num = None

    def __call__(self, predicts, labels):
        return self.forward(predicts, labels)

    def forward(self, predicts, labels):
        """
        输入:
            - predicts:预测值,shape=[N, 1],N为样本数量
            - labels:真实标签,shape=[N, 1]
        输出:
            - 损失值:shape=[1]
        """
        self.predicts = predicts
        self.labels = labels
        self.num = self.predicts.shape[0]
        loss = -1. / self.num * (torch.matmul(self.labels.t(), torch.log(self.predicts)) + torch.matmul((1-self.labels.t()), torch.log(1-self.predicts)))
        loss = torch.squeeze(loss, dim=1)
        return loss

1.3.2函数测试

# 测试一下
# 生成一组长度为3,值为1的标签数据
labels = torch.ones([3,1])
# 计算风险函数
bce_loss = BinaryCrossEntropyLoss()
print(bce_loss(outputs, labels))

测试结果:
tensor([0.6931])

1.4模型优化

1.4.1 梯度计算:模型的优化

#3.1.4模型的优化
class model_LR(op.Op):
    def __init__(self, input_dim):
        super(model_LR, self).__init__()
        # 存放线性层参数
        self.params = {}
        # 将线性层的权重参数全部初始化为0
        self.params['w'] = torch.zeros([input_dim, 1])
        # self.params['w'] = torch.normal(mean=0, std=0.01, shape=[input_dim, 1])
        # 将线性层的偏置参数初始化为0
        self.params['b'] = torch.zeros([1])
        # 存放参数的梯度
        self.grads = {}
        self.X = None
        self.outputs = None

    def __call__(self, inputs):
        return self.forward(inputs)

    def forward(self, inputs):
        self.X = inputs
        # 线性计算
        score = torch.matmul(inputs, self.params['w']) + self.params['b']
        # Logistic 函数
        self.outputs = logistic(score)
        return self.outputs

    def backward(self, labels):
        """
        输入:
            - labels:真实标签,shape=[N, 1]
        """
        N = labels.shape[0]
        # 计算偏导数
        self.grads['w'] = -1 / N * torch.matmul(self.X.t(), (labels - self.outputs))
        self.grads['b'] = -1 / N * torch.sum(labels - self.outputs)

1.4.2参数更新:优化基类函数

from abc import abstractmethod

# 优化器基类
class Optimizer(object):
    def __init__(self, init_lr, model):
        """
        优化器类初始化
        """
        # 初始化学习率,用于参数更新的计算
        self.init_lr = init_lr
        # 指定优化器需要优化的模型
        self.model = model

    @abstractmethod
    def step(self):
        """
        定义每次迭代如何更新参数
        """
        pass

1.4.3参数更新:优化器

class SimpleBatchGD(Optimizer):
    def __init__(self, init_lr, model):
        super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)

    def step(self):
        # 参数更新
        # 遍历所有参数,按照公式(3.8)和(3.9)更新参数
        if isinstance(self.model.params, dict):
            for key in self.model.params.keys():
                self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]

1.5评价指标

1.5.1精度指示函数

#3.1.5评价指标
def accuracy(preds, labels):
    """
    输入:
        - preds:预测值,二分类时,shape=[N, 1],N为样本数量,多分类时,shape=[N, C],C为类别数量
        - labels:真实标签,shape=[N, 1]
    输出:
        - 准确率:shape=[1]
    """
    print(preds)
    # 判断是二分类任务还是多分类任务,preds.shape[1]=1时为二分类任务,preds.shape[1]>1时为多分类任务
    if preds.shape[1] == 1:
        # 二分类时,判断每个概率值是否大于0.5,当大于0.5时,类别为1,否则类别为0
        # 使用'torch.can_cast'将preds的数据类型转换为float32类型
        preds = torch.can_cast((preds>=0.5).dtype,to=torch.float32)
    else:
        # 多分类时,使用'torch.argmax'计算最大元素索引作为类别
        preds = torch.argmax(preds,dim=1)
        torch.can_cast(preds.dtype,torch.int32)
    return torch.mean(torch.as_tensor((preds == labels), dtype=torch.float32))

1.5.2测试指示函数

# 假设模型的预测值为[[0.],[1.],[1.],[0.]],真实类别为[[1.],[1.],[0.],[0.]],计算准确率
preds = torch.tensor([[0.],[1.],[1.],[0.]])
labels = torch.tensor([[1.],[1.],[0.],[0.]])

print("accuracy is:", accuracy(preds, labels))

测试结果:
在这里插入图片描述

1.6完善Runner类

#3.1.6完善Runner类
# 用RunnerV2类封装整个训练过程
class RunnerV2(object):
    def __init__(self, model, optimizer, metric, loss_fn):
        self.model = model
        self.optimizer = optimizer
        self.loss_fn = loss_fn
        self.metric = metric
        # 记录训练过程中的评价指标变化情况
        self.train_scores = []
        self.dev_scores = []
        # 记录训练过程中的损失函数变化情况
        self.train_loss = []
        self.dev_loss = []

    def train(self, train_set, dev_set, **kwargs):
        # 传入训练轮数,如果没有传入值则默认为0
        num_epochs = kwargs.get("num_epochs", 0)
        # 传入log打印频率,如果没有传入值则默认为100
        log_epochs = kwargs.get("log_epochs", 100)
        # 传入模型保存路径,如果没有传入值则默认为"best_model.pdparams"
        save_path = kwargs.get("save_path", "best_model.pdparams")
        # 梯度打印函数,如果没有传入则默认为"None"
        print_grads = kwargs.get("print_grads", None)
        # 记录全局最优指标
        best_score = 0
        # 进行num_epochs轮训练
        for epoch in range(num_epochs):
            X, y = train_set
            # 获取模型预测
            logits = self.model(X)
            # 计算交叉熵损失
            trn_loss = self.loss_fn(logits, y).item()
            self.train_loss.append(trn_loss)
            # 计算评价指标
            trn_score = self.metric(logits, y).item()
            self.train_scores.append(trn_score)
            # 计算参数梯度
            self.model.backward(y)
            if print_grads is not None:
                # 打印每一层的梯度
                print_grads(self.model)
            # 更新模型参数
            self.optimizer.step()
            dev_score, dev_loss = self.evaluate(dev_set)
            # 如果当前指标为最优指标,保存该模型
            if dev_score > best_score:
                self.save_model(save_path)
                print(f"best accuracy performence has been updated: {best_score:.5f} --> {dev_score:.5f}")
                best_score = dev_score
            if epoch % log_epochs == 0:
                print(f"[Train] epoch: {epoch}, loss: {trn_loss}, score: {trn_score}")
                print(f"[Dev] epoch: {epoch}, loss: {dev_loss}, score: {dev_score}")
                
    def evaluate(self, data_set):
        X, y = data_set
        # 计算模型输出
        logits = self.model(X)
        # 计算损失函数
        loss = self.loss_fn(logits, y).item()
        self.dev_loss.append(loss)
        # 计算评价指标
        score = self.metric(logits, y).item()
        self.dev_scores.append(score)
        return score, loss

    def predict(self, X):
        return self.model(X)

    def save_model(self, save_path):
        torch.save(self.model.params, save_path)

    def load_model(self, model_path):
        self.model.params = torch.load(model_path)

1.7模型训练

1.7.1模型训练

3.1.7模型训练
# 固定随机种子,保持每次运行结果一致
torch.manual_seed(102)

# 特征维度
input_dim = 2
# 学习率
lr = 0.1

# 实例化模型
model = model_LR(input_dim=input_dim)
# 指定优化器
optimizer = SimpleBatchGD(init_lr=lr, model=model)
# 指定损失函数
loss_fn = BinaryCrossEntropyLoss()
# 指定评价方式
metric = accuracy

# 实例化RunnerV2类,并传入训练配置
runner = RunnerV2(model, optimizer, metric, loss_fn)

runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=500, log_epochs=50, save_path="best_model.pdparams")

1.7.2可视化训练过程

# 可视化观察训练集与验证集的指标变化情况
def plot(runner,fig_name):
    plt.figure(figsize=(10,5))
    plt.subplot(1,2,1)
    epochs = [i for i in range(len(runner.train_scores))]
    # 绘制训练损失变化曲线
    plt.plot(epochs, runner.train_loss, color='#8E004D', label="Train loss")
    # 绘制评价损失变化曲线
    plt.plot(epochs, runner.dev_loss, color='#E20079', linestyle='--', label="Dev loss")
    # 绘制坐标轴和图例
    plt.ylabel("loss")
    plt.xlabel("epoch")
    plt.legend(loc='upper right')
    plt.subplot(1,2,2)
    # 绘制训练准确率变化曲线
    plt.plot(epochs, runner.train_scores, color='#8E004D', label="Train accuracy")
    # 绘制评价准确率变化曲线
    plt.plot(epochs, runner.dev_scores, color='#E20079', linestyle='--', label="Dev accuracy")
    # 绘制坐标轴和图例
    plt.ylabel("score")
    plt.xlabel("epoch")
    plt.legend(loc='lower right')
    plt.tight_layout()
    plt.savefig(fig_name)
    plt.show()

plot(runner,fig_name='linear-acc.pdf')

可视化结果示意:
在这里插入图片描述

1.8模型评价

1.8.1模型评价

#3.1.8模型评价
score, loss = runner.evaluate([X_test, y_test])
print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

1.8.2可视化结果

def decision_boundary(w, b, x1):
    w1, w2 = w
    x2 = (- w1 * x1 - b) / w2
    return x2
In [19]
plt.figure(figsize=(5,5))
# 绘制原始数据
plt.scatter(X[:, 0].tolist(), X[:, 1].tolist(), marker='*', c=y.tolist())

w = model.params['w']
b = model.params['b']
x1 = torch.linspace(-2, 3, 1000)
x2 = decision_boundary(w, b, x1)
# 绘制决策边界
plt.plot(x1.tolist(), x2.tolist(), color="red")
plt.show()

可视化结果:
在这里插入图片描述

二、基于Softmax函数回归的多分类任务

2.1数据集构建

2.1.1数据集构建函数

def make_multiclass_classification(n_samples=100, n_features=2, n_classes=3, shuffle=True, noise=0.1):
    """
    生成带噪音的多类别数据
    输入:
        - n_samples:数据量大小,数据类型为int
        - n_features:特征数量,数据类型为int
        - shuffle:是否打乱数据,数据类型为bool
        - noise:以多大的程度增加噪声,数据类型为None或float,noise为None时表示不增加噪声
    输出:
        - X:特征数据,shape=[n_samples,2]
        - y:标签数据, shape=[n_samples,1]
    """
    # 计算每个类别的样本数量
    n_samples_per_class = [int(n_samples / n_classes) for k in range(n_classes)]
    for i in range(n_samples - sum(n_samples_per_class)):
        n_samples_per_class[i % n_classes] += 1
    # 将特征和标签初始化为0
    X = torch.zeros([n_samples, n_features])
    y = torch.zeros([n_samples], dtype=torch.int32)
    # 随机生成3个簇中心作为类别中心
    centroids = torch.randperm(2 ** n_features)[:n_classes]
    centroids_bin = np.unpackbits(centroids.numpy().astype('uint8')).reshape((-1, 8))[:, -n_features:]
    centroids = torch.tensor(centroids_bin, dtype=torch.float32)
    # 控制簇中心的分离程度
    centroids = 1.5 * centroids - 1
    # 随机生成特征值
    X[:, :n_features] = torch.randn([n_samples, n_features])

    stop = 0
    # 将每个类的特征值控制在簇中心附近
    for k, centroid in enumerate(centroids):
        start, stop = stop, stop + n_samples_per_class[k]
        # 指定标签值
        y[start:stop] = k % n_classes
        X_k = X[start:stop, :n_features]
        # 控制每个类别特征值的分散程度
        A = 2 * torch.rand([n_features, n_features]) - 1
        X_k[...] = torch.matmul(X_k, A)
        X_k += centroid
        X[start:stop, :n_features] = X_k

    # 如果noise不为None,则给特征加入噪声
    if noise > 0.0:
        # 生成noise掩膜,用来指定给那些样本加入噪声
        noise_mask = torch.rand([n_samples]) < noise
        for i in range(len(noise_mask)):
            if noise_mask[i]:
                # 给加噪声的样本随机赋标签值
                y[i] = torch.can_cast(torch.randint(n_classes, [1]).dtype,torch.int32)
    # 如果shuffle为True,将所有数据打乱
    if shuffle:
        idx = torch.randperm(X.shape[0])
        X = X[idx]
        y = y[idx]

    return X, y

2.1.2数据集构建函数测试

#make_multiclass_classification创建多分类任务函数的测试
# 固定随机种子,保持每次运行结果一致
import numpy as np
torch.manual_seed(102)
# 采样1000个样本
n_samples = 1000
X, y = make_multiclass_classification(n_samples=n_samples, n_features=2, n_classes=3, noise=0.2)

2.1.3可视化数据集

#可视化产生的数据集
# 可视化生产的数据集,不同颜色代表不同类别
import matplotlib.pyplot as plt
plt.figure(figsize=(5,5))
plt.scatter(x=X[:, 0].tolist(), y=X[:, 1].tolist(), marker='*', c=y.tolist())
plt.savefig('linear-dataset-vis2.pdf')
plt.show()

可视化结果:
在这里插入图片描述

2.1.4划分训练集、验证集、测试集

#拆分训练集、验证集和测试集
num_train = 640
num_dev = 160
num_test = 200

X_train, y_train = X[:num_train], y[:num_train]
X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]

# 打印X_train和y_train的维度
print("X_train shape: ", X_train.shape, "y_train shape: ", y_train.shape)

结果:
X_train shape: torch.Size([640, 2]) y_train shape: torch.Size([640])

2.2模型构建

2.2.1 softmax回归模型构建

#softmax回归模型构建
# x为tensor
def softmax(X):
    """
    输入:
        - X:shape=[N, C],N为向量数量,C为向量维度
    """
    x_max = torch.max(X, axis=1, keepdim=True)#N,1
    x_exp = torch.exp(X - x_max.values)
    partition = torch.sum(x_exp, axis=1, keepdim=True)#N,1
    return x_exp / partition

2.2.2观察softmax计算方式

# 观察softmax的计算方式
X = torch.tensor([[0.1, 0.2, 0.3, 0.4],[1,2,3,4]])
predict = softmax(X)
print(predict)

结果:
在这里插入图片描述

2.2.3实现softmax回归算子

#实现sotfmax回归算子
class model_SR(op.Op):
    def __init__(self, input_dim, output_dim):
        super(model_SR, self).__init__()
        self.params = {}
        # 将线性层的权重参数全部初始化为0
        self.params['W'] = torch.zeros([input_dim, output_dim])
        # self.params['W'] = torch.normal(mean=0, std=0.01, shape=[input_dim, output_dim])
        # 将线性层的偏置参数初始化为0
        self.params['b'] = torch.zeros([output_dim])
        self.outputs = None

    def __call__(self, inputs):
        return self.forward(inputs)

    def forward(self, inputs):
        """
        输入:
            - inputs: shape=[N,D], N是样本数量,D是特征维度
        输出:
            - outputs:预测值,shape=[N,C],C是类别数
        """
        # 线性计算
        score = torch.matmul(inputs, self.params['W']) + self.params['b']
        # Softmax 函数
        self.outputs = softmax(score)
        return self.outputs

测试softmax回归算子:

# 随机生成1条长度为4的数据
inputs = torch.randn([1,4])
print('Input is:', inputs)
# 实例化模型,这里令输入长度为4,输出类别数为3
model = model_SR(input_dim=4, output_dim=3)
outputs = model(inputs)
print('Output is:', outputs)

测试结果:
在这里插入图片描述

2.3损失函数

2.3.1交叉熵损失

#3.2.3交叉熵损失函数
class MultiCrossEntropyLoss(op.Op):
    def __init__(self):
        self.predicts = None
        self.labels = None
        self.num = None

    def __call__(self, predicts, labels):
        return self.forward(predicts, labels)

    def forward(self, predicts, labels):
        """
        输入:
            - predicts:预测值,shape=[N, 1],N为样本数量
            - labels:真实标签,shape=[N, 1]
        输出:
            - 损失值:shape=[1]
        """
        self.predicts = predicts
        self.labels = labels
        self.num = self.predicts.shape[0]
        loss = 0
        for i in range(0, self.num):
            index = self.labels[i]
            loss -= torch.log(self.predicts[i][index])
        return loss / self.num


测试一下:

# 测试一下
# 假设真实标签为第1类
labels = torch.tensor([0])
# 计算风险函数
mce_loss = MultiCrossEntropyLoss()
print(mce_loss(outputs, labels))

结果:tensor(1.0986)

2.4模型优化

class model_SR(op.Op):
    def __init__(self, input_dim, output_dim):
        super(model_SR, self).__init__()
        self.params = {}
        # 将线性层的权重参数全部初始化为0
        self.params['W'] = torch.zeros([input_dim, output_dim])
        # self.params['W'] = torch.normal(mean=0, std=0.01, shape=[input_dim, output_dim])
        # 将线性层的偏置参数初始化为0
        self.params['b'] = torch.zeros([output_dim])
        # 存放参数的梯度
        self.grads = {}
        self.X = None
        self.outputs = None
        self.output_dim = output_dim

    def __call__(self, inputs):
        return self.forward(inputs)

    def forward(self, inputs):
        self.X = inputs
        # 线性计算
        score = torch.matmul(self.X, self.params['W']) + self.params['b']
        # Softmax 函数
        self.outputs = softmax(score)
        return self.outputs

    def backward(self, labels):
        """
        输入:
            - labels:真实标签,shape=[N, 1],其中N为样本数量
        """
        # 计算偏导数
        N =labels.shape[0]
        labels = torch.nn.functional.one_hot(labels.to(torch.int64), self.output_dim)
        self.grads['W'] = -1 / N * torch.matmul(self.X.t(), (labels-self.outputs))
        self.grads['b'] = -1 / N * torch.matmul(torch.ones([N]), (labels-self.outputs))

2.5模型训练

# 固定随机种子,保持每次运行结果一致
torch.manual_seed(102)

# 特征维度
input_dim = 2
# 类别数
output_dim = 3
# 学习率
lr = 0.1

# 实例化模型
model = model_SR(input_dim=input_dim, output_dim=output_dim)
# 指定优化器
optimizer = SimpleBatchGD(init_lr=lr, model=model)
# 指定损失函数
loss_fn = MultiCrossEntropyLoss()
# 指定评价方式
metric = accuracy
# 实例化RunnerV2类
runner = RunnerV2(model, optimizer, metric, loss_fn)

# 模型训练
runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=500, log_eopchs=50, eval_epochs=1, save_path="best_model.pdparams")

# 可视化观察训练集与验证集的准确率变化情况
plot(runner,fig_name='linear-acc2.pdf')

可视化训练结果图:
在这里插入图片描述

2.6模型评价

观察测试准确率:

score, loss = runner.evaluate([X_test, y_test])
print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

准确率结果:
在这里插入图片描述

# 均匀生成40000个数据点
x1, x2 = torch.meshgrid(torch.linspace(-3.5, 2, 200), torch.linspace(-4.5, 3.5, 200))
x = torch.stack([torch.flatten(x1), torch.flatten(x2)], axis=1)
# 预测对应类别
y = runner.predict(x)
y = torch.argmax(y, axis=1)
# 绘制类别区域
plt.ylabel('x2')
plt.xlabel('x1')
plt.scatter(x[:,0].tolist(), x[:,1].tolist(), c=y.tolist(), cmap=plt.cm.Spectral)

torch.manual_seed(102)
n_samples = 1000
X, y = make_multiclass_classification(n_samples=n_samples, n_features=2, n_classes=3, noise=0.2)

plt.scatter(X[:, 0].tolist(), X[:, 1].tolist(), marker='*', c=y.tolist())

可视化结果:
在这里插入图片描述

三、实践:基于Softmax回归完成鸢尾花的分类任务

3.1数据处理

3.1.1导入数据,查看是否有缺失值。

from sklearn.datasets import load_iris
import pandas
import numpy as np

iris_features = np.array(load_iris().data, dtype=np.float32)
iris_labels = np.array(load_iris().target, dtype=np.int32)
print(pandas.isna(iris_features).sum())
print(pandas.isna(iris_labels).sum())

结果说明不存在缺失值:
在这里插入图片描述

3.1.2箱线图查看异常值

import matplotlib.pyplot as plt #可视化工具

# 箱线图查看异常值分布
def boxplot(features):
    feature_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']

    # 连续画几个图片
    plt.figure(figsize=(5, 5), dpi=200)
    # 子图调整
    plt.subplots_adjust(wspace=0.6)
    # 每个特征画一个箱线图
    for i in range(4):
        plt.subplot(2, 2, i+1)
        # 画箱线图
        plt.boxplot(features[:, i], 
                    showmeans=True, 
                    whiskerprops={"color":"#E20079", "linewidth":0.4, 'linestyle':"--"},
                    flierprops={"markersize":0.4},
                    meanprops={"markersize":1})
        # 图名
        plt.title(feature_names[i], fontdict={"size":5}, pad=2)
        # y方向刻度
        plt.yticks(fontsize=4, rotation=90)
        plt.tick_params(pad=0.5)
        # x方向刻度
        plt.xticks([])
    plt.savefig('ml-vis.pdf')
    plt.show()

boxplot(iris_features)

箱线图结果展示:
在这里插入图片描述
由图可以得出,在第二张图中存在异常值。

3.1.3加载数据集

import copy
import torch 

# 加载数据集
def load_data(shuffle=True):
    """
    加载鸢尾花数据
    输入:
        - shuffle:是否打乱数据,数据类型为bool
    输出:
        - X:特征数据,shape=[150,4]
        - y:标签数据, shape=[150]
    """
    # 加载原始数据
    X = np.array(load_iris().data, dtype=np.float32)
    y = np.array(load_iris().target, dtype=np.int32)

    X = torch.tensor(X)
    y = torch.tensor(y)

    # 数据归一化
    X_min = torch.min(X, axis=0)
    X_max = torch.max(X, axis=0)
    X = (X-X_min.values) / (X_max.values-X_min.values)

    # 如果shuffle为True,随机打乱数据
    if shuffle:
        idx = torch.randperm(X.shape[0])
        X = X[idx]
        y = y[idx]
    return X, y

3.1.4测试是否加载成功


# 固定随机种子
torch.manual_seed(102)

num_train = 120
num_dev = 15
num_test = 15

X, y = load_data(shuffle=True)
print("X shape: ", X.shape, "y shape: ", y.shape)
X_train, y_train = X[:num_train], y[:num_train]
X_dev, y_dev = X[num_train:num_train + num_dev], y[num_train:num_train + num_dev]
X_test, y_test = X[num_train + num_dev:], y[num_train + num_dev:]

测试结果:
在这里插入图片描述

3.2模型构建

#3.2.2模型构建
from nndl import op

# 输入维度
input_dim = 4
# 类别数
output_dim = 3
# 实例化模型
model = model_SR(input_dim=input_dim, output_dim=output_dim)

3.3损失函数

我们依旧采用交叉熵损失:

# 交叉熵损失
loss_fn = MultiCrossEntropyLoss()

3.4模型优化

我们采用梯度下降法优化模型:

# 梯度下降法
optimizer = SimpleBatchGD(init_lr=lr, model=model)

3.5模型训练

设置学习率,实例化RunnerV2启动训练

# 学习率
lr = 0.9

# 梯度下降法
optimizer = SimpleBatchGD(init_lr=lr, model=model)
# 交叉熵损失
loss_fn = MultiCrossEntropyLoss()


# 实例化RunnerV2
runner = RunnerV2(model, optimizer, accuracy, loss_fn)

# 启动训练
runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=200, log_epochs=10, save_path="best_model.pdparams")

训练结果:
在这里插入图片描述
我们对训练结果可视化:

plot(runner,fig_name='linear-acc3.pdf')

可视化结果:
在这里插入图片描述

3.6模型评价

打印损失:

# 加载最优模型
runner.load_model('best_model.pdparams')
# 模型评价
score, loss = runner.evaluate([X_test, y_test])
print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))

损失(Loss结果:)
在这里插入图片描述

3.7模型预测

# 预测测试集数据
logits = runner.predict(X_test)
# 观察其中一条样本的预测结果
pred = torch.argmax(logits[0]).numpy()
# 获取该样本概率最大的类别
label = y_test[0].numpy()
# 输出真实类别与预测类别
print("The true category is {} and the predicted category is {}".format(label, pred))

我们对模型进行预测
在这里插入图片描述


解答:其中的一些问题解答

问题1:Logistic回归在不同的书籍中,有许多其他的称呼,具体有哪些?你认为哪个称呼最好?

解析:
Logistic可称为:逻辑回归,罗杰斯蒂克回归分析,对数几率回归,概率型非线性回归。
其中,关于其中哪个称呼好的问题,我自我感觉是认为对数几率回归最好,因为使用的函数是sigmoid函数,采用的方法是先取正例/反例的概率,再求的对数,从而进行的回归分析,对数几率回归更加使得其内涵通俗易懂,所以我认为对数几率回归更能体现其思想过程,所以我感觉它比较好一些。

问题2:什么是激活函数?为什么要用激活函数?常见激活函数有哪些?
解析:
我感觉吧,激活函数是将一个线性的东西映射到非线性的东西上,从而进行分析,因为我们的生活中大部分的回归问题的分析,大多都不是线性的,都是非线性的,非线性的回归才具有普遍的研究意义。我记得我用过的激活函数有:Sigmoid函数,ReLu函数,Tanh函数还有softmax函数,就是将其输入映射到多维空间分析输出到输出端
问题3:在第三部分实践当中,尝试调整学习率和训练轮数等超参数,观察是否能够得到更高的精度?
能。
当学习率为0.9时:
在这里插入图片描述

在这里插入图片描述
当学习率为0.02时:
在这里插入图片描述
在这里插入图片描述
当学习率为10.0时
在这里插入图片描述
在这里插入图片描述
当学习率为100.0时:
在这里插入图片描述
在这里插入图片描述
当学习率为1000时:
在这里插入图片描述
在这里插入图片描述
当学习率为1800.0时:
在这里插入图片描述
在这里插入图片描述
由上述测试,我们可以看出,当学习率在一定范围内波动时,是有助于score升高和loss降低的,当超出这个限度,误差将会无限大。

总结

我开始体会到类的方便,并更加能够想通过类调用函数的方式来实现我们的数据集的训练,总结来说就是一次类封装,多次简单调用。希望能在以后更多的机会中使用类封装的形式完成实验。
参考博客:
NNDL 实验四 线性分类
邱锡鹏深度学习–第3章(上):线性分类理论解读
实践:基于Softmax回归完成鸢尾花分类任务

NNDL 实验二 pytorch入门 阅读详情

相关推荐

深度学习入门代码详解(附代码)

目录 一、数据处理 1.1 读入数据 1.2 数据形状变换 1.3 数据集划分 1.4 数据归一化处理 1.5 封装成load data函数 二、模型设计 2.1 训练配置 2.2 训练过程 2.3 梯度下降法 2.4 计算梯度 2.5 使用Numpy进行梯度计算 2.6 确定损失函数更小的点 2.7 代码封装Train函数 2.8 训练扩展到全部参数 三、随机梯度下降法( Stochastic Gradient Descent) 3.1 数据处理代码修改 3.2 ...

Python,数据分析,机器学习,深度学习 3万+

PaddlePaddle飞桨(学习笔记二——Tensor张量)

飞桨框架的 API 有原位(Inplace)操作和非原位操作之分,原位操作即在原 Tensor 上保存操作结果,输出 Tensor 将与输入 Tensor 共享数据,并且没有 Tensor 数据拷贝的过程。表示该维度的元素数量与原值相同,因此 shape 中 0 的索引值必须小于 Tensor 的维度(索引值从 0 开始计,如第 1 维的索引值是 0,第二维的索引值是 1)。ndim: Tensor 的维度数量,例如向量的维度为 1,矩阵的维度为 2,Tensor 可以有任意数量的维度。

weixin_72787227的博客 2812

python 识别滑块验证码

博客来源于: https://www.cnblogs.com/wyh0923/p/16528354.html # -*- coding: utf-8 -*- # https://gov.pkulaw.cn/ 1. import io 2. import json 3. from pathlib import Path 4. from PIL import Image 5. import bas...

2103

PaddlePaddle与PyTorch的转换

PaddlePaddle与PyTorch的转换1 基本结构2 网络结构 PaddlePaddle 2.0和PyTorch风格还是非常像的。使用PaddlePaddle可以直接调用百度AI Studio里的一些资源(包括GPU、预训练权重之类的),而且说明文档、社区都是中文的,比较友好;而PyTorch在Github有更多的代码与资源,两者配合使用是比较香的。下面整理了一些PaddlePaddle以及PyTorch中对应的函数。 1 基本结构 PyTorch PaddlePaddle 说明 t

shaojie_45的博客 1万+

项目回顾一:《高速多端口共享缓存模块》

本帖子仅为了回顾一下一年前自己动手完成的第一个数字ic设计项目的历程,为复试做一下准备,完成的这个sramc模块花了整整四个月的时间,从0到12个模块的代码产出以及模块的验证,虽然没有拿奖,也没有进入复赛,设计过程中使用的技术手段和算法也不太成熟,但这这是一个值得记录的过程!

weixin_60261760的博客 1258

从像素到光影:解析《黑神话:悟空》中Nanite与Lumen的协同渲染革命

本文深度解析了《黑神话:悟空》如何利用Unreal Engine 5的Nanite与Lumen技术实现渲染革命。Nanite处理亿级多边形几何细节,无需传统LOD优化;Lumen提供全动态全局光照,实现实时光线反弹。两者协同工作,为游戏带来电影级视觉体验,重塑了实时渲染的技术标准与工作流程。

f6g7h8i9j的博客 425

【深度学习-Day 10】机器学习基石:从零入门线性回归与逻辑回归

在上一篇【深度学习-Day 9】机器学习基础(一) - 核心概念中,我们初步踏入了机器学习的大门,了解了其基本定义、分类以及像特征、标签、数据集划分等核心术语。今天,我们将继续深入,学习两种基础且非常重要的机器学习模型:**线性回归 (Linear Regression)** 和 **逻辑回归 (Logistic Regression)**。理解它们不仅能帮助我们解决实际问题,更是我们后续理解复杂神经网络如何“学习”的关键一步。

吴师兄大模型的博客 1652

AI与运筹学赋能:混合动力公交调度优化算法实战解析

组合优化是运筹学与计算机科学交叉的核心领域,旨在从海量可行方案中寻找最优解,其原理在于通过定义目标函数与约束条件,将复杂现实问题转化为可计算的数学模型。该技术的核心价值在于解决资源受限下的高效分配问题,广泛应用于物流、交通、生产调度等场景。在智慧交通领域,混合动力公交车辆调度正是一个典型的组合优化问题,涉及车辆、班次、充电桩等多重资源与时空约束。本文聚焦于通过贪婪启发式与模拟退火元启发式算法,求解大规模公交网络下的车辆调度与能耗优化方案,旨在实现总能源成本最小化。其中,模拟退火算法通过引入概率性接受劣解的策

weixin_42497762的博客 407

【深度学习-Day 12】从零认识神经网络:感知器原理、实现与局限性深度剖析

欢迎来到深度学习系列的第12篇文章!在前面的章节中,我们已经为深度学习之旅奠定了坚实的数学、编程和机器学习基础。我们了解了线性回归和逻辑回归等基本模型,并对模型训练的基本流程有了初步认识。从本篇开始,我们将正式踏入神经网络的核心领域。神经网络是当前人工智能浪潮中最耀眼的技术之一,而理解其最基本的构建单元——感知器(Perceptron)——是至关重要的一步。

吴师兄大模型的博客 1793

windows10下 iperf3测试带宽

客户端输入:"iperf3.exe -u -c 服务器IP地址 -b 5g" //客户端给服务器发送udp数据包,最大带宽为5g。客户端输入:“iperf3.exe -c 服务器IP地址 -P 10“//表示客户端10路并行给服务器发送TCP包;上图可知:带宽是15Gbps(这里不知道为什么下面测试的UDP会比这里TCP慢 按道理UDP不可能比TCP慢的5.)3. 验证是否下载成功,在打开的窗口中输入“iperf3.exe -v”,会出现安装的版本,表示安装成功了。5. iperf3参数。

xiaoqixiaoguai的博客 5896

一张图讲透银行个人外汇业务逻辑和实操

个人外汇业务主要分为结售汇和外币兑换两类,前者满足日常跨境需求,后者因投机属性多数银行已暂停。业务核心是利用汇率波动实现货币兑换,满足支付或投资需求。交易涉及客户分类、主流币种、多种渠道和汇率计算规则,需区分直接/间接标价法判断汇率走势。银行通过"货币兑换"科目核算损益,采用期末折算确认盈亏。监管要求包括5万美元年度额度、合法渠道、真实性原则及大额申报等。随着跨境金融数字化发展,掌握基础逻辑和合规要求是安全参与外汇业务的关键。

银行信息系统应用架构详解 296

【深度学习-Day 40】RNN入门:当神经网络拥有记忆,如何处理文本与时间序列?

本文将正式开启循环神经网络(RNN)的学习之旅,深入探讨为什么处理序列数据需要一种全新的架构。我们将从序列数据的本质特性出发,剖析 MLP 和 CNN 在处理这类数据时的核心局限性,并最终揭示 RNN 如何通过其独特的**循环结构**和**隐藏状态**机制,赋予神经网络“记忆”能力,从而有效地理解和处理序列信息。

吴师兄大模型的博客 1805

【WRF编译-Lab1】使用自动脚本编译WRF:错误总结

WRF编译过程及错误总结

WW、forever的博客 84

【深度学习-Day 33】从零到一:亲手构建你的第一个卷积神经网络(CNN)

我们知道了卷积层如何通过卷积核提取局部特征,以及池化层如何进行降维和增强特征的不变性。今天,我们将把这些独立的“积木块”组装起来,亲手搭建我们的第一个完整的卷积神经网络模型。本文将带你领略一个典型CNN的完整结构,理解其工作流程,并最终使用PyTorch代码将其变为现实。

吴师兄大模型的博客 1220

用 CORRESPONDING #( ) 优雅复制同名字段:从 MOVE-CORRESPONDING 到现代 ABAP 结构映射的关键差异与最佳实践

摘要:本文深入探讨了SAP ABAP中结构数据复制的两种主要方式——传统MOVE-CORRESPONDING与现代CORRESPONDING #()的核心差异。重点分析了现代构造表达式会初始化目标结构的关键特性,通过SAP_GWFND开发中的实际案例展示了这一差异可能引发的线上问题。同时介绍了使用BASE保留目标字段值的技巧,以及通过MAPPING处理字段名不一致的场景。文章为ABAP开发者提供了在S/4HANA、BTP及RAP等现代架构下的数据映射最佳实践,帮助规避常见的维护陷阱。(149字)

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 2262

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

【深度学习-Day 17】神经网络的心脏:反向传播算法全解析

在上一篇文章【深度学习-Day 16】中,我们了解了梯度下降法——这个引领我们寻找损失函数最小值的强大工具。我们知道了,只要能计算出损失函数关于模型参数(权重 $w$ 和偏置 $b$)的梯度,我们就能通过不断迭代来更新参数,让模型变得越来越好。但是,对于一个拥有成千上万甚至数百万参数的深度神经网络来说,如何高效地计算这些梯度呢?手动推导显然是不现实的。这时,神经网络的“心脏”——**反向传播算法(Backpropagation, BP)**——就登场了。

吴师兄大模型的博客 1404

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

【深度学习-Day 41】解密循环神经网络(RNN):深入理解隐藏状态、参数共享与前向传播

本文将深入剖析最基础的RNN结构,带你彻底理解其核心工作原理。我们将从RNN的核心单元(Cell)出发,详细解读其内部结构、关键的隐藏状态(Hidden State)传递机制,以及高效的参数共享(Parameter Sharing)策略。最后,我们将通过可视化的方式完整地演示RNN的前向传播过程,并提供一个NumPy实现的代码示例,让你真正掌握RNN的内在逻辑,为后续学习LSTM、GRU等高级变体打下坚实的基础。

吴师兄大模型的博客 3247

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

深度学习 从入门到精通 day_04

在使用Torch构建网络模型时,每个网络层的参数都有默认的初始化方法,同时还可以通过以上方法来对网络参数进行初始化。当输出层使用softmax多分类时,使用交叉熵损失函数;当输出层使用sigmoid二分类时,使用二分类交叉熵损失函数, 比如在逻辑回归中使用;当功能为线性回归时,使用均方差损失-L2 loss;梯度下降算法通过不断更新参数来最小化损失函数,是反向传播算法中计算权重调整的基础。

qq_59348412的博客 1212

【深度学习-Day 19】入门必读:全面解析 TensorFlow 与 PyTorch 的核心差异与选择指南

深度学习领域群雄逐鹿,其中最耀眼的两大巨头无疑是 Google 的 TensorFlow 和 Meta (Facebook) 的 PyTorch。它们各自拥有庞大的用户社区和强大的生态系统,但在设计理念、使用方式和应用场景上又各有千秋。今天,我们就将深入这两大框架的内部,对比它们的异同,并探讨如何根据自身需求做出明智的选择,为我们接下来的实战篇章打下坚实的基础。

吴师兄大模型的博客 2231

黑马王炸上新!《神经网络与深度学习》教程发布!

黑马程序员推出《神经网络与深度学习》硬核教程,助你7天掌握AI开发核心技能。课程从Pytorch框架入门到CNN/RNN实战,覆盖图像分类、文本生成等应用场景,适合零基础学员和转行者。通过保姆级教学和项目实战,快速提升深度学习能力,抢占AI行业风口。

黑马程序员官方博客 832

【深度学习-Day 21】框架入门:神经网络模型构建核心指南 (Keras & PyTorch)

构建模型是深度学习流程中的核心环节。一个设计良好的模型结构是决定项目成败的关键因素之一。本文将带你深入了解两大主流框架 TensorFlow (主要通过其高级 API Keras) 和 PyTorch 中模型构建的机制,包括模型容器(Model Containers)的选择与使用、常用神经网络层的定义,以及如何查看和理解你所搭建的模型结构。最终,我们将通过实践,亲手用框架搭建一个简单的多层感知器(MLP)模型。

吴师兄大模型的博客 1860

【深度学习-Day 24】过拟合与欠拟合:深入解析模型泛化能力的核心挑战

我们看到模型在训练数据上表现优异,但这是否意味着它就是一个好模型呢?并非如此。一个模型真正的价值在于它对**未知数据**的预测能力,我们称之为**泛化能力**。然而,在追求高泛化能力的道路上,我们常常会遇到两个主要的“拦路虎”:**欠拟合(Underfitting)** 和 **过拟合(Overfitting)**。理解并有效处理这两个问题,是从入门迈向专业的关键一步。本文将带你深入剖析这两个概念,并探讨其背后的核心理论——偏差与方差的权衡,最后提供诊断和应对的实战策略。

吴师兄大模型的博客 1886

【深度学习-Day 38】破解深度网络退化之谜:残差网络(ResNet)核心原理与实战

ResNet的核心在于引入了“残差学习”框架和“快捷连接”(Shortcut Connection),它巧妙地改变了网络的学习目标,使得优化深层网络变得异常容易。本文将深入剖析网络退化问题的本质,详细阐述ResNet的设计哲学、核心组件“残差块”的工作原理,并提供基于PyTorch的实现代码。通过理解ResNet,你将掌握构建超深神经网络的关键,并洞悉其为何能成为计算机视觉乃至整个深度学习领域的里程碑式工作。

吴师兄大模型的博客 2996

day04||深度学习(李沐动手学深度学习)

不带参数的层带参数的层定义具有参数的层, 这些参数可以通过训练进行调整。我们可以使用内置函数来创建参数,这些函数提供一些基本的管理功能。比如管理访问、初始化、共享、保存和加载模型参数。这样做的好处之一是:我们不需要为每个自定义层编写自定义的序列化程序。现在,让我们实现自定义版本的全连接层。该层需要两个参数,一个用于表示权重,另一个用于表示偏置项。在此实现中,我们使用修正线性单元作为激活函数。该层需要输入参数:in_units和units,分别表示输入数(输入维度)和输出数(输出维度)。

m0_67567149的博客 2206

【深度学习-Day 39】玩转迁移学习与模型微调:站在巨人的肩膀上

我们将从迁移学习的核心思想出发,系统性地解析其工作原理、关键策略(如特征提取、分层微调),并详细介绍如何根据不同场景选择最合适的微调方案。最后,本文将通过一个完整的 PyTorch 实战案例,手把手教你如何加载预训练的 ResNet 模型,并将其成功微调应用于新的图像分类任务。无论你是希望快速实现项目落地的初学者,还是寻求提升模型性能的进阶者,本文都将为你提供清晰的理论指导和可复现的实践代码。

吴师兄大模型的博客 1969

【深度学习-Day 37】VGG与GoogLeNet:当深度遇见宽度,CNN架构的演进之路

本文将深入探讨两种具有里程碑意义的经典卷积神经网络(CNN)架构:VGG和GoogLeNet。VGG以其极致的简洁和深度,证明了通过堆叠小型卷积核构建深层网络的可行性。而GoogLeNet则另辟蹊径,通过创新的Inception模块,在网络“宽度”上做文章,实现了在更低计算预算下对多尺度特征的高效提取。

吴师兄大模型的博客 2780
上一篇: 神经网络与深度学习-作业1
下一篇: 进阶torch:torch.stack和torch.cat + one-hot报错
小鬼缠身、
博客等级 码龄6年 29粉丝 35原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鬼缠身、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值