【机器学习】自定义数据集使用框架的线性回归方法对其进行拟合

一、使用框架的线性回归方法

1. 基础原理

        在自求导线性回归中，我们需要先自定义参数，并且需要通过数学公式来对w和b进行求导，然后在反向传播过程中通过梯度下降的方式来更新参数，从而降低损失值。

2. 实现步骤

① 散点输入

        有一些散点，将它们绘制在一个二维坐标中，其分布如下图所示：

② 定义前向模型

        准备好数据之后，就需要定义前向模型了。在这里给出了“定义前向模型”组件，如下图所示。

③ 定义损失函数和优化器

        在选择好前向的模型后，需要定义反向传播过程中用到的一些超参数。在深度学习的三种框架中，关于损失函数和优化器的代码实现都已经封装好了，只需要选择使用哪种即可。

④ 开始迭代

在选择好损失函数及优化器之后，我们就可以进行迭代了。通过不断的迭代更新，使w和b的值不断更新，从而降低损失函数值，使直线的拟合效果更好，本实验中，“开始迭代”组件中默认选择的迭代次数是1000次，可以选择不同的迭代次数来观察直线的拟合效果。

⑤ 显示频率设置

        迭代次数选好之后，就开始进行迭代了，为了能够观察到迭代过程中的现象，给出了“显示频率设置”的组件，该组件能够设置每迭代多少次，显示一次当前的参数值和损失值。

⑥ 拟合线显示与输出

        选择好显示频率之后，通过“拟合线显示与输出”组件来查看我们的迭代过程中参数、直线及损失值的变化，内容如下图所示：

二、pytorch框架线性回归

1. 数据部分：

  • 首先自定义了一个简单的数据集，特征 X 是 100 个随机样本，每个样本一个特征，目标值 y 基于线性关系并添加了噪声。
  • 将 numpy 数组转换为 PyTorch 张量，方便后续在模型中使用。

2. 模型定义部分：

方案 1：使用 nn.Sequential 直接按顺序定义了一个线性层，简洁直观。

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义线性回归模型
model = nn.Sequential(nn.Linear(1, 1)
)# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):# 前向传播outputs = model(X_tensor)loss = criterion(outputs, y_tensor)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()if (epoch + 1) % 100 == 0:print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')# 模型评估
with torch.no_grad():y_pred = model(X_tensor).numpy()mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
print("模型系数:", model[0].weight.item())
print("模型截距:", model[0].bias.item())

方案 2：使用 nn.ModuleList 存储线性层，在 forward 方法中依次调用层进行前向传播，适合动态构建层序列。

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义线性回归模型
class LinearRegression(nn.Module):def __init__(self):super(LinearRegression, self).__init__()self.layers = nn.ModuleList([nn.Linear(1, 1)])def forward(self, x):for layer in self.layers:x = layer(x)return xmodel = LinearRegression()# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):# 前向传播outputs = model(X_tensor)loss = criterion(outputs, y_tensor)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()if (epoch + 1) % 100 == 0:print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')# 模型评估
with torch.no_grad():y_pred = model(X_tensor).numpy()mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
print("模型系数:", model.layers[0].weight.item())
print("模型截距:", model.layers[0].bias.item())

方案 3：使用 nn.ModuleDict 以字典形式存储层，通过键名调用层，适合需要对层进行命名和灵活访问的场景。

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义线性回归模型
class LinearRegression(nn.Module):def __init__(self):super(LinearRegression, self).__init__()self.layers = nn.ModuleDict({'linear': nn.Linear(1, 1)})def forward(self, x):x = self.layers['linear'](x)return xmodel = LinearRegression()# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):# 前向传播outputs = model(X_tensor)loss = criterion(outputs, y_tensor)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()if (epoch + 1) % 100 == 0:print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')# 模型评估
with torch.no_grad():y_pred = model(X_tensor).numpy()mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
print("模型系数:", model.layers['linear'].weight.item())
print("模型截距:", model.layers['linear'].bias.item())

方案 4：直接继承 nn.Module，在 __init__ 方法中定义线性层，在 forward 方法中实现前向传播逻辑，是最常见和基础的定义模型方式。

import torch
import torch.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义线性回归模型
class LinearRegression(nn.Module):def __init__(self):super(LinearRegression, self).__init__()self.linear = nn.Linear(1, 1)def forward(self, x):return self.linear(x)model = LinearRegression()# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)# 训练模型
num_epochs = 1000
for epoch in range(num_epochs):# 前向传播outputs = model(X_tensor)loss = criterion(outputs, y_tensor)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()if (epoch + 1) % 100 == 0:print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')# 模型评估
with torch.no_grad():y_pred = model(X_tensor).numpy()mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
print("模型系数:", model.linear.weight.item())
print("模型截距:", model.linear.bias.item())

3. 训练和评估部分：

  • 定义了均方误差损失函数 nn.MSELoss 和随机梯度下降优化器 torch.optim.SGD。
  • 通过多个 epoch 进行训练，每个 epoch 包含前向传播、损失计算、反向传播和参数更新。
  • 训练结束后，在无梯度计算模式下进行预测，并使用 scikit-learn 的指标计算均方误差和决定系数评估模型性能，最后输出模型的系数和截距。

三、tensorflow框架线性回归

1. 数据部分：

  • 首先自定义了一个简单的数据集，特征 X 是 100 个随机样本，每个样本一个特征，目标值 y 基于线性关系并添加了噪声。
  • tensorflow框架不需要numpy 数组转换为相应的张量，可以直接在模型中使用数据集。

2. 模型定义部分：

方案 1：model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])

解释：

  • 此方案使用 tf.keras.Sequential 构建模型，在列表中直接定义了一个 Dense 层，input_shape=(1,) 表明输入数据的形状。
  • 编译模型时，选择随机梯度下降（SGD）优化器和均方误差损失函数。
  • 训练完成后，使用 sklearn 的指标评估模型，并输出模型的系数和截距。
import tensorflow as tf
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 构建模型
model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))
])# 编译模型
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.01),loss='mean_squared_error')# 训练模型
history = model.fit(X, y, epochs=1000, verbose=0)# 模型评估
y_pred = model.predict(X)
mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
weights, biases = model.layers[0].get_weights()
print(f"模型系数: {weights[0][0]}")
print(f"模型截距: {biases[0]}")

方案 2：model = tf.keras.Sequential()

解释：

  • 这种方式先创建一个空的 Sequential 模型，再使用 add 方法添加 Dense 层。
  • 后续编译、训练、评估和输出模型参数的步骤与方案 1 类似。
import tensorflow as tf
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 构建模型
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(1, input_shape=(1,)))# 编译模型
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.01),loss='mean_squared_error')# 训练模型
history = model.fit(X, y, epochs=1000, verbose=0)# 模型评估
y_pred = model.predict(X)
mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
weights, biases = model.layers[0].get_weights()
print(f"模型系数: {weights[0][0]}")
print(f"模型截距: {biases[0]}")

方案 3：自定义模型类

解释：

  • 继承 Model 基类创建自定义模型类 Linear，在 __init__ 方法中定义 Dense 层。
  • call 方法用于实现前向传播逻辑，类似于 PyTorch 中的 forward 方法。
  • 后续的编译、训练、评估和参数输出流程和前面方案一致。
import tensorflow as tf
from tensorflow.keras import Model
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 自定义模型类
class Linear(Model):def __init__(self):super(Linear, self).__init__()self.linear = tf.keras.layers.Dense(1)def call(self, x, **kwargs):x = self.linear(x)return x# 构建模型
model = Linear()# 编译模型
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.01),loss='mean_squared_error')# 训练模型
history = model.fit(X, y, epochs=1000, verbose=0)# 模型评估
y_pred = model.predict(X)
mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
weights, biases = model.linear.get_weights()
print(f"模型系数: {weights[0][0]}")
print(f"模型截距: {biases[0]}")

方案 4：函数式 API 构建模型

解释：

  • 使用函数式 API 构建模型，先定义输入层，再定义 Dense 层，最后使用 Model 类将输入和输出连接起来形成模型。
  • 编译、训练、评估和参数输出的步骤和前面方案相同。注意这里通过 model.layers[1] 获取 Dense 层的权重和偏置，因为第一层是输入层。
import tensorflow as tf
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score# 自定义数据集
X = np.random.rand(100, 1).astype(np.float32)
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 定义函数构建模型
def linear():input = tf.keras.layers.Input(shape=(1,), dtype=tf.float32)y = tf.keras.layers.Dense(1)(input)model = tf.keras.models.Model(inputs=input, outputs=y)return model# 构建模型
model = linear()# 编译模型
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.01),loss='mean_squared_error')# 训练模型
history = model.fit(X, y, epochs=1000, verbose=0)# 模型评估
y_pred = model.predict(X)
mse = mean_squared_error(y, y_pred)
r2 = r2_score(y, y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
weights, biases = model.layers[1].get_weights()
print(f"模型系数: {weights[0][0]}")
print(f"模型截距: {biases[0]}")

3. 训练和评估部分：

  • 使用 fit 方法对模型进行训练，verbose=0 表示不显示训练过程中的详细信息，训练过程中的损失信息会存储在 history 对象中。
  • 通过多个 epoch 进行训练，每个 epoch 包含前向传播、损失计算、反向传播和参数更新。
  • 使用 predict 方法进行预测，计算均方误差和决定系数评估模型性能，通过 model.linear.get_weights() 获取模型的系数和截距。

四、paddlepaddle框架线性回归

1. 数据部分：

  • 首先自定义了一个简单的数据集，特征 X 是 100 个随机样本，每个样本一个特征，目标值 y 基于线性关系并添加了噪声。
  • 将 numpy 数转换为Paddlepaddle张量，方便后续在模型中使用。

2. 模型定义部分：

方案 1：使用 nn.Sequential 组网

代码解释

① 数据生成与转换：

  • 生成自定义的特征矩阵 X 和目标值向量 y，并添加高斯噪声模拟真实数据。
  • 使用 paddle.to_tensor 将 numpy 数组转换为 PaddlePaddle 张量。

② 模型组网：

  • 使用 nn.Sequential 快速构建线性回归模型，只包含一个 nn.Linear 层。

③ 损失函数和优化器：

  • 选择均方误差损失函数 nn.MSELoss 和随机梯度下降优化器 paddle.optimizer.SGD。

④ 模型训练：

  • 进行多个轮次的训练，在每个轮次中进行前向传播、损失计算、反向传播和参数更新。
  • 记录每一轮的损失值，用于后续绘制损失曲线。

⑤ 损失曲线绘制：

  • 使用 matplotlib 绘制训练损失随轮次的变化曲线，直观展示模型的训练过程。

⑥ 模型评估：

  • 在无梯度计算的模式下进行预测，计算预测结果的均方误差和决定系数。

⑦ 输出模型参数：

  • 获取模型的系数和截距并输出。
import paddle
import paddle.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score
import matplotlib.pyplot as plt# 自定义数据集
# 生成 100 个样本，每个样本有 1 个特征
X = np.random.rand(100, 1).astype(np.float32)
# 根据特征生成目标值，添加一些噪声
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 将 numpy 数组转换为 PaddlePaddle 张量
X = paddle.to_tensor(X)
y = paddle.to_tensor(y)# 使用 nn.Sequential 组网
model = nn.Sequential(nn.Linear(1, 1)
)# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())# 训练模型
num_epochs = 1000
losses = []
for epoch in range(num_epochs):# 前向传播outputs = model(X)loss = criterion(outputs, y)losses.append(loss.numpy()[0])# 反向传播和优化optimizer.clear_grad()loss.backward()optimizer.step()if (epoch + 1) % 100 == 0:print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.numpy()[0]:.4f}')# 绘制训练损失曲线
plt.plot(range(num_epochs), losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss')
plt.show()# 模型评估
with paddle.no_grad():y_pred = model(X).numpy()mse = mean_squared_error(y.numpy(), y_pred)
r2 = r2_score(y.numpy(), y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
weights = model[0].weight.numpy()[0][0]
bias = model[0].bias.numpy()[0]
print(f"模型系数: {weights}")
print(f"模型截距: {bias}")

方案 2：单独定义，使用类的方式 class nn.Layer 组网

代码解释

此方案与方案 1 的主要区别在于模型的组网方式，具体如下：

模型组网：

① 定义一个继承自 nn.Layer 的自定义模型类 LinearRegression。

② 在 __init__ 方法中初始化 nn.Linear 层。

③ 在 forward 方法中定义前向传播逻辑。

后续步骤：

损失函数、优化器的选择，模型训练、评估以及参数输出等步骤与方案 1 基本相同。

import paddle
import paddle.nn as nn
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score
import matplotlib.pyplot as plt# 自定义数据集
# 生成 100 个样本，每个样本有 1 个特征
X = np.random.rand(100, 1).astype(np.float32)
# 根据特征生成目标值，添加一些噪声
y = 2 * X + 1 + 0.3 * np.random.randn(100, 1).astype(np.float32)# 将 numpy 数组转换为 PaddlePaddle 张量
X = paddle.to_tensor(X)
y = paddle.to_tensor(y)# 自定义模型类，继承自 nn.Layer
class LinearRegression(nn.Layer):def __init__(self):super(LinearRegression, self).__init__()self.linear = nn.Linear(1, 1)def forward(self, x):return self.linear(x)# 创建模型实例
model = LinearRegression()# 定义损失函数和优化器
criterion = nn.MSELoss()
optimizer = paddle.optimizer.SGD(learning_rate=0.01, parameters=model.parameters())# 训练模型
num_epochs = 1000
losses = []
for epoch in range(num_epochs):# 前向传播outputs = model(X)loss = criterion(outputs, y)losses.append(loss.numpy()[0])# 反向传播和优化optimizer.clear_grad()loss.backward()optimizer.step()if (epoch + 1) % 100 == 0:print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.numpy()[0]:.4f}')# 绘制训练损失曲线
plt.plot(range(num_epochs), losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss')
plt.show()# 模型评估
with paddle.no_grad():y_pred = model(X).numpy()mse = mean_squared_error(y.numpy(), y_pred)
r2 = r2_score(y.numpy(), y_pred)
print(f"均方误差 (MSE): {mse}")
print(f"决定系数 (R²): {r2}")# 输出模型的系数和截距
weights = model.linear.weight.numpy()[0][0]
bias = model.linear.bias.numpy()[0]
print(f"模型系数: {weights}")
print(f"模型截距: {bias}")

3. 训练和评估部分：

  • 使用 train_losses 列表记录每一轮训练的损失值，方便后续绘制训练损失曲线，直观观察模型的训练过程。
  • 将数据集按 80:20 的比例划分为训练集和测试集，以更准确地评估模型的泛化能力。
  • 使用 scikit-learn 中的 mean_squared_error 和 r2_score 计算测试集的均方误差和决定系数。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/66949.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

pytest执行报错：found no collectors

pytest执行报错：found no collectors

今天在尝试使用pytest运行用例的时候出现报错：found no collectors；从两个方向进行排查，一是看文件名和函数名是不是符合规范，命名要是"test_*"格式；二是是否存在修改文件名的情况，如果修改过文件…
阅读更多...
mysql-06.JDBC

mysql-06.JDBC

目录 什么是JDBC: 为啥存在JDBC: JDBC工作原理： JDBC的优势： 下载mysql驱动包： 用java程序操作数据库 1.创建dataSource: 2.与服务端建立连接 3.构造sql语句 4.执行sql 5.关闭连接，释放资源 参考代码： 插…
阅读更多...
微信小程序wxs实现UTC转北京时间

微信小程序wxs实现UTC转北京时间

微信小程序实现UTC转北京时间 打脸一刻：最近在迭代原生微信小程序，好一段时间没写原生的，有点不习惯； 咦，更新数据咋不生效呢？原来还停留在 this.xxx； 哟，事件又没反应了&#xff1f…
阅读更多...
机器学习-线性回归（对于f(x；w)=w^Tx+b理解）

机器学习-线性回归（对于f(x；w)=w^Tx+b理解）

一、𝑓(𝒙;𝒘) 𝒘T𝒙的推导 学习线性回归，我们那先要对于线性回归的表达公示，有所认识。 我们先假设空间是一组参数化的线性函数： 其中权重向量𝒘 ∈ R𝐷 …
阅读更多...
R语言学习笔记之语言入门基础

R语言学习笔记之语言入门基础

一、R语言基础 快速熟悉R语言中的基本概念&#xff0c;先入个门。 1、运算符 运算符含义例子加1 1-减3 - 2*乘3 * 2/除9 / 3^(**)乘方2 ^ 3 2 ** 3%%取余5 %% 2%/%取整5 %/% 2 2、赋值符号 等号a 1三者等价&#xff1a;把1赋值给变量a左箭头<−a <- 1右箭头−&g…
阅读更多...
计算机网络三张表（ARP表、MAC表、路由表）总结

计算机网络三张表（ARP表、MAC表、路由表）总结

参考&#xff1a; 网络三张表&#xff1a;ARP表, MAC表, 路由表&#xff0c;实现你的网络自由&#xff01;&#xff01;_mac表、arp表、路由表-CSDN博客 网络中的三张表&#xff1a;ARP表、MAC表、路由表 首先要明确一件事&#xff0c;如果一个主机要发送数据&#xff0c;那么必…
阅读更多...
【Nomoto 船舶模型】

【Nomoto 船舶模型】

【Nomoto 船舶模型】 1. Nomoto 船舶模型简介2. 来源及发展历程3. 构建 一阶模型Nomoto 船舶模型3.1 C 实现3.2 Python 实现3.3 说明 5. 参数辨识方法5.1 基于最小二乘法的参数辨识5.2 数学推导5.3 Python 实现5.4 说明 4. 结论参考文献 1. Nomoto 船舶模型简介 Nomoto 模型是…
阅读更多...
差分进化算法 (Differential Evolution) 算法详解及案例分析

差分进化算法 (Differential Evolution) 算法详解及案例分析

差分进化算法 (Differential Evolution) 算法详解及案例分析 目录 差分进化算法 (Differential Evolution) 算法详解及案例分析1. 引言2. 差分进化算法 (DE) 算法原理2.1 基本概念2.2 算法步骤3. 差分进化算法的优势与局限性3.1 优势3.2 局限性4. 案例分析4.1 案例1: 单目标优化…
阅读更多...
深入理解GPT底层原理--从n-gram到RNN到LSTM/GRU到Transformer/GPT的进化

深入理解GPT底层原理--从n-gram到RNN到LSTM/GRU到Transformer/GPT的进化

从简单的RNN到复杂的LSTM/GRU,再到引入注意力机制,研究者们一直在努力解决序列建模的核心问题。每一步的进展都为下一步的突破奠定了基础,最终孕育出了革命性的Transformer架构和GPT大模型。 1. 从n-gram到循环神经网络(RNN)的诞生 1.1 N-gram 模型 在深度学习兴起之前,处理…
阅读更多...
【JWT】jwt实现HS、RS、ES、ED签名与验签

【JWT】jwt实现HS、RS、ES、ED签名与验签

JWT 实现 HS、RS、ES 和 ED 签名与验签 签名方式算法密钥类型签名要点验签要点HSHMAC-SHA256对称密钥- 使用 crypto/hmac 和对称密钥生成 HMAC 签名- 将 header.payload 作为数据输入- 使用同一密钥重新计算 HMAC 签名- 比较计算结果与接收到的签名是否一致RSRSA-SHA256公钥 …
阅读更多...
地址栏信息location

地址栏信息location

获取信息 页面跳转 location.href当前地址栏信息 location.assign()设置跳转新的页面 location.replace() location.reload()刷新页面
阅读更多...
程序员转型测试：解锁漏洞挖掘新旅程

程序员转型测试：解锁漏洞挖掘新旅程

前言&#xff1a;哈喽&#xff0c;大家好&#xff0c;今天给大家分享一篇文章&#xff01;并提供具体代码帮助大家深入理解&#xff0c;彻底掌握&#xff01;创作不易&#xff0c;如果能帮助到大家或者给大家一些灵感和启发&#xff0c;欢迎收藏关注哦 &#x1f495; 目录 程序…
阅读更多...
StarRocks常用命令

StarRocks常用命令

目录 1、StarRocks 集群管理&配置命令 2、StarRocks 常用操作命令 3、StarRocks 数据导入和导出 1、StarRocks 集群管理&配置命令 查询 FE 节点信息 SHOW frontends; SHOW PROC /frontends; mysql -h192.168.1.250 -P9030 -uroot -p -e "SHOW PROC /dbs;"…
阅读更多...
08-ArcGIS For JavaScript-通过Mesh绘制几何体（Cylinder，Circle，Box，Pyramid）

08-ArcGIS For JavaScript-通过Mesh绘制几何体（Cylinder，Circle，Box，Pyramid）

目录 概述代码实现1、Mesh.createBox2、createPyramid3、Mesh.createSphere4、Mesh.createCylinder 完整代码 概述 对于三维场景而言&#xff0c;二位的点、线、面&#xff0c;三维的圆、立方体、圆柱等都是比较常见的三维对象&#xff0c;在ArcGIS For JavaScript中我们知道点…
阅读更多...
Linux中page、buffer_head、bio的关系

Linux中page、buffer_head、bio的关系

在Linux中&#xff0c;page、buffer_head、bio这三个概念紧密相关&#xff0c;共同构成了块设备I/O和内存管理的重要部分&#xff0c;它们的联系主要体现在以下方面&#xff1a; page与buffer_head 基于page构建&#xff1a;buffer_head通常是基于page来构建的&#xff0c;一…
阅读更多...
直线拟合例子 ，岭回归拟合直线

直线拟合例子 ，岭回归拟合直线

目录 直线拟合,算出离群点 岭回归拟合直线&#xff1a; 直线拟合,算出离群点 import cv2 import numpy as np# 输入的点 points np.array([[51, 149],[122, 374],[225, 376],[340, 382],[463, 391],[535, 298],[596, 400],[689, 406],[821, 407] ], dtypenp.float32)# 使用…
阅读更多...
SpringCloud两种注册中心

SpringCloud两种注册中心

SpringCloud 基本概念 系统架构 我们之前做的所有的项目都属于单体架构&#xff0c;下面我们将要学习更适合大型项目的分布式架构 单体架构&#xff1a; 将业务的所有功能几种在一个项目中开发&#xff0c;打成一个包部署。 优点&#xff1a;架构简单、部署成本低 缺点&am…
阅读更多...
SpringAI 搭建智能体（二）：搭建客服系统智能体

SpringAI 搭建智能体（二）：搭建客服系统智能体

在现代人工智能应用中&#xff0c;智能体&#xff08;Agent&#xff09; 是一个重要的概念&#xff0c;它的核心能力是自主性与灵活性。一个智能体不仅能够理解用户的需求&#xff0c;还能拆解任务、调用工具完成具体操作&#xff0c;并在复杂场景中高效运行。在本篇博客中&…
阅读更多...
SVN客户端使用手册

SVN客户端使用手册

目录 一、简介 二、SVN的安装与卸载 1. 安装&#xff08;公司内部一般会提供安装包和汉化包&#xff0c;直接到公司内部网盘下载即可&#xff0c;如果找不到可以看下面的教程&#xff09; 2. 查看SVN版本 ​编辑 3. SVN卸载 三、SVN的基本操作 1. 检出 2. 清除认证数据 3. 提交…
阅读更多...
HTML 文本格式化详解

HTML 文本格式化详解

在网页开发中&#xff0c;文本内容的呈现方式直接影响用户的阅读体验。HTML 提供了多种文本格式化元素&#xff0c;可以帮助我们更好地控制文本的显示效果。本文将详细介绍 HTML 中的文本格式化元素及其使用方法&#xff0c;帮助你轻松实现网页文本的美化。 什么是 HTML 文本格…
阅读更多...
最新文章

Copyright @ 2022~2023