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

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

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.rhkb.cn/news/7333.html

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

相关文章

微服务搭建----springboot接入Nacos2.x

微服务搭建----springboot接入Nacos2.x

springboot接入Nacos2.x nacos之前用的版本是1.0的，现在重新搭建一个2.0版本的，学如逆水行舟，不进则退，废话不多说，开搞 1、 nacos2.x搭建 1，首先第一步查询下项目之间的版本对照，不然后期会…
阅读更多...
扣子平台音频功能：让声音也能“智能”起来

扣子平台音频功能：让声音也能“智能”起来

在数字化时代，音频内容的重要性不言而喻。无论是在线课程、有声读物，还是各种多媒体应用，音频都是传递信息、增强体验的关键元素。扣子平台的音频功能，为开发者和内容创作者提供了一个强大而灵活的工具，让音频的使用和…
阅读更多...
全面了解 Web3 AIGC 和 AI Agent 的创新先锋 MelodAI

全面了解 Web3 AIGC 和 AI Agent 的创新先锋 MelodAI

不管是在传统领域还是 Crypto，AI 都是公认的最有前景的赛道。随着数字内容需求的爆炸式增长和技术的快速迭代，Web3 AIGC（AI生成内容）和 AI Agent（人工智能代理）正成为两大关键赛道。 AIGC 通过 AI 技术生成…
阅读更多...
【Uniapp-Vue3】动态设置页面导航条的样式

【Uniapp-Vue3】动态设置页面导航条的样式

1. 动态修改导航条标题 uni.setNavigationBarTitle({ title:"标题名称" }) 点击修改以后顶部导航栏的标题会从“主页”变为“动态标题” 2. 动态修改导航条颜色 uni.setNavigationBarColor({ backgroundColor:"颜色" }) 3. 动态添加导航加载动画 // 添加加…
阅读更多...
GitLab配置免密登录和常用命令

GitLab配置免密登录和常用命令

SSH 免密登录 Windows免密登录 删除现有Key 访问目录：C:\Users\Administrator\ .ssh，删除公钥：id_rsa.pub ，私钥：id_rsa 2.生成.ssh 秘钥 运行命令生成.ssh 秘钥目录（ ssh-keygen -t rsa -C xxxxxx126.…
阅读更多...
Spring Boot 自动配置

Spring Boot 自动配置

目录 什么是自动配置？ Spring 加载 Bean ComponentScan Import 导入类 导入 ImportSelector 接口的实现类 SpringBoot 原理分析 EnableAutoConfiguration Import(AutoConfigurationImportSelector.class) AutoConfigurationPackage SpringBoot 自动配置流…
阅读更多...
16.好数python解法——2024年省赛蓝桥杯真题

16.好数python解法——2024年省赛蓝桥杯真题

问题描述 一个整数如果按从低位到高位的顺序,奇数位(个位、百位、万位…)上的数字是奇数,偶数位(十位、千位、十万位…)上的数字是偶数,我们就称之为“好数”。 给定一个正整数N,请计算从1到N一共有多少个好数。 输入格式 一个整数N。 输出格式 一个整数代表答案。 样例输入 1 …
阅读更多...
wxwidgets直接获取系统图标，效果类似QFileIconProvider

wxwidgets直接获取系统图标，效果类似QFileIconProvider

目前只做了windows版本&#xff0c;用法类似QFileIconProvider // 头文件 #ifndef WXFILEICONPROVIDER_H #define WXFILEICONPROVIDER_H#include <wx/wx.h> #include <wx/icon.h> #include <wx/image.h> #include <wx/bmpcbox.h> // Include for wxB…
阅读更多...
微服务学习-服务调用组件 OpenFeign 实战

微服务学习-服务调用组件 OpenFeign 实战

1. OpenFeign 接口方法编写规范 1.1. 在编写 OpenFeign 接口方法时&#xff0c;需要遵循以下规范 1.1.1.1. 接口中的方法必须使用 RequestMapping、GetMapping、PostMapping 等注解声明 HTTP 请求的类型。 1.1.1.2. 方法的参数可以使用 RequestParam、RequestHeader、PathVa…
阅读更多...
鸿蒙模块概念和应用启动相关类（HAP、HAR、HSP、AbilityStage、UIAbility、WindowStage、window）

鸿蒙模块概念和应用启动相关类（HAP、HAR、HSP、AbilityStage、UIAbility、WindowStage、window）

目录 鸿蒙模块概念 HAP entry feature har shared 使用场景 HAP、HAR、HSP介绍 HAP、HAR、HSP开发 应用的启动 AbilityStage UIAbility WindowStage Window 拉起应用到显示到前台流程 鸿蒙模块概念 HAP hap包是手机安装的最小单元&#xff0c;1个app包含一个或…
阅读更多...
想品客老师的第六天：函数

想品客老师的第六天：函数

函数基础的部分写在这里 函数声明 在js里万物皆对象&#xff0c;函数也可以用对象的方式定义 let func new Function("title", "console.log(title)");func(我是参数title); 也可以对函数赋值&#xff1a; let cms function (title) {console.log(tit…
阅读更多...
Python：元组构造式和字典推导式

Python：元组构造式和字典推导式

&#xff08;Python 元组构造式和字典推导式整理笔记&#xff09; 1. 元组构造式 1.1 创建元组 使用圆括号&#xff1a; tuple1 (1, 2.5, (three, four), [True, 5], False) print(tuple1) # 输出: (1, 2.5, (three, four), [True, 5], False) 省略圆括号&#xff1a; tup…
阅读更多...
Linux之Tcp粘包笔记

Linux之Tcp粘包笔记

目录 一.网络传输四层模型 二.数据传输中数据包传输的两个限制概念 三.数据传输的中粘包问题 四.数据组装的原因 Nagle算法原理: 五.关闭Nagle优化处理粘包问题吗&#xff1f; 六.粘包处理方法 a.设置消息边界&#xff1a; b.定义消息长度&#xff1a; 七.UDP是否会出…
阅读更多...
【C语言算法刷题】第2题 图论 dijkastra

【C语言算法刷题】第2题 图论 dijkastra

题目描述 一个局域网内有很多台电脑&#xff0c;分别标注为 0 ~ N-1 的数字。相连接的电脑距离不一样&#xff0c;所以感染时间不一样&#xff0c;感染时间用 t 表示。 其中网络内一台电脑被病毒感染&#xff0c;求其感染网络内所有的电脑最少需要多长时间。如果最后有电脑不…
阅读更多...
软件测试压力太大了怎么办？

软件测试压力太大了怎么办？

本文其实是知乎上针对一个问题的回答&#xff1a; 目前在做软件测试&#xff0c;主要负责的是手机端的项目测试&#xff0c;项目迭代很快&#xff0c;每次上线前验正式都会发现一些之前验测试包时候没有发现的问题&#xff0c;压力太大了&#xff0c;应该怎么调整 看过我之前其…
阅读更多...
枚举与模拟 练习

枚举与模拟 练习

练习题基于《C/C程序设计竞赛真题实战特训教程&#xff08;图解版&#xff09;》 目录 1.1 卡片 题目描述 代码实现 题解笔记 总评 注意点 重点解释 1.2 回文日期 题目描述 输入描述 输出描述 代码实现 题解笔记 总评 注意点 重点解释 1.1 卡片 题目描述 小蓝…
阅读更多...
Redis高阶5-布隆过滤器

Redis高阶5-布隆过滤器

Redis布隆过滤器 ​ 由一个初始值都为零的bit数组和多个哈希函数构成&#xff0c;用来快速判断集合中是否存在某个元素 目的减少内存占用方式不保存数据信息&#xff0c;只是在内存中做一个是否存在的标记flag 布隆过滤器&#xff08;英语&#xff1a;Bloom Filter&#xff0…
阅读更多...
vim如何设置自动缩进

vim如何设置自动缩进

:set autoindent 设置自动缩进 :set noautoindent 取消自动缩进 &#xff08;vim如何使设置自动缩进永久生效&#xff1a;vim如何使相关设置永久生效-CSDN博客&#xff09;
阅读更多...
检测到联想鼠标自动调出运行窗口，鼠标自己作为键盘操作

检测到联想鼠标自动调出运行窗口，鼠标自己作为键盘操作

联想鼠标会自动时不时的调用“运行”窗口 然后鼠标自己作为键盘输入 然后打开这个网页 &#xff08;不是点击了什么鼠标外加按键&#xff0c;这个鼠标除了左右和中间滚轮&#xff0c;没有其他按键了&#xff09;
阅读更多...
（Halcon）轮廓等分切割（项目分析）

（Halcon）轮廓等分切割（项目分析）

目标&#xff1a;获取绿色圆所在位置&#xff08;可用于点焊/点胶引导&#xff09; 实现思路 一&#xff0c;相机标定板标定&#xff08;如果实战用于点焊/点胶引导需要做图像畸变校正以减小误差&#xff09; 相机标定 如何做一个C#仿Halcon Calibration插件-CSDN博客 二&…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023