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

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

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 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.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 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.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 计算测试集的均方误差和决定系数。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

DeepSeekMoE：迈向混合专家语言模型的终极专业化

DeepSeekMoE：迈向混合专家语言模型的终极专业化

一、结论写在前面 论文提出了MoE语言模型的DeepSeekMoE架构，目的是实现终极的专家专业化(expert specialization)。通过细粒度的专家分割和共享专家隔离，DeepSeekMoE相比主流的MoE架构实现了显著更高的专家专业化和性能。从较小的2B参数规模开始&#x…
阅读更多...
【ESP32】ESP-IDF开发 | WiFi开发 | UDP用户数据报协议 + UDP客户端和服务器例程

【ESP32】ESP-IDF开发 | WiFi开发 | UDP用户数据报协议 + UDP客户端和服务器例程

1. 简介 UDP协议（User Datagram Protocol），全称用户数据报协议，它是一种面向非连接的协议，面向非连接指的是在正式通信前不必与对方先建立连接， 不管对方状态就直接发送。至于对方是否可以接收到这些数据内…
阅读更多...
Oracle Primavera P6自动进行进度计算

Oracle Primavera P6自动进行进度计算

前言 在P6 Professional 有一个自动计划计算的选项，很多人不了解该设置如何使用，以及什么时候该启动这项配置。 详情 P6 Professional 默认为非自动进度计算。启用自动选项后，可以快速查看调度更改的效果。 ​ ​ 如图所示，当你…
阅读更多...
gesp(C++六级)（6）洛谷：P10109：[GESP202312 六级] 工作沟通

gesp(C++六级)（6）洛谷：P10109：[GESP202312 六级] 工作沟通

gesp(C六级)（6）洛谷：P10109：[GESP202312 六级] 工作沟通 题目描述 某公司有 N N N 名员工，编号从 0 0 0 至 N − 1 N-1 N−1。其中，除了 0 0 0 号员工是老板，其余每名员工都有一个直接领导…
阅读更多...
冯诺依曼结构和进程概念及其相关的内容的简单介绍

冯诺依曼结构和进程概念及其相关的内容的简单介绍

目录 ​编辑 冯诺依曼体系结构 操作系统(Operator System) 进程 引入 基本概念 描述进程-PCB task_ struct内容分类 进程 ID (PID)和查看进程 进程状态: 进程创建: 进程终止: 进程间通信 (IPC): 冯诺依曼体系结构 冯诺依曼体系结构是现代计算机的基础架构&#xf…
阅读更多...
松灵机器人 scout ros2 驱动 安装

松灵机器人 scout ros2 驱动 安装

必须使用 ubuntu22 必须使用 链接的humble版本 #打开can 口 sudo modprobe gs_usbsudo ip link set can0 up type can bitrate 500000sudo ip link set can0 up type can bitrate 500000sudo apt install can-utilscandump can0mkdir -p ~/ros2_ws/srccd ~/ros2_ws/src git cl…
阅读更多...
Excel 技巧23 - 在Excel中用切片器做出查询效果(★★★）

Excel 技巧23 - 在Excel中用切片器做出查询效果(★★★）

本文讲如何在Excel中用切片器做出查询效果。 目录 1，在Excel中用切片器做出查询效果 1-1，Excel 中的切片器是什么？ 1-2，用切片器做出查询效果 1），点击任一表格内单元格，按下CtrlA&#xff0…
阅读更多...
Python从0到100（八十六）：神经网络-ShuffleNet通道混合轻量级网络的深入介绍

Python从0到100（八十六）：神经网络-ShuffleNet通道混合轻量级网络的深入介绍

前言： 零基础学Python：Python从0到100最新最全教程。 想做这件事情很久了，这次我更新了自己所写过的所有博客，汇集成了Python从0到100，共一百节课，帮助大家一个月时间里从零基础到学习Python基础语法、Pyth…
阅读更多...
cmd命令行无法进入D：盘怎么办

cmd命令行无法进入D：盘怎么办

我找到了一个方法就是 增加一个/d cd /d d: 如下图,我不仅可以进入d盘符下，还可以访问盘符下的文件夹
阅读更多...
万物皆有联系：驼鸟和布什

万物皆有联系：驼鸟和布什

布什？一块布十块钱吗？不是，大家都知道，美国有两个总统，叫老布什和小布什，因为两个布什总统（父子俩），大家就这么叫来着，目的是为了好区分。 布什总统的布什&a…
阅读更多...
unity学习24：场景scene相关生成，加载，卸载，加载进度，异步加载场景等

unity学习24：场景scene相关生成，加载，卸载，加载进度，异步加载场景等

目录 1 场景数量 SceneManager.sceneCount 2 直接代码生成新场景 SceneManager.CreateScene 3 场景的加载 3.1 用代码加载场景，仍然build setting里先加入配置 3.2 卸载场景 SceneManager.UnloadSceneAsync(); 3.3 同步加载场景 SceneManager.LoadScene 3.3.…
阅读更多...
在线知识库创建与维护提升企业效率与知识共享能力

在线知识库创建与维护提升企业效率与知识共享能力

内容概要 在当今数字化快速发展的背景下，在线知识库逐渐成为企业管理信息的重要工具。其核心在于将知识进行系统化、结构化的整理和存储，便于员工获取和分享。这不仅提高了信息的访问效率，还促进了团队之间的协作。在线知识库的建立可以有效…
阅读更多...
【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】1.24 随机宇宙：生成现实世界数据的艺术

【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】1.24 随机宇宙：生成现实世界数据的艺术

1.24 随机宇宙：生成现实世界数据的艺术 目录 #mermaid-svg-vN1An9qZ6t4JUcGa {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-vN1An9qZ6t4JUcGa .error-icon{fill:#552222;}#mermaid-svg-vN1An9qZ6t4JUc…
阅读更多...
DeepSeek-R1 论文解读 —— 强化学习大语言模型新时代来临？

DeepSeek-R1 论文解读 —— 强化学习大语言模型新时代来临？

近年来，人工智能（AI）领域发展迅猛，大语言模型（LLMs）为通用人工智能（AGI）的发展开辟了道路。OpenAI 的 o1 模型表现非凡，它引入的创新性推理时缩放技术显著提升了推理能力…
阅读更多...
进阶数据结构——高精度运算

进阶数据结构——高精度运算

目录 前言一、高精度运算的定义与背景二、高精度运算的实现方式三、高精度运算的算法实现四、高精度运算的应用场景五、代码模版（c）六、经典例题1.[高精度加法](https://www.lanqiao.cn/problems/1516/learning/?page1&first_category_id1&name…
阅读更多...
MYSQL--一条SQL执行的流程,分析MYSQL的架构

MYSQL--一条SQL执行的流程,分析MYSQL的架构

文章目录 第一步建立连接第二部解析 SQL第三步执行 sql预处理优化阶段执行阶段索引下推 执行一条select 语句中间会发生什么？ 这个是对 mysql 架构的深入理解。 select * from product where id 1;对于mysql的架构分层: mysql 架构分成了 Server 层和存储引擎层&a…
阅读更多...
【4Day创客实践入门教程】Day2 探秘微控制器——单片机与MicroPython初步

【4Day创客实践入门教程】Day2 探秘微控制器——单片机与MicroPython初步

Day2 探秘微控制器——单片机与MicroPython初步 目录 Day2 探秘微控制器——单片机与MicroPython初步MicroPython语言基础开始基础语法注释与输出变量模块与函数 单片机基础后记 Day0 创想启程——课程与项目预览Day1 工具箱构建——开发环境的构建Day2 探秘微控制器——单片机…
阅读更多...
动态规划每日一练（四）

动态规划每日一练（四）

一、day1——最长数对链 题目链接&#xff1a; 646. 最长数对链 - 力扣&#xff08;LeetCode&#xff09;646. 最长数对链 - 给你一个由 n 个数对组成的数对数组 pairs &#xff0c;其中 pairs[i] [lefti, righti] 且 lefti < righti 。现在&#xff0c;我们定义一种 跟随…
阅读更多...
事务02之锁机制

事务02之锁机制

锁机制 文章目录 锁机制一&#xff1a;MySQL锁的由来与分类1&#xff1a;锁机制的分类 二&#xff1a;共享锁与排他锁1&#xff1a;共享锁(S锁)2&#xff1a;排他锁(X锁)3&#xff1a;锁的释放 二&#xff1a;表级别锁1&#xff1a;元数据锁(了解)2&#xff1a;意向锁3&#xf…
阅读更多...
网络工程师 （8）存储管理

网络工程师 （8）存储管理

一、页式存储基本原理 &#xff08;一&#xff09;内存划分 页式存储首先将内存物理空间划分成大小相等的存储块&#xff0c;这些块通常被称为“页帧”或“物理页”。每个页帧的大小是固定的&#xff0c;例如常见的页帧大小有4KB、8KB等&#xff0c;这个大小由操作系统决定。同…
阅读更多...
最新文章

Copyright @ 2022~2023