【机器学习】自定义数据集 使用pytorch框架实现逻辑回归并保存模型，然后保存模型后再加载模型进行预测

一、使用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 的指标计算均方误差和决定系数评估模型性能，最后输出模型的系数和截距。

二、保存pytorch框架逻辑回归模型

在 PyTorch 中，有两种常见的保存模型的方式：保存模型的权重和其他参数，以及保存整个模型。下面将结合一个简单的逻辑回归模型示例，详细介绍这两种保存方式及对应的加载方法。

方式 1：保存模型的权重和其他参数

这种方式只保存模型的状态字典（state_dict），它包含了模型的所有可学习参数（如权重和偏置）。这种方法的优点是文件体积小，便于共享和迁移，缺点是加载时需要先定义模型结构。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np# 自定义数据集
X = np.random.randn(100, 2).astype(np.float32)
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义逻辑回归模型
class LogisticRegression(nn.Module):def __init__(self, input_size):super(LogisticRegression, self).__init__()self.linear = nn.Linear(input_size, 1)self.sigmoid = nn.Sigmoid()def forward(self, x):out = self.linear(x)out = self.sigmoid(out)return out# 初始化模型
input_size = 2
model = LogisticRegression(input_size)# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = 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}')# 保存模型的权重和其他参数
torch.save(model.state_dict(), 'model_weights.pth')# 加载模型的权重和其他参数
loaded_model = LogisticRegression(input_size)
loaded_model.load_state_dict(torch.load('model_weights.pth'))
loaded_model.eval()# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)with torch.no_grad():predictions = loaded_model(new_X_tensor)predicted_labels = (predictions >= 0.5).float()print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

代码解释

  1. 模型训练：首先定义并训练一个逻辑回归模型。
  2. 保存模型：使用 torch.save(model.state_dict(), 'model_weights.pth') 保存模型的状态字典到文件 model_weights.pth。
  3. 加载模型：先创建一个新的模型实例 loaded_model，然后使用 loaded_model.load_state_dict(torch.load('model_weights.pth')) 加载保存的状态字典。
  4. 预测：将模型设置为评估模式，生成新数据进行预测。

方式 2：保存整个模型

这种方式会保存整个模型对象，包括模型的结构和状态字典。优点是加载时不需要重新定义模型结构，缺点是文件体积较大，并且可能会受到 Python 版本和库版本的限制。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np# 自定义数据集
X = np.random.randn(100, 2).astype(np.float32)
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义逻辑回归模型
class LogisticRegression(nn.Module):def __init__(self, input_size):super(LogisticRegression, self).__init__()self.linear = nn.Linear(input_size, 1)self.sigmoid = nn.Sigmoid()def forward(self, x):out = self.linear(x)out = self.sigmoid(out)return out# 初始化模型
input_size = 2
model = LogisticRegression(input_size)# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = 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}')# 保存整个模型
torch.save(model, 'whole_model.pth')# 加载整个模型
loaded_model = torch.load('whole_model.pth')
loaded_model.eval()# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)with torch.no_grad():predictions = loaded_model(new_X_tensor)predicted_labels = (predictions >= 0.5).float()print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

代码解释

  1. 模型训练：同样先定义并训练逻辑回归模型。
  2. 保存模型：使用 torch.save(model, 'whole_model.pth') 保存整个模型对象到文件 whole_model.pth。
  3. 加载模型：使用 torch.load('whole_model.pth') 直接加载整个模型。
  4. 预测：将模型设置为评估模式，生成新数据进行预测。

通过以上两种方式，可以根据实际需求选择合适的模型保存和加载方法。

三、加载pytorch框架逻辑回归模型

以下将分别详细介绍在 PyTorch 中针对只保存模型参数和保存结构与参数这两种不同保存方式对应的模型加载方法，同时给出完整的代码示例。

方式 1：只保存模型参数的加载方式

当用户只保存了模型的参数（即 state_dict）时，在加载模型时需要先定义好与原模型相同结构的模型，再将保存的参数加载到该模型中。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np# 自定义数据集
X = np.random.randn(100, 2).astype(np.float32)
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义逻辑回归模型
class LogisticRegression(nn.Module):def __init__(self, input_size):super(LogisticRegression, self).__init__()self.linear = nn.Linear(input_size, 1)self.sigmoid = nn.Sigmoid()def forward(self, x):out = self.linear(x)out = self.sigmoid(out)return out# 初始化模型
input_size = 2
model = LogisticRegression(input_size)# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = 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}')# 保存模型的参数
torch.save(model.state_dict(), 'model_params.pth')# 加载模型的参数
# 重新定义模型结构
loaded_model = LogisticRegression(input_size)
# 加载保存的参数
loaded_model.load_state_dict(torch.load('model_params.pth'))
# 将模型设置为评估模式
loaded_model.eval()# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)# 进行预测
with torch.no_grad():predictions = loaded_model(new_X_tensor)predicted_labels = (predictions >= 0.5).float()print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

代码解释

  1. 模型定义与训练：定义了一个简单的逻辑回归模型，并使用自定义数据集进行训练。
  2. 保存参数：使用 torch.save(model.state_dict(), 'model_params.pth') 保存模型的参数。
  3. 加载参数：
    • 重新定义与原模型相同结构的 loaded_model。
    • 使用 loaded_model.load_state_dict(torch.load('model_params.pth')) 加载保存的参数。
  4. 预测：将模型设置为评估模式，生成新数据进行预测。

方式 2：保存结构和参数的模型加载方式

当保存了模型的结构和参数时，加载模型就相对简单，直接使用 torch.load 函数即可加载整个模型。

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np# 自定义数据集
X = np.random.randn(100, 2).astype(np.float32)
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义逻辑回归模型
class LogisticRegression(nn.Module):def __init__(self, input_size):super(LogisticRegression, self).__init__()self.linear = nn.Linear(input_size, 1)self.sigmoid = nn.Sigmoid()def forward(self, x):out = self.linear(x)out = self.sigmoid(out)return out# 初始化模型
input_size = 2
model = LogisticRegression(input_size)# 定义损失函数和优化器
criterion = nn.BCELoss()
optimizer = 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}')# 保存整个模型（结构和参数）
torch.save(model, 'whole_model.pth')# 加载整个模型
loaded_model = torch.load('whole_model.pth')
# 将模型设置为评估模式
loaded_model.eval()# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)# 进行预测
with torch.no_grad():predictions = loaded_model(new_X_tensor)predicted_labels = (predictions >= 0.5).float()print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

代码解释

  1. 模型定义与训练：同样定义并训练逻辑回归模型。
  2. 保存整个模型：使用 torch.save(model, 'whole_model.pth') 保存模型的结构和参数。
  3. 加载整个模型：使用 torch.load('whole_model.pth') 直接加载整个模型。
  4. 预测：将模型设置为评估模式，生成新数据进行预测。

通过以上两种方式，可以根据不同的保存情况正确加载 PyTorch 模型。

四、完整流程（使用直接继承 nn.Module逻辑回归，且仅保存模型的权重和其他参数）

1. 实现思路

① 自定义数据集：

生成符合特定分布的特征矩阵和对应的标签向量。

② 构建逻辑回归模型：

定义一个简单的逻辑回归模型，这里使用直接继承 nn.Module逻辑回归。

③ 训练模型：

使用生成的数据集对模型进行训练。

④ 保存模型：

将训练好的模型保存到本地文件，这里仅保存模型的权重和其他参数。

⑤ 加载模型：

从本地文件中加载保存的模型。

⑥ 模型预测：

使用加载的模型对新数据进行预测。

2. 代码示例

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np# 自定义数据集
# 生成 100 个样本，每个样本有 2 个特征
X = np.random.randn(100, 2).astype(np.float32)
# 根据特征生成标签，使用简单的线性组合和阈值判断
y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)# 将 numpy 数组转换为 PyTorch 张量
X_tensor = torch.from_numpy(X)
y_tensor = torch.from_numpy(y)# 定义逻辑回归模型
class LogisticRegression(nn.Module):def __init__(self, input_size):super(LogisticRegression, self).__init__()self.linear = nn.Linear(input_size, 1)self.sigmoid = nn.Sigmoid()def forward(self, x):out = self.linear(x)out = self.sigmoid(out)return out# 初始化模型
input_size = 2
model = LogisticRegression(input_size)# 定义损失函数和优化器
criterion = nn.BCELoss()  # 二元交叉熵损失函数
optimizer = 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}')# 保存模型
torch.save(model.state_dict(), 'logistic_regression_model.pth')# 加载模型
loaded_model = LogisticRegression(input_size)
loaded_model.load_state_dict(torch.load('logistic_regression_model.pth'))
loaded_model.eval()# 生成新数据进行预测
new_X = np.random.randn(10, 2).astype(np.float32)
new_X_tensor = torch.from_numpy(new_X)# 使用加载的模型进行预测
with torch.no_grad():predictions = loaded_model(new_X_tensor)predicted_labels = (predictions >= 0.5).float()print("预测概率:")
print(predictions.numpy())
print("预测标签:")
print(predicted_labels.numpy())

3. 代码解释

① 数据集生成：

  • X = np.random.randn(100, 2).astype(np.float32)：生成 100 个样本，每个样本有 2 个特征。
  • y = (2 * X[:, 0] + 3 * X[:, 1] > 0).astype(np.float32).reshape(-1, 1)：根据特征的线性组合生成标签，大于 0 标记为 1，否则标记为 0。
  • X_tensor = torch.from_numpy(X) 和 y_tensor = torch.from_numpy(y)：将 numpy 数组转换为 PyTorch 张量。

② 模型定义：

  • LogisticRegression 类继承自 nn.Module，包含一个线性层 nn.Linear 和一个 Sigmoid 激活函数 nn.Sigmoid。
  • forward 方法定义了前向传播的逻辑。

③ 损失函数和优化器：

  • criterion = nn.BCELoss()：使用二元交叉熵损失函数，适用于二分类问题。
  • optimizer = optim.SGD(model.parameters(), lr=0.01)：使用随机梯度下降优化器，学习率为 0.01。

④ 模型训练：

  • 通过多次迭代进行前向传播、损失计算、反向传播和参数更新。
  • 每 100 个 epoch 打印一次损失值。

⑤模型保存：

  • torch.save(model.state_dict(), 'logistic_regression_model.pth')：保存模型的参数到本地文件 logistic_regression_model.pth。

⑥ 模型加载和预测：

  1. loaded_model = LogisticRegression(input_size)：创建一个新的模型实例。
  2. loaded_model.load_state_dict(torch.load('logistic_regression_model.pth'))：加载保存的模型参数。
  3. loaded_model.eval()：将模型设置为评估模式。
  4. 生成新数据 new_X 并转换为张量 new_X_tensor。
  5. 使用 loaded_model 进行预测，通过 (predictions >= 0.5).float() 将预测概率转换为标签。

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

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

相关文章

AI 浪潮席卷中国年，开启科技新春新纪元

AI 浪潮席卷中国年，开启科技新春新纪元

在这博主提前祝大家蛇年快乐呀！！！ 随着人工智能（AI）技术的飞速发展，其影响力已经渗透到社会生活的方方面面。在中国传统节日 —— 春节期间，AI 技术也展现出了巨大的潜力，为中国年带…
阅读更多...
vim的特殊模式-可视化模式

vim的特殊模式-可视化模式

可视化模式：按 v进入可视化模式 选中 y复制 d剪切/删除 可视化块模式: ctrlv 选中 y复制 d剪切/删除 示例： （vim可视化模式的进阶使用：vim可视化模式的进阶操作-CSDN博客）
阅读更多...
sunrays-framework配置重构

sunrays-framework配置重构

文章目录 1.common-log4j2-starter1.目录结构2.Log4j2Properties.java 新增两个属性3.Log4j2AutoConfiguration.java 条件注入LogAspect4.ApplicationEnvironmentPreparedListener.java 从Log4j2Properties.java中定义的配置读取信息 2.common-minio-starter1.MinioProperties.…
阅读更多...
相互作用感知的蛋白-小分子对接模型 - Interformer 评测

相互作用感知的蛋白-小分子对接模型 - Interformer 评测

Interformer 是一个应用于分子对接和亲和力预测的深度学习模型，基于 Graph-Transdormer 架构的模型，利用相互作用（氢键、疏水）感知的混合密度网络（interaction-aware mixture den sity network， MDN&#x…
阅读更多...
Ceisum无人机巡检直播视频投射

Ceisum无人机巡检直播视频投射

接上次的视频投影，Leader告诉我这个视频投影要用在两个地方，一个是我原先写的轨迹回放那里，另一个在无人机起飞后的地图回显，要实时播放无人机拍摄的视频，还要能转镜头，让我把这个也接一下。 我的天&#x…
阅读更多...
【漫话机器学习系列】065.梯度（Gradient）

【漫话机器学习系列】065.梯度（Gradient）

梯度（Gradient） 在数学和机器学习中，梯度是一个向量，用来表示函数在某一点的变化方向和变化率。它是多变量函数的一阶偏导数的组合。 梯度的定义 设有一个标量函数 ，它对 ​ 是可微的，则该函数在某一点的…
阅读更多...
基于SpringBoot多数据源解决方案

基于SpringBoot多数据源解决方案

最近在学习SpringBoot的时候，需要同时用两个不同的数据库连接服务，在网上学习了之后，下文以连接一个MySQL数据库和一个SqlServer数据库为例。 配置数据源连接信息 在配置文件中，配置对应的数据库连接信息，相比于单数…
阅读更多...
二叉树的最大深度（C语言详解版）

二叉树的最大深度（C语言详解版）

一、摘要 嗨喽呀大家，leetcode每日一题又和大家见面啦，今天要讲的是104.二叉树的最大深度，思路互相学习，有什么不足的地方欢迎指正！好啦让我们开始吧！！！ 二、题目简介 给定一个二…
阅读更多...
穿心莲内酯（andrographolide）生物合成CYP72-文献精读106

穿心莲内酯（andrographolide）生物合成CYP72-文献精读106

Two CYP72 enzymes function as Ent-labdane hydroxylases in the biosynthesis of andrographolide in Andrographis paniculata 两种CYP72酶在穿心莲（Andrographis paniculata）中作为Ent-labdane羟化酶，在穿心莲内酯（andrograp…
阅读更多...
[SaaS] 内容创意生产平台

[SaaS] 内容创意生产平台

1.即梦 2.讯飞绘镜 typemovie 3.Krea.ai 4.Pika 5.runway 6.pixVerse 7.
阅读更多...
DiffuEraser: 一种基于扩散模型的视频修复技术

DiffuEraser: 一种基于扩散模型的视频修复技术

视频修复算法结合了基于流的像素传播与基于Transformer的生成方法，利用光流信息和相邻帧的信息来恢复纹理和对象，同时通过视觉Transformer完成被遮挡区域的修复。然而，这些方法在处理大范围遮挡时常常会遇到模糊和时序不一致的问题&#xff0…
阅读更多...
[c语言日寄]assert函数功能详解

[c语言日寄]assert函数功能详解

【作者主页】siy2333 【专栏介绍】⌈c语言日寄⌋：这是一个专注于C语言刷题的专栏，精选题目，搭配详细题解、拓展算法。从基础语法到复杂算法，题目涉及的知识点全面覆盖，助力你系统提升。无论你是初学者，还是…
阅读更多...
【数据结构】_链表经典算法OJ：分割链表（力扣—中等）

【数据结构】_链表经典算法OJ：分割链表（力扣—中等）

目录 1. 题目描述及链接 2. 解题思路 2.1 思路1 2.2 思路2 2.3 思路3（本题采取该解法） 3. 题解程序 1. 题目描述及链接 题目链接：面试题 02.04. 分割链表 - 力扣（LeetCode） 题目描述： 给你一个链表…
阅读更多...
基于vue和elementui的简易课表

基于vue和elementui的简易课表

本文参考基于vue和elementui的课程表_vue实现类似课程表的周会议列表-CSDN博客，原程序在vue3.5.13版本下不能运行，修改两处： 1）slot-cope改为v-slot 2）return background-color:rgb(24 144 255 / 80%);color: #fff; …
阅读更多...
【Unity3D】实现Decal贴花效果，模拟战旗游戏地形效果

【Unity3D】实现Decal贴花效果，模拟战旗游戏地形效果

目录 一、基础版 二、Post Process 辉光Bloom效果 矩形渐隐 涉及知识点：Decal贴花、屏幕后处理Bloom、屏幕空间构建世界空间、ChracterController物体移动、Terrain地形创建 一、基础版 Unity 2019.4.0f1 普通渲染管线（非URP、非HDRP） UR…
阅读更多...
数据结构与算法学习笔记----求组合数

数据结构与算法学习笔记----求组合数

数据结构与算法学习笔记----求组合数 author: 明月清了个风 first publish time: 2025.1.27 ps⭐️一组求组合数的模版题，因为数据范围的不同要用不同的方法进行求解，涉及了很多之前的东西快速幂，逆元，质数，高精度等…
阅读更多...
基于物联网设计的疫苗冷链物流监测系统

基于物联网设计的疫苗冷链物流监测系统

一、前言 1.1 项目开发背景 随着全球经济的发展和物流行业的不断创新，疫苗和生物制品的运输要求变得越来越高。尤其是疫苗的冷链物流，温度、湿度等环境因素的控制直接关系到疫苗的质量和效力，因此高效、可靠的冷链监控系统显得尤为重要。冷…
阅读更多...
学习数据结构（1）时间复杂度

学习数据结构（1）时间复杂度

1.数据结构和算法 （1）数据结构是计算机存储、组织数据的方式，指相互之间存在⼀种或多种特定关系的数据元素的集合 （2）算法就是定义良好的计算过程，取一个或一组的值为输入，并产生出一个或一组…
阅读更多...
基于RIP的MGRE实验

基于RIP的MGRE实验

实验拓扑 实验要求 按照图示配置IP地址配置静态路由协议，搞通公网配置MGRE VPNNHRP的配置配置RIP路由协议来传递两端私网路由测试全网通 实验配置 1、配置IP地址 [R1]int g0/0/0 [R1-GigabitEthernet0/0/0]ip add 15.0.0.1 24 [R1]int LoopBack 0 [R1-LoopBack0]i…
阅读更多...
Oracle迁移DM数据库

Oracle迁移DM数据库

Oracle迁移DM数据库 本文记录使用达梦官方数据迁移工具DTS，将Oracle数据库的数据迁移至达梦数据库。 1 数据准备 2 DTS工具操作步骤 2.1 创建工程 打开DTS迁移工具，点击新建工程，填写好工程信息，如图： 2.2 新建迁…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023