NNDL 实验四线性分类

最新推荐文章于 2024-03-19 09:46:00 发布

Sun.02

最新推荐文章于 2024-03-19 09:46:00 发布

阅读量83

点赞数 1

文章标签：分类机器学习逻辑回归

本文链接：https://blog.csdn.net/m0_63172447/article/details/126928047

版权

3.1 基于Logistic回归的二分类任务

3.2 基于Softmax回归的多分类任务

3.3 实践：基于Softmax回归完成鸢尾花分类任务

3.1 基于Logistic回归的二分类任务

3.1.1 数据集构建

构建一个简单的分类任务，并构建训练集、验证集和测试集。
本任务的数据来自带噪音的两个弯月形状函数，每个弯月对一个类别。我们采集1000条样本，每个样本包含2个特征。

随机采集1000个样本，并进行可视化。

将1000条样本数据拆分成训练集、验证集和测试集，其中训练集640条、验证集160条、测试集200条。

import math

import torch


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_out = n_samples // 2
    n_samples_in = n_samples - n_samples_out

    # 采集第1类数据，特征为(x,y)
    # 使用'paddle.linspace'在0到pi上均匀取n_samples_out个值
    # 使用'paddle.cos'计算上述取值的余弦值作为特征1，使用'paddle.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)

    # 使用'paddle.concat'将两类数据的特征1和特征2分别延维度0拼接在一起，得到全部特征1和特征2
    # 使用'paddle.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)

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

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

    # 如果shuffle为True，将所有数据打乱
    if shuffle:
        # 使用'paddle.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:
        # 使用'paddle.normal'生成符合正态分布的随机Tensor作为噪声，并加到原始特征上
        X += torch.normal(mean=0.0, std=noise, size=X.shape)

    return X, y

# 采样1000个样本
n_samples = 1000
X, y = make_moons(n_samples=n_samples, shuffle=True, noise=0.5)
# 可视化生产的数据集，不同颜色代表不同类别

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()

输出

3.1.2 模型构建

# 定义Logistic函数
def logistic(x):
    return 1 / (1 + tr.exp(-x))
 
# 在[-10,10]的范围内生成一系列的输入值，用于绘制函数曲线
x = tr.linspace(-10, 10, 10000)
plt.figure()
plt.plot(x.tolist(), logistic(x).tolist(), color="#e4007f", 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()
from nndl import op
 
class model_LR(op.Op):
    def __init__(self, input_dim):
        super(model_LR, self).__init__()
        self.params = {}
        # 将线性层的权重参数全部初始化为0
        self.params['w'] = tr.zeros(size=[input_dim, 1])
        # self.params['w'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, 1])
        # 将线性层的偏置参数初始化为0
        self.params['b'] = tr.zeros(size=[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 =tr.matmul(inputs, self.params['w']) + self.params['b']
        # Logistic 函数
        outputs = logistic(score)
        return outputs
# 固定随机种子，保持每次运行结果一致
tr.seed()
# 随机生成3条长度为4的数据
inputs = tr.randn([3,4])
print('Input is:', inputs)
# 实例化模型
model = model_LR(4)
outputs = model(inputs)
print('Output is:', outputs)

输出

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

答：还可以被叫做逻辑回归分析、对数几率回归。对数几率回归更好，从名字中更能了解该回归的原理和过程。

问题2：什么是激活函数？为什么要用激活函数？常见激活函数有哪些？

a. 激活函数（Activation Function）是一种添加到人工神经网络中的函数，旨在帮助网络学习数据中的复杂模式。类似于人类大脑中基于神经元的模型，激活函数最终决定了要发射给下一个神经元的内容。

b.激活函数（Activation functions）对于人工神经网络模型去学习、理解非常复杂和非线性的函数来说具有十分重要的作用。

c.sigmoid函数

tanh函数

relu函数

3.1.3 损失函数

交叉熵损失函数

# 实现交叉熵损失函数
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 * (tr.matmul(self.labels.t(), tr.log(self.predicts)) + tr.matmul((1-self.labels.t()), tr.log(1-self.predicts)))
        loss = tr.squeeze(loss, axis=1)
        return loss
 
# 测试一下
# 生成一组长度为3，值为1的标签数据
labels = tr.ones(size=[3,1])
# 计算风险函数
bce_loss = BinaryCrossEntropyLoss()
print(bce_loss(outputs, labels))

tensor([0.6931])

3.1.4 模型优化

不同于线性回归中直接使用最小二乘法即可进行模型参数的求解，Logistic回归需要使用优化算法对模型参数进行有限次地迭代来获取更优的模型，从而尽可能地降低风险函数的值。
在机器学习任务中，最简单、常用的优化算法是梯度下降法。

使用梯度下降法进行模型优化，首先需要初始化参数W和 b，然后不断地计算它们的梯度，并沿梯度的反方向更新参数。

class model_LR(op.Op):
    def __init__(self, input_dim):
        super(model_LR, self).__init__()
        # 存放线性层参数
        self.params = {}
        # 将线性层的权重参数全部初始化为0
        self.params['w'] = tr.zeros(size=[input_dim, 1])
        # self.params['w'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, 1])
        # 将线性层的偏置参数初始化为0
        self.params['b'] = tr.zeros(size=[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 = tr.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 * tr.matmul(self.X.t(), (labels - self.outputs))
        self.grads['b'] = -1 / N * tr.sum(labels - self.outputs)
 
import nndl.opitimizer as Optimizer
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]

3.1.5 评价指标

在分类任务中，通常使用准确率（Accuracy）作为评价指标。

def accuracy(preds, labels):
    """
    输入：
        - preds：预测值，二分类时，shape=[N, 1]，N为样本数量，多分类时，shape=[N, C]，C为类别数量
        - labels：真实标签，shape=[N, 1]
    输出：
        - 准确率：shape=[1]
    """
    # 判断是二分类任务还是多分类任务，preds.shape[1]=1时为二分类任务，preds.shape[1]>1时为多分类任务
    if preds.shape[1] == 1:
        # 二分类时，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
        # 使用'paddle.cast'将preds的数据类型转换为float32类型
        j = 0;
        for i in preds:
            if i[0]>0.5:
                preds[j][0]=1.0;
            j=j+1;
        preds=preds.float();
    else:
        # 多分类时，使用'paddle.argmax'计算最大元素索引作为类别
        preds = tr.argmax(preds,1).float()
    return tr.mean(tr.eq(preds, labels).float())
 
# 假设模型的预测值为[[0.],[1.],[1.],[0.]]，真实类别为[[1.],[1.],[0.],[0.]]，计算准确率
preds = tr.tensor([[0.],[1.],[1.],[0.]])
labels = tr.tensor([[1.],[1.],[0.],[0.]])
print("accuracy is:", accuracy(preds, labels))

accuracy is: tensor(0.5000)

3.1.6 完善Runner类

基于RunnerV1，本章的RunnerV2类在训练过程中使用梯度下降法进行网络优化，模型训练过程中计算在训练集和验证集上的损失及评估指标并打印，训练过程中保存最优模型。

# 用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):
        tr.save(self.model.params, save_path)
 
    def load_model(self, model_path):
        self.model.params = tr.load(model_path)

3.1.7 模型训练

Logistic回归模型的训练，使用交叉熵损失函数和梯度下降法进行优化。
使用训练集和验证集进行模型训练，共训练 500个epoch，每隔50个epoch打印出训练集上的指标。

#3.1.7
# 固定随机种子，保持每次运行结果一致
tr.seed()
 
# 特征维度
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")
 
 
# 可视化观察训练集与验证集的指标变化情况
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='#e4007f', label="Train loss")
    # 绘制评价损失变化曲线
    plt.plot(epochs, runner.dev_loss, color='#f19ec2', linestyle='--', label="Dev loss")
    # 绘制坐标轴和图例
    plt.ylabel("loss", fontsize='large')
    plt.xlabel("epoch", fontsize='large')
    plt.legend(loc='upper right', fontsize='x-large')
    plt.subplot(1,2,2)
    # 绘制训练准确率变化曲线
    plt.plot(epochs, runner.train_scores, color='#e4007f', label="Train accuracy")
    # 绘制评价准确率变化曲线
    plt.plot(epochs, runner.dev_scores, color='#f19ec2', linestyle='--', label="Dev accuracy")
    # 绘制坐标轴和图例
    plt.ylabel("score", fontsize='large')
    plt.xlabel("epoch", fontsize='large')
    plt.legend(loc='lower right', fontsize='x-large')
    plt.tight_layout()
    plt.savefig(fig_name)
    plt.show()
 
plot(runner,fig_name='linear-acc.pdf')

输出

3.1.8 模型评价

使用测试集对训练完成后的最终模型进行评价，观察模型在测试集上的准确率和loss数据。

score, loss = runner.evaluate([X_test, y_test])
print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))
def decision_boundary(w, b, x1):
    w1, w2 = w
    x2 = (- w1 * x1 - b) / w2
    return x2
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 = tr.linspace(-2, 3, 1000)
x2 = decision_boundary(w, b, x1)
# 绘制决策边界
plt.plot(x1.tolist(), x2.tolist(), color="red")
plt.show()

[Test] score/loss: 0.2950/0.5748

输出

3.2 基于Softmax回归的多分类任务

Logistic回归可以有效地解决二分类问题。

但在分类任务中，还有一类多分类问题，即类别数C大于2 的分类问题。

Softmax回归就是Logistic回归在多分类问题上的推广。

3.2.1 数据集构建

数据来自3个不同的簇，每个簇对一个类别。我们采集1000条样本，每个样本包含2个特征。

import numpy as np
import torch as tr
import matplotlib.pyplot as plt
 
 
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 = tr.zeros([n_samples, n_features])
    y = tr.zeros([n_samples], dtype=tr.int32)
    # 随机生成3个簇中心作为类别中心
    centroids = tr.randperm(2 ** n_features)[:n_classes]
    centroids_bin = np.unpackbits(centroids.numpy().astype('uint8')).reshape((-1, 8))[:, -n_features:]
    centroids = tr.tensor(centroids_bin, dtype=tr.float32)
    # 控制簇中心的分离程度
    centroids = 1.5 * centroids - 1
    # 随机生成特征值
    X[:, :n_features] = tr.randn(size=[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 * tr.rand(size=[n_features, n_features]) - 1
        X_k[...] = tr.matmul(X_k, A)
        X_k += centroid
        X[start:stop, :n_features] = X_k
 
    # 如果noise不为None，则给特征加入噪声
    if noise > 0.0:
        # 生成noise掩膜，用来指定给那些样本加入噪声
        noise_mask = tr.rand([n_samples]) < noise
        for i in range(len(noise_mask)):
            if noise_mask[i]:
                # 给加噪声的样本随机赋标签值
                y[i] = tr.randint(n_classes, size=[1]).int()
    # 如果shuffle为True，将所有数据打乱
    if shuffle:
        idx = tr.randperm(X.shape[0])
        X = X[idx]
        y = y[idx]
 
    return X, y
 
 
# 固定随机种子，保持每次运行结果一致
tr.seed()
# 采样1000个样本
n_samples = 1000
X, y = make_multiclass_classification(n_samples=n_samples, n_features=2, n_classes=3, noise=0.2)
 
# 可视化生产的数据集，不同颜色代表不同类别
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()

 
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)
 
# 打印前5个数据的标签
print(y_train[:5])

X_train shape:  torch.Size([640, 2]) y_train shape:  torch.Size([640])
tensor([0, 2, 1, 1, 2], dtype=torch.int32)
 
Process finished with exit code 0

3.2.2 模型构建

#3.2.2.1
# x为tensor
def softmax(X):
    """
    输入：
        - X：shape=[N, C]，N为向量数量，C为向量维度
    """
    x_max = tr.max(X, 1, True)#N,1
    x_exp = tr.exp(X - x_max.values)
    partition = tr.sum(x_exp, 1, True)#N,1
    return x_exp / partition
 
# 观察softmax的计算方式
X = tr.tensor([[0.1, 0.2, 0.3, 0.4],[1,2,3,4]])
predict = softmax(X)
print(predict)
#3.2.2.2
from nndl import op
class model_SR(op.Op):
    def __init__(self, input_dim, output_dim):
        super(model_SR, self).__init__()
        self.params = {}
        # 将线性层的权重参数全部初始化为0
        self.params['W'] = tr.zeros(size=[input_dim, output_dim])
        # self.params['W'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, output_dim])
        # 将线性层的偏置参数初始化为0
        self.params['b'] = tr.zeros(size=[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 = tr.matmul(inputs, self.params['W']) + self.params['b']
        # Softmax 函数
        self.outputs = softmax(score)
        return self.outputs
 
# 随机生成1条长度为4的数据
inputs = tr.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)

indices=tensor([[0]]))
Output is: tensor([[0.3333, 0.3333, 0.3333]])

思考题：Logistic函数是激活函数。Softmax函数是激活函数么？谈谈你的看法。

答：Softmax函数是用于多类分类问题的激活函数，在多类分类问题中，超过两个类标签则需要类成员关系。对于长度为K KK的任意实向量，Softmax函数可以将其压缩为长度为K KK，值在[ 0 , 1 ] [0,1][0,1]范围内，并且向量中元素的总和为1的实向量。

3.2.3 损失函数

#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 -= tr.log(self.predicts[i][index])
        return loss / self.num
 
# 测试一下
# 假设真实标签为第1类
labels = tr.tensor([0])
# 计算风险函数
mce_loss = MultiCrossEntropyLoss()
print(mce_loss(outputs, labels))

tensor(1.0986)

3.2.4 模型优化

使用3.1.4.2中实现的梯度下降法进行参数更新

#3.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'] = tr.zeros(size=[input_dim, output_dim])
        # self.params['W'] = paddle.normal(mean=0, std=0.01, shape=[input_dim, output_dim])
        # 将线性层的偏置参数初始化为0
        self.params['b'] = tr.zeros(size=[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 = tr.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 = tr.nn.functional.one_hot(labels, self.output_dim)
        self.grads['W'] = -1 / N * tr.matmul(self.X.t(), (labels-self.outputs))
        self.grads['b'] = -1 / N * tr.matmul(tr.ones(size=[N]), (labels-self.outputs))

3.2.5 模型训练

实例化RunnerV2类，并传入训练配置。使用训练集和验证集进行模型训练，共训练500个epoch。每隔50个epoch打印训练集上的指标。

#3.2.5
# 固定随机种子，保持每次运行结果一致
tr.seed()
 
# 特征维度
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')

输出

3.2.6 模型评价

使用测试集对训练完成后的最终模型进行评价，观察模型在测试集上的准确率。

#3.2.6
score, loss = runner.evaluate([X_test, y_test])
print("[Test] score/loss: {:.4f}/{:.4f}".format(score, loss))
 
# 均匀生成40000个数据点
x1, x2 = tr.meshgrid(tr.linspace(-3.5, 2, 200), tr.linspace(-4.5, 3.5, 200))
x = tr.stack([tr.flatten(x1), tr.flatten(x2)], 1)
# 预测对应类别
y = runner.predict(x)
y = tr.argmax(y, 1)
# 绘制类别区域
plt.ylabel('x2')
plt.xlabel('x1')
plt.scatter(x[:,0].tolist(), x[:,1].tolist(), c=y.tolist(), cmap=plt.cm.Spectral)
 
tr.seed()
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())

[Test] score/loss: 0.7200/0.7704

输出

3.3 实践：基于Softmax回归完成鸢尾花分类任务

步骤：数据处理、模型构建、损失函数定义、优化器构建、模型训练、模型评价和模型预测等，

数据处理：根据网络接收的数据格式，完成相应的预处理操作，保证模型正常读取；
模型构建：定义Softmax回归模型类；
训练配置：训练相关的一些配置，如：优化算法、评价指标等；
组装Runner类：Runner用于管理模型训练和测试过程；
模型训练和测试：利用Runner进行模型训练、评价和测试。
（说明：使用深度学习进行实践时的操作流程基本一致，后文不再赘述。）

主要配置：

数据：Iris数据集；
模型：Softmax回归模型；
损失函数：交叉熵损失；
优化器：梯度下降法；
评价指标：准确率。
为了加深对机器学习模型的理解，请自己动手完成以下实验：

3.3.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())

0
0

#异常值处理
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)

输出

#数据读取
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, 0)
    X_max = torch.max(X, 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
 
# 固定随机种子
torch.seed()
 
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:]
# 打印X_train和y_train的维度
print("X_train shape: ", X_train.shape, "y_train shape: ", y_train.shape)
# 打印前5个数据的标签
print(y_train[:5])

X shape:  torch.Size([150, 4]) y shape:  torch.Size([150])
X_train shape:  torch.Size([120, 4]) y_train shape:  torch.Size([120])
tensor([1, 1, 2, 0, 1], dtype=torch.int32)

3.3.2模型构建

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

3.3.3模型训练

#3.3.3
from nndl import op, metric, opitimizer, runnerV2
# 学习率
lr = 0.2
 
# 梯度下降法
optimizer = SimpleBatchGD(init_lr=lr, model=model)
# 交叉熵损失
loss_fn = MultiCrossEntropyLoss()
# 准确率
metric = metric.accuracy
 
# 实例化RunnerV2
runner = RunnerV2(model, optimizer, metric, loss_fn)
 
# 启动训练
runner.train([X_train, y_train], [X_dev, y_dev], num_epochs=200, log_epochs=10, save_path="best_model.pdparams")

best accuracy performence has been updated: 0.00000 --> 0.53333
[Train] epoch: 0, loss: 1.09861159324646, score: 0.375
[Dev] epoch: 0, loss: 1.0864840745925903, score: 0.5333333611488342
[Train] epoch: 10, loss: 0.9832408428192139, score: 0.6916666626930237
[Dev] epoch: 10, loss: 0.9968279600143433, score: 0.5333333611488342
[Train] epoch: 20, loss: 0.8964821696281433, score: 0.6916666626930237
[Dev] epoch: 20, loss: 0.932120144367218, score: 0.5333333611488342
[Train] epoch: 30, loss: 0.8276765942573547, score: 0.6916666626930237
[Dev] epoch: 30, loss: 0.8794916868209839, score: 0.5333333611488342
[Train] epoch: 40, loss: 0.7723132371902466, score: 0.7083333134651184
[Dev] epoch: 40, loss: 0.8355364203453064, score: 0.5333333611488342
[Train] epoch: 50, loss: 0.7271296977996826, score: 0.7166666388511658
[Dev] epoch: 50, loss: 0.7983362078666687, score: 0.5333333611488342
[Train] epoch: 60, loss: 0.6896953582763672, score: 0.7333333492279053
[Dev] epoch: 60, loss: 0.7664929032325745, score: 0.5333333611488342
best accuracy performence has been updated: 0.53333 --> 0.60000
[Train] epoch: 70, loss: 0.6582178473472595, score: 0.75
[Dev] epoch: 70, loss: 0.7389351725578308, score: 0.6000000238418579
[Train] epoch: 80, loss: 0.6313791871070862, score: 0.7583333253860474
[Dev] epoch: 80, loss: 0.7148336172103882, score: 0.6000000238418579
best accuracy performence has been updated: 0.60000 --> 0.66667
best accuracy performence has been updated: 0.66667 --> 0.73333
[Train] epoch: 90, loss: 0.6082016825675964, score: 0.800000011920929
[Dev] epoch: 90, loss: 0.6935451030731201, score: 0.7333333492279053
[Train] epoch: 100, loss: 0.5879534482955933, score: 0.800000011920929
[Dev] epoch: 100, loss: 0.6745683550834656, score: 0.7333333492279053
[Train] epoch: 110, loss: 0.5700806379318237, score: 0.8166666626930237
[Dev] epoch: 110, loss: 0.6575102210044861, score: 0.7333333492279053
[Train] epoch: 120, loss: 0.5541572570800781, score: 0.8333333134651184
[Dev] epoch: 120, loss: 0.6420602798461914, score: 0.7333333492279053
best accuracy performence has been updated: 0.73333 --> 0.80000
[Train] epoch: 130, loss: 0.5398533344268799, score: 0.8416666388511658
[Dev] epoch: 130, loss: 0.6279710531234741, score: 0.800000011920929
[Train] epoch: 140, loss: 0.5269086956977844, score: 0.8500000238418579
[Dev] epoch: 140, loss: 0.6150435209274292, score: 0.800000011920929
[Train] epoch: 150, loss: 0.5151160955429077, score: 0.8500000238418579
[Dev] epoch: 150, loss: 0.6031162738800049, score: 0.800000011920929
[Train] epoch: 160, loss: 0.5043091177940369, score: 0.8500000238418579
[Dev] epoch: 160, loss: 0.5920573472976685, score: 0.800000011920929
[Train] epoch: 170, loss: 0.49435245990753174, score: 0.8583333492279053
[Dev] epoch: 170, loss: 0.5817575454711914, score: 0.800000011920929
[Train] epoch: 180, loss: 0.48513472080230713, score: 0.8666666746139526
[Dev] epoch: 180, loss: 0.5721263289451599, score: 0.800000011920929
[Train] epoch: 190, loss: 0.4765640199184418, score: 0.875
[Dev] epoch: 190, loss: 0.5630874037742615, score: 0.800000011920929
 
Process finished with exit code 0

3.3.4模型评价

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

[Test] score/loss: 0.8667/0.7783

3.3.5 模型预测

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

The true category is 1 and the predicted category is 1

尝试调整学习率和训练轮数等超参数，观察是否能够得到更高的精度；（必须完成）
答：当学习率为0.15，训练为800轮时

[Test] score/loss: 0.9333/0.2956

实验总结

通过本次实验Logistic回归、softmax回归有了更加清晰的认识，对这些函数的分类问题，模型构建，训练的过程更加熟悉。

Sun.02

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
NNDL 实验四线性分类

通过本次实验Logistic回归、softmax回归有了更加清晰的认识，对这些函数的分类问题，模型构建，训练的过程更加熟悉。
复制链接

扫一扫

NNDL 实验四 线性分类

3.1 基于Logistic回归的二分类任务

3.1.1 数据集构建

3.1.2 模型构建

3.1.3 损失函数

3.1.4 模型优化

3.1.5 评价指标

3.1.6 完善Runner类

3.1.7 模型训练

3.1.8 模型评价

3.2 基于Softmax回归的多分类任务

3.2.1 数据集构建

3.2.2 模型构建

3.2.3 损失函数

3.2.4 模型优化

3.2.5 模型训练

3.2.6 模型评价

3.3 实践：基于Softmax回归完成鸢尾花分类任务

3.3.1数据处理

3.3.2模型构建

3.3.3模型训练

3.3.4模型评价

3.3.5 模型预测

实验总结

NNDL 实验四线性分类