当前位置： 首页 > news >正文

深度学习Note.4(机器学习实践）

news 来源：原创 2025/6/3 20:25:18

线性回归

零.

1.paddle库的一些API

paddle.rand(shape,dtype = None, name = None)

*随机生成符合均匀分布的Tensor

paddle.nromal(mean = 0.0, std = 1.0, shape = None, name = None)

*随机生成符合正态分布的Tensor

*输入正态分布均值，标准差， 生成结果的形状

*输出形状为shape的Tensor

paddle.randint(low = 0, high = None, shape = [1],dtype = 0, name = none)

*在指定范围内生成符合均匀分布的Tensor

*输入范围的上下限。。。

paddle.linspace(start, stop, num, dtype = None, name = None)

*在指定区间生成均匀间隔的是定个值

*输入区间，区间数，输出1-DTensor 

paddle.rann(shape, dtype = None, name = None)

随机生成符合标准正态分布的Tensor 

paddle.zeros(shape, dtype = None, name = None)

生成指定形状的全0 Tensor 

 paddle.full(shape, fill_value, dtype=None,name=None)

创建指定形状元素值均为指定值的Tensor

输入：生成结果的形状，元素值    输出：形状为shape值全为fill_value的Tensor

 paddle.matmul(x, y, transpose_x=False,transpose_y=False, name=None)

功能：计算两个Tensor乘积，遵循广播规则
输入：两个Tensor以及相乘前是否转置
输出：Tensor，矩阵相乘后的结果

 paddle.mean(x, axis=None, keepdim=False,name=None)
功能：沿axis计算输入的平均值
输入：Tensor，计算轴，是否在输出种保留减少的维度
输出：Tensor，沿着axis进行平均值计算的结果

paddle.square(x, name=None)
功能：逐元素取平方
输入：Tensor
输出：返回取平方后的Tensor 

paddle.subtract(x, y, name=None)
功能：逐元素相减
输入：输入2个Tensor
输出：Tensor，运算后的结果

paddle.eye(num_rows, num_columns=None, dtype=None, name=None)
功能：构建二维Tensor(主对角线元素为1，其他元素为0)
输入：行数和列数
输出:Tensor, shape为[num_rows, num_columns]

paddle.inverse(x,name=None)
功能：计算方阵的逆
输入：输入Tensor
输出：输入方阵的逆   

 2.matplotlib库学习

一.数据集构建

import paddle
from matplotlib import pyplot as plt

def linear_func(x, w=1.2, b=0.5):
    return w * x + b

def create_toy_data(func, interval, sample_num, noise=0.0, add_outlier=False, outlier_ratio=0.01):
    X = paddle.rand(shape=[sample_num]) * (interval[1] - interval[0]) + interval[0]
    y = func(X)
    epsilon = paddle.normal(0, noise, shape=[y.shape[0]])
    y += epsilon
    if add_outlier:
        outlier_num = max(1, int(len(y) * outlier_ratio))
        outlier_idx = paddle.randint(len(y), shape=[outlier_num])
        y[outlier_idx] = y[outlier_idx] * 5
    return X.numpy(), y.numpy()  # 返回 NumPy 数组

# 生成数据
func = linear_func
interval = (-10, 10)
train_num = 100
test_num = 50
noise = 2

X_train, y_train = create_toy_data(func, interval, train_num, noise, add_outlier=False)
X_test, y_test = create_toy_data(func, interval, test_num, noise, add_outlier=False)

# 生成理论分布数据（转换为 NumPy）
X_underlying = paddle.linspace(interval[0], interval[1], train_num).numpy()
y_underlying = linear_func(paddle.to_tensor(X_underlying)).numpy()  # 确保输出为 NumPy

# 绘图
plt.figure(figsize=(8, 6))
plt.scatter(X_train, y_train, marker='*', facecolor="none", edgecolor='green', s=50, label="Train Data")
plt.scatter(X_test, y_test, facecolor="none", edgecolor='red', s=50, label="Test Data")
plt.plot(X_underlying, y_underlying, c='#000000', linestyle='--', label="Underlying Distribution")
plt.xlabel("X", fontsize=12)
plt.ylabel("y", fontsize=12)
plt.title("Linear Regression Dataset", fontsize=14)
plt.legend()
plt.grid(True, linestyle=':', alpha=0.5)
plt.savefig('ml-vis.pdf', bbox_inches='tight', dpi=300)
plt.show()

结果;

二.模型构建

                                                                    f(x;w,b)=wTx+b

y=Xw+b

import paddle
from nndl.op import Op

paddle.seed(10) #设置随机种子

# 线性算子
class Linear(Op):
    def __init__(self, input_size):
        """
        输入：
           - input_size:模型要处理的数据特征向量长度
        """

        self.input_size = input_size

        # 模型参数
        self.params = {}
        self.params['w'] = paddle.randn(shape=[self.input_size,1],dtype='float32') 
        self.params['b'] = paddle.zeros(shape=[1],dtype='float32')

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

    # 前向函数
    def forward(self, X):
        """
        输入：
           - X: tensor, shape=[N,D]
           注意这里的X矩阵是由N个x向量的转置拼接成的，与原教材行向量表示方式不一致
        输出：
           - y_pred： tensor, shape=[N]
        """

        N,D = X.shape

        if self.input_size==0:
            return paddle.full(shape=[N,1], fill_value=self.params['b'])
        
        assert D==self.input_size # 输入数据维度合法性验证

        # 使用paddle.matmul计算两个tensor的乘积
        y_pred = paddle.matmul(X,self.params['w'])+self.params['b']
        
        return y_pred

# 注意这里我们为了和后面章节统一，这里的X矩阵是由N个x向量的转置拼接成的，与原教材行向量表示方式不一致
input_size = 3
N = 2
X = paddle.randn(shape=[N, input_size],dtype='float32') # 生成2个维度为3的数据
model = Linear(input_size)
y_pred = model(X)
print("y_pred:",y_pred) #输出结果的个数也是2个

三.损失函数

回归任务是对连续值的预测，希望模型能根据数据的特征输出一个连续值作为预测值。因此回归任务中常用的评估指标是均方误差

import paddle

def mean_squared_error(y_true, y_pred):
    """
    输入：
       - y_true: tensor，样本真实标签
       - y_pred: tensor, 样本预测标签
    输出：
       - error: float，误差值
    """

    assert y_true.shape[0] == y_pred.shape[0]
    
    # paddle.square计算输入的平方值
    # paddle.mean沿 axis 计算 x 的平均值，默认axis是None，则对输入的全部元素计算平均值。
    error = paddle.mean(paddle.square(y_true - y_pred))

    return error


# 构造一个简单的样例进行测试:[N,1], N=2
y_true= paddle.to_tensor([[-0.2],[4.9]],dtype='float32')
y_pred = paddle.to_tensor([[1.3],[2.5]],dtype='float32')

error = mean_squared_error(y_true=y_true, y_pred=y_pred).item()
print("error:",error)

四.模型优化

经验风险最小化，利用偏导数为0求最小

def optimizer_lsm(model, X, y, reg_lambda=0):
  """
    输入：
       - model: 模型
       - X: tensor, 特征数据，shape=[N,D]
       - y: tensor,标签数据，shape=[N]
       - reg_lambda: float, 正则化系数，默认为0
    输出：
       - model: 优化好的模型
    """

  N, D = X.shape

  # 对输入特征数据所有特征向量求平均
  x_bar_tran = paddle.mean(X,axis=0).T 
  
  # 求标签的均值,shape=[1]
  y_bar = paddle.mean(y)
  
  # paddle.subtract通过广播的方式实现矩阵减向量
  x_sub = paddle.subtract(X,x_bar_tran)

  # 使用paddle.all判断输入tensor是否全0
  if paddle.all(x_sub==0):
    model.params['b'] = y_bar
    model.params['w'] = paddle.zeros(shape=[D])
    return model
  
  # paddle.inverse求方阵的逆
  tmp = paddle.inverse(paddle.matmul(x_sub.T,x_sub)+
          reg_lambda*paddle.eye(num_rows = (D)))

  w = paddle.matmul(paddle.matmul(tmp,x_sub.T),(y-y_bar))
  
  b = y_bar-paddle.matmul(x_bar_tran,w)
  
  model.params['b'] = b
  model.params['w'] = paddle.squeeze(w,axis=-1)

  return model

五.模型训练

模型的评价指标和损失函数一致，都为均方误差。

通过上文实现的线性回归类来拟合训练数据，并输出模型在训练集上的损失。

input_size = 1
model = Linear(input_size)
model = optimizer_lsm(model,X_train.reshape([-1,1]),y_train.reshape([-1,1]))
print("w_pred:",model.params['w'].item(), "b_pred: ", model.params['b'].item())

y_train_pred = model(X_train.reshape([-1,1])).squeeze()
train_error = mean_squared_error(y_true=y_train, y_pred=y_train_pred).item()
print("train error: ",train_error)

model_large = Linear(input_size)
model_large = optimizer_lsm(model_large,X_train_large.reshape([-1,1]),y_train_large.reshape([-1,1]))
print("w_pred large:",model_large.params['w'].item(), "b_pred large: ", model_large.params['b'].item())

y_train_pred_large = model_large(X_train_large.reshape([-1,1])).squeeze()
train_error_large = mean_squared_error(y_true=y_train_large, y_pred=y_train_pred_large).item()
print("train error large: ",train_error_large)

六.模型评估

用训练好的模型预测一下测试集的标签，并计算在测试集上的损失。

y_test_pred = model(X_test.reshape([-1,1])).squeeze()
test_error = mean_squared_error(y_true=y_test, y_pred=y_test_pred).item()
print("test error: ",test_error)
y_test_pred_large = model_large(X_test.reshape([-1,1])).squeeze()
test_error_large = mean_squared_error(y_true=y_test, y_pred=y_test_pred_large).item()
print("test error large: ",test_error_large)

相关文章：

  • C++细节知识for面试
  • C 语言常用关键字详解：static、const、volatile
  • 对于后端已经实现逻辑了，而前端还没有设置显示的改造
  • LLM 优化技术(2)——paged_attention 原理
  • 进程间通信—system v标准
  • leetcode102 二叉树的层次遍历 使用队列实现二叉树广度优先遍历
  • vue2、vue3项目中遇到的问题总结(一)
  • 【网络协议】【http】http 简单介绍
  • vue-cli工具build测试与生产包对css处理的不同
  • PDF 文本提取为何如此困难？– 原因和解决方案
  • 如何破解软件自动化测试框架的维护难题
  • 跨境电商生死存亡：AI反检测技术是否能为卖家保驾护航？
  • Ubuntu桌面环境下网络设置选项缺失问题解决
  • 在Java中集成DeepSeek的详细步骤
  • ADAS智能驾驶功能
  • 前端 VSCODE 插件开发总结 （后续将出专栏详细讲解开发的细节...）
  • 【性能优化点滴】odygrd/quill 中将 MacroMetadata 变量声明为 constexpr
  • 蓝桥杯 双子数
  • Go 语言标准库中Channels，Goroutines详细功能介绍与示例
  • 2025AWE观察：“无AI不家电”，但“AI”还是“AL”仍是个问题
  • wordpress oa 插件/东莞seo网站排名优化公司
  • 织梦高端html5网站建设工作室网络公司网站模板/企业微信营销系统
  • 电子商务网站系统规划报告/企业产品推广策划方案
  • 大型网站稳定性建设视频课程/网建
  • 推广怎么推/seo工作内容
  • 小程序制作实惠首选华网天下/seo课程培训入门