营销网站制作多少钱seo做得比较好的企业案例

线性回归

零.

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 pltdef linear_func(x, w=1.2, b=0.5):return w * x + bdef 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 += epsilonif 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] * 5return X.numpy(), y.numpy()  # 返回 NumPy 数组# 生成数据
func = linear_func
interval = (-10, 10)
train_num = 100
test_num = 50
noise = 2X_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 Oppaddle.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.shapeif 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 paddledef 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是否全0if paddle.all(x_sub==0):model.params['b'] = y_barmodel.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'] = bmodel.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)