Python 梯度下降法(七):Summary

文章目录

  • Python 梯度下降法(七):Summary
    • 一、核心思想
      • 1.1 核心思想
      • 1.2 优化方法概述
      • 1.3 第三方库的使用
    • 二、 BGD
      • 2.1 介绍
      • 2.2 torch 库算法
      • 2.2 代码示例
      • 2.3 SGD
      • 2.4 SGD代码示例
      • 2.5 MBGD
      • 2.6 MBGD 代码示例
    • 三、 Adagrad
      • 3.1 介绍
      • 3.2 torch 库算法
      • 3.3 代码示例
    • 四、 Adadelta
      • 4.1 介绍
      • 4.2 torch 库算法
      • 4.3 代码示例
    • 五、RMSProp
      • 5.1 介绍
      • 5.2 torch 库算法
      • 5.3 代码示例
    • 六、Adam
      • 6.1 介绍
      • 6.2 torch 库算法
      • 6.3 代码示例
    • 七、Nadam
      • 7.1 介绍
      • 7.2 torch 库算法
      • 7.3 代码示例
    • 八、 总结
    • 九、相关链接

Python 梯度下降法(七):Summary

一、核心思想

1.1 核心思想

梯度下降法的核心思想是通过不断调整参数,使损失函数的值逐渐减小。每次迭代中,参数沿着损失函数梯度的反方向更新,直到达到最小值或收敛。

Python 梯度下降法系列文章中,我们从基础到进阶,逐步深入探讨了梯度下降法的原理、实现和优化方法。

Python 梯度下降法(一):Gradient Descent我介绍了常用的梯度下降法,其核心公式为:
θ t + 1 : = θ t − η ∇ θ J ( θ ) \theta_{t+1}:=\theta_{t}-\eta \nabla_{\theta}J(\theta) θt+1:=θtηθJ(θ)

这篇文章详细讲解了如何有效使用这一公式,并通过 Python 实现了一个简单的梯度下降算法。

负梯度下降是下降的最快方向,但是由于步长的存在,导致路径并不是最优的,如A->C是沿负梯度进行,但是其并不是最优解,B->C的过程并不是最优的选择。

1738397220_9jbrdd9isw.png1738397219863.png

在后续的文章中,我们逐步探讨了如何基于梯度下降法的核心公式进行优化,优化思路:

  1. 使学习率 η \eta η改变,即改变步长
  2. 使梯度 ∇ θ J ( θ ) \nabla_{\theta}J(\theta) θJ(θ)改变,即改变方向
  3. θ \theta θ更新之前进行处理,可使之变小,即权重衰减

1.2 优化方法概述

1738392060_1uxgrbrx3a.png1738392059611.png

以降低算法的复杂度、资源占用率,并提升其在实际应用中的性能。这些优化方法包括:

  • 批量梯度下降(BGD):使用全部数据计算梯度,稳定性高但计算开销大。
  • 随机梯度下降(SGD):每次迭代使用单个样本计算梯度,计算速度快但收敛不稳定。
  • 小批量梯度下降(Mini-batch GD):结合 BGD 和 SGD 的优点,使用小批量数据计算梯度。
  • 动量法(Momentum):引入动量项,加速收敛并减少震荡。
  • 自适应学习率方法:如 AdaGrad、RMSProp、Adadelta、Adam 和 NAdam,动态调整学习率,适合处理稀疏数据和非凸优化问题。

1.3 第三方库的使用

这些梯度下降的方法可以使用,torch.optim 里面的库来实现

torch进行机器学习流程概述:

  1. 生成示例数据:可以使用torch生成随机数据作为训练数据
  2. 定义线性模型:使用torch.nn.Linear定义一个简答的线性模型
  3. 定义损失函数:使用均方误差损失函数torch.nn.MESLoss
  4. 定义优化器:使用torch.optim里面的类,设置参数
  5. 训练模型:进行多次迭代,每次迭代计算损失并且更新模型参数
  6. 可视化:绘制损失函数图像,当然这是博客需要,你可以绘制原始数据和拟合直线。

二、 BGD

2.1 介绍

Python 梯度下降法(一):Gradient Descent-CSDN博客

GD:
1738394278_meztd066wg.png1738394277769.png

BGD:
1738394349_l1qzd3uxld.png1738394348252.png

SGD — PyTorch 2.6 documentation

2.2 torch 库算法

1738395714_znuzvzre3n.png1738395713524.png

通过官方给定的算法,我们可以发现 momentum ≠ 0 \text{momentum}\ne 0 momentum=0时,即为Momentum梯度下降法,故就不在后文赘述。

2.2 代码示例

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0)

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt# 生成随机数据
# 生成 100 个在 [0, 2) 之间的随机数作为输入特征
x = 2 * torch.rand(100, 1)
# 生成对应的目标值,添加一些随机噪声
y = 4 + 3 * x  +  torch.randn(100, 1)loss_ = []   # 存储历史损失值# 定义线性模型
model = nn.Linear(1, 1)# 定义损失函数
criterion = nn.MSELoss()# 定义优化器,使用批量梯度下降(BGD),学习率设置为 0.01
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0)# 训练模型
num_epochs = 1000
threshold = 1e-8
for epoch in range(num_epochs):# 前向传播outputs = model(x)loss = criterion(outputs, y)  # 使用MES(均方误差损失)的方式计算损失值loss_.append(loss.item())# 反向传播和优化optimizer.zero_grad()  # 在每次迭代中将梯度清零loss.backward()  # 反向传播,根据链式法则自动计算损失函数对每个参数的偏导数,并将这些梯度存储在参数的 .grad 属性optimizer.step()  # 根据优化算法更新参数# 检查是否收敛if epoch > 1 and abs(loss_[-1] - loss_[-2]) < threshold:print(f"Converged at iteration {epoch}")break# 可视化结果
print("斜率:", model.weight.item(), "偏移量:", model.bias.item())
# 绘制损失函数图像
plt.plot(range(len(loss_)), loss_)
plt.title('Linear Regression using BGD')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)  # 显示网格线
plt.show()

2.3 SGD

1738396021_a9u6ei8z5e.png1738396021090.png

2.4 SGD代码示例

其类似BGD,只是每次拟合的样本数据为1

这里使用DataLoader模块来进行数据的选择

from torch.utils.data import TensorDataset, DataLoader# 创建数据集对象
dataset = TensorDataset(x, y)# 设置 batch_size
batch_size = 1
# 创建数据加载器,指定 batch_size 和是否打乱数据
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

总代码:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
import matplotlib.pyplot as plt# 生成随机数据
# 生成 100 个在 [0, 2) 之间的随机数作为输入特征
x = 2 * torch.rand(100, 1)
# 生成对应的目标值,添加一些随机噪声
y = 4 + 3 * x  +  torch.randn(100, 1)loss_ = []   # 存储历史损失值# 定义线性模型
model = nn.Linear(1, 1)# 定义损失函数
criterion = nn.MSELoss()# 定义优化器,使用批量梯度下降(BGD),学习率设置为 0.01
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0)# 创建数据集对象
dataset = TensorDataset(x, y)# 设置 batch_size
batch_size = 1
# 创建数据加载器,指定 batch_size 和是否打乱数据
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)# 训练模型
num_epochs = 10
threshold = 1e-8
for epoch in range(num_epochs):# 前向传播for inputs, labels in dataloader:outputs = model(inputs)loss = criterion(outputs, labels)  # 使用MES(均方误差损失)的方式计算损失值loss_.append(loss.item())# 反向传播和优化optimizer.zero_grad()  # 在每次迭代中将梯度清零loss.backward()  # 反向传播,根据链式法则自动计算损失函数对每个参数的偏导数,并将这些梯度存储在参数的 .grad 属性optimizer.step()  # 根据优化算法更新参数# 检查是否收敛if epoch > 1 and abs(loss_[-1] - loss_[-2]) < threshold:print(f"Converged at iteration {epoch}")break# 可视化结果
print("斜率:", model.weight.item(), "偏移量:", model.bias.item())
# 绘制损失函数图像
plt.plot(range(len(loss_)), loss_)
plt.title('Linear Regression using BGD')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)  # 显示网格线
plt.show()

1738396865_fhoau0bveb.png1738396864461.png

2.5 MBGD

1738396232_kgrxqzhe1o.png1738396231644.png

2.6 MBGD 代码示例

设置 1 < batch_size < all 1<\text{batch\_size}<\text{all} 1<batch_size<all,即可实现

总代码:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import TensorDataset, DataLoader
import matplotlib.pyplot as plt# 生成随机数据
# 生成 100 个在 [0, 2) 之间的随机数作为输入特征
x = 2 * torch.rand(100, 1)
# 生成对应的目标值,添加一些随机噪声
y = 4 + 3 * x  +  torch.randn(100, 1)loss_ = []   # 存储历史损失值# 定义线性模型
model = nn.Linear(1, 1)# 定义损失函数
criterion = nn.MSELoss()# 定义优化器,使用批量梯度下降(BGD),学习率设置为 0.01
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0)# 创建数据集对象
dataset = TensorDataset(x, y)# 设置 batch_size
batch_size = 40
# 创建数据加载器,指定 batch_size 和是否打乱数据
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)# 训练模型
num_epochs = 100
threshold = 1e-8
for epoch in range(num_epochs):# 前向传播for inputs, labels in dataloader:outputs = model(inputs)loss = criterion(outputs, labels)  # 使用MES(均方误差损失)的方式计算损失值loss_.append(loss.item())# 反向传播和优化optimizer.zero_grad()  # 在每次迭代中将梯度清零loss.backward()  # 反向传播,根据链式法则自动计算损失函数对每个参数的偏导数,并将这些梯度存储在参数的 .grad 属性optimizer.step()  # 根据优化算法更新参数# 检查是否收敛if epoch > 1 and abs(loss_[-1] - loss_[-2]) < threshold:print(f"Converged at iteration {epoch}")break# 可视化结果
print("斜率:", model.weight.item(), "偏移量:", model.bias.item())
# 绘制损失函数图像
plt.plot(range(len(loss_)), loss_)
plt.title('Linear Regression using SGD')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)  # 显示网格线
plt.show()

1738397089_ae580k59jf.png1738397088799.png

即,总结:

1738397138_v1fxl4yrpf.png1738397137711.png

三、 Adagrad

3.1 介绍

Python 梯度下降法(三):Adagrad Optimize-CSDN博客

学习率除一个数值,这个数值是历史上所有梯度数据的平方再开方。 g t 2 g_{t}^{2} gt2越大,学习率越小,使得学习率自适应。

假设一个参数累计历史梯度极大,那么经过计算更新这个一步之后,它的学习率反而会变小。相反的,如果一个参数累计历史梯度极小,那么经过计算更新这一步之后,它的学习率反而会变大。

缺点:累加的太快,学习率小的太快,导致最后的学习很慢。

Adagrad — PyTorch 2.6 documentation

3.2 torch 库算法

1738399503_b3eqzc4xr4.png1738399502527.png

3.3 代码示例

optimizer = optim.Adagrad(model.parameters(), lr=lr)

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt# 生成随机数据
# 生成 100 个在 [0, 2) 之间的随机数作为输入特征
x = 2 * torch.rand(100, 1)
# 生成对应的目标值,添加一些随机噪声
y = 4 + 3 * x  +  torch.randn(100, 1)loss_ = []   # 存储历史损失值# 定义线性模型
model = nn.Linear(1, 1)# 定义损失函数
criterion = nn.MSELoss()# 定义优化器,使用Adagrad,学习率设置为 0.01
lr = 0.8
optimizer = optim.Adagrad(model.parameters(), lr=lr)# 训练模型
num_epochs = 1000
threshold = 1e-8
for epoch in range(num_epochs):# 前向传播outputs = model(x)loss = criterion(outputs, y)  # 使用MES(均方误差损失)的方式计算损失值loss_.append(loss.item())# 反向传播和优化optimizer.zero_grad()  # 在每次迭代中将梯度清零loss.backward()  # 反向传播,根据链式法则自动计算损失函数对每个参数的偏导数,并将这些梯度存储在参数的 .grad 属性optimizer.step()  # 根据优化算法更新参数# 检查是否收敛if epoch > 1 and abs(loss_[-1] - loss_[-2]) < threshold:print(f"Converged at iteration {epoch}")break# 可视化结果
print("斜率:", model.weight.item(), "偏移量:", model.bias.item())
# 绘制损失函数图像
plt.plot(range(len(loss_)), loss_)
plt.title('Linear Regression using Adagrad')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)  # 显示网格线
plt.show()

1738402571_k9dmmhkrpk.png1738402570785.png

四、 Adadelta

4.1 介绍

Python 梯度下降法(四):Adadelta Optimize-CSDN博客

Adadelta 是正对 Adagrad 学习速率衰减过快问题做出的改进。改进思路和RMSProp很像,但是其背后是基于一次梯度近似代替二次梯度的思想。Adagrad 会累加之前所有的梯度平方,而 Adadelta 只累加固定大小的项,并且也不直接存储这些项,仅仅是近似计算对应的平均值

Adadelta — PyTorch 2.6 documentation

4.2 torch 库算法

1738401969_glujj4vtqo.png1738401968761.png

4.3 代码示例

optimizer = optim.Adadelta(model.parameters(), lr=lr)

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt# 生成随机数据
# 生成 100 个在 [0, 2) 之间的随机数作为输入特征
x = 2 * torch.rand(100, 1)
# 生成对应的目标值,添加一些随机噪声
y = 4 + 3 * x  +  torch.randn(100, 1)loss_ = []   # 存储历史损失值# 定义线性模型
model = nn.Linear(1, 1)# 定义损失函数
criterion = nn.MSELoss()# 定义优化器,Adadelta
lr = 2
optimizer = optim.Adadelta(model.parameters(), lr=lr)  # 衰减率默认为0.9# 训练模型
num_epochs = 1000
threshold = 1e-8
for epoch in range(num_epochs):# 前向传播outputs = model(x)loss = criterion(outputs, y)  # 使用MES(均方误差损失)的方式计算损失值loss_.append(loss.item())# 反向传播和优化optimizer.zero_grad()  # 在每次迭代中将梯度清零loss.backward()  # 反向传播,根据链式法则自动计算损失函数对每个参数的偏导数,并将这些梯度存储在参数的 .grad 属性optimizer.step()  # 根据优化算法更新参数# 检查是否收敛if epoch > 1 and abs(loss_[-1] - loss_[-2]) < threshold:print(f"Converged at iteration {epoch}")break# 可视化结果
print("斜率:", model.weight.item(), "偏移量:", model.bias.item())
# 绘制损失函数图像
plt.plot(range(len(loss_)), loss_)
plt.title('Linear Regression using Adadelta')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)  # 显示网格线
plt.show()

1738403310_yufd184q5w.png1738403309375.png

五、RMSProp

5.1 介绍

Python 梯度下降法(二):RMSProp Optimize-CSDN博客

Adagrad 根据平方梯度的整个历史来收缩学习率,可能使得学习率在达到局部最小值之前就变得太小而难以继续训练;

RMSProp 使用指数衰减平均以丢弃遥远的历史,使其能够在找到某个“凸”结构后快速收敛;此外,RMSProp 还加入了一个超参数 ρ \rho ρ用于控制衰减率。

RMSProp 主要思想:使用指数加权移动平均的方法计算累积梯度,以丢弃遥远的梯度历史信息(让距离当前越远的梯度的缩减下学习率的权重越小)

衰减率表明的是只是最近的梯度平方有意义,而很久以前的梯度基本上会被遗忘。

RMSprop — PyTorch 2.6 documentation

5.2 torch 库算法

1738402036_zg911c2sx8.png1738402035850.png

5.3 代码示例

optimizer = optim.RMSprop(model.parameters(), lr=lr)

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt# 生成随机数据
# 生成 100 个在 [0, 2) 之间的随机数作为输入特征
x = 2 * torch.rand(100, 1)
# 生成对应的目标值,添加一些随机噪声
y = 4 + 3 * x  +  torch.randn(100, 1)loss_ = []   # 存储历史损失值# 定义线性模型
model = nn.Linear(1, 1)# 定义损失函数
criterion = nn.MSELoss()# 定义优化器,RMSprop
lr = 0.01
optimizer = optim.RMSprop(model.parameters(), lr=lr)  # 衰减率默认为0.99# 训练模型
num_epochs = 1000
threshold = 1e-8
for epoch in range(num_epochs):# 前向传播outputs = model(x)loss = criterion(outputs, y)  # 使用MES(均方误差损失)的方式计算损失值loss_.append(loss.item())# 反向传播和优化optimizer.zero_grad()  # 在每次迭代中将梯度清零loss.backward()  # 反向传播,根据链式法则自动计算损失函数对每个参数的偏导数,并将这些梯度存储在参数的 .grad 属性optimizer.step()  # 根据优化算法更新参数# 检查是否收敛if epoch > 1 and abs(loss_[-1] - loss_[-2]) < threshold:print(f"Converged at iteration {epoch}")break# 可视化结果
print("斜率:", model.weight.item(), "偏移量:", model.bias.item())
# 绘制损失函数图像
plt.plot(range(len(loss_)), loss_)
plt.title('Linear Regression using RMSprop')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)  # 显示网格线
plt.show()

1738403341_mxolya5yrg.png1738403340437.png

六、Adam

6.1 介绍

Python 梯度下降法(五):Adam Optimize-CSDN博客

Adam 算法的本质:其实就是 Momentum + RMSProp 的结合,让后再修正其偏差。Adam 对梯度的一阶和二阶都进行了估计与偏差修正,使用梯度的一阶矩估计和二阶矩估计来动态调整每个参数的学习率(参数更新的频率)。

缺点:Adam 优化器在权重衰减的处理上存在问题,Adam 算法弱化了 L2 范数正则化的作用,导致模型过拟合或者训练效果不佳。

Adam — PyTorch 2.6 documentation

6.2 torch 库算法

1738402095_jsyfniov4n.png1738402094684.png

6.3 代码示例

optimizer = optim.Adam(model.parameters(), lr=lr)

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt# 生成随机数据
# 生成 100 个在 [0, 2) 之间的随机数作为输入特征
x = 2 * torch.rand(100, 1)
# 生成对应的目标值,添加一些随机噪声
y = 4 + 3 * x  +  torch.randn(100, 1)loss_ = []   # 存储历史损失值# 定义线性模型
model = nn.Linear(1, 1)# 定义损失函数
criterion = nn.MSELoss()# 定义优化器,Adam
lr = 0.03
optimizer = optim.Adam(model.parameters(), lr=lr)  # 默认beta: 0.9, 0.99# 训练模型
num_epochs = 1000
threshold = 1e-8
for epoch in range(num_epochs):# 前向传播outputs = model(x)loss = criterion(outputs, y)  # 使用MES(均方误差损失)的方式计算损失值loss_.append(loss.item())# 反向传播和优化optimizer.zero_grad()  # 在每次迭代中将梯度清零loss.backward()  # 反向传播,根据链式法则自动计算损失函数对每个参数的偏导数,并将这些梯度存储在参数的 .grad 属性optimizer.step()  # 根据优化算法更新参数# 检查是否收敛if epoch > 1 and abs(loss_[-1] - loss_[-2]) < threshold:print(f"Converged at iteration {epoch}")break# 可视化结果
print("斜率:", model.weight.item(), "偏移量:", model.bias.item())
# 绘制损失函数图像
plt.plot(range(len(loss_)), loss_)
plt.title('Linear Regression using Adam')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)  # 显示网格线
plt.show()

1738403373_3gizmxim3f.png1738403372944.png

七、Nadam

7.1 介绍

Python 梯度下降法(六):Nadam Optimize-CSDN博客

Nadam 类似带有 Nesterov 动量项的Adam

其对学习率有了更强的约束,同时对梯度的会更新也有更直观的影响。
NAdam — PyTorch 2.6 documentation

7.2 torch 库算法

1738402164_wl1if5cllj.png1738402163199.png

7.3 代码示例

optimizer = optim.NAdam(model.parameters(), lr=lr)

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt# 生成随机数据
# 生成 100 个在 [0, 2) 之间的随机数作为输入特征
x = 2 * torch.rand(100, 1)
# 生成对应的目标值,添加一些随机噪声
y = 4 + 3 * x  +  torch.randn(100, 1)loss_ = []   # 存储历史损失值# 定义线性模型
model = nn.Linear(1, 1)# 定义损失函数
criterion = nn.MSELoss()# 定义优化器,NAdam
lr = 0.03
optimizer = optim.NAdam(model.parameters(), lr=lr)  # 默认beta: 0.9, 0.99# 训练模型
num_epochs = 1000
threshold = 1e-8
for epoch in range(num_epochs):# 前向传播outputs = model(x)loss = criterion(outputs, y)  # 使用MES(均方误差损失)的方式计算损失值loss_.append(loss.item())# 反向传播和优化optimizer.zero_grad()  # 在每次迭代中将梯度清零loss.backward()  # 反向传播,根据链式法则自动计算损失函数对每个参数的偏导数,并将这些梯度存储在参数的 .grad 属性optimizer.step()  # 根据优化算法更新参数# 检查是否收敛if epoch > 1 and abs(loss_[-1] - loss_[-2]) < threshold:print(f"Converged at iteration {epoch}")break# 可视化结果
print("斜率:", model.weight.item(), "偏移量:", model.bias.item())
# 绘制损失函数图像
plt.plot(range(len(loss_)), loss_)
plt.title('Linear Regression using NAdam')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)  # 显示网格线
plt.show()

1738403168_x61wxcolyo.png1738403167350.png

八、 总结

使用torch库,我们可以比较轻松的实现梯度下降法的大部分算法。

1738401881_vtkr8evsm9.png1738401880447.png

九、相关链接

Python 梯度下降法合集:

  • Python 梯度下降法(一):Gradient Descent-CSDN博客
  • Python 梯度下降法(二):RMSProp Optimize-CSDN博客
  • Python 梯度下降法(三):Adagrad Optimize-CSDN博客
  • Python 梯度下降法(四):Adadelta Optimize-CSDN博客
  • Python 梯度下降法(五):Adam Optimize-CSDN博客
  • Python 梯度下降法(六):Nadam Optimize-CSDN博客
  • Python 梯度下降法(七):Summary-CSDN博客

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

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

相关文章

SpringBoot Web开发(SpringMVC)

SpringBoot Web开发&#xff08;SpringMVC) MVC 核心组件和调用流程 Spring MVC与许多其他Web框架一样&#xff0c;是围绕前端控制器模式设计的&#xff0c;其中中央 Servlet DispatcherServlet 做整体请求处理调度&#xff01; . 除了DispatcherServletSpringMVC还会提供其他…

Web_php_unserialize

代码审计 <?php class Demo { private $file index.php;public function __construct($file) { $this->file $file; }、 //接收一个参数 $file 并赋值给私有属性 $filefunction __destruct() { echo highlight_file($this->file, true); } //在对象销毁时调用&…

Spring Web MVC基础第一篇

目录 1.什么是Spring Web MVC&#xff1f; 2.创建Spring Web MVC项目 3.注解使用 3.1RequestMapping&#xff08;路由映射&#xff09; 3.2一般参数传递 3.3RequestParam&#xff08;参数重命名&#xff09; 3.4RequestBody&#xff08;传递JSON数据&#xff09; 3.5Pa…

安装anaconda3 后 电脑如何单独运行python,python还需要独立安装吗?

安装anaconda3 后 电脑如何单独运行python&#xff0c;python还需要独立安装吗? 电脑第一此安装anaconda用于jupyter notebook使用。 但是在运行cmd的时候&#xff0c;输入python --version 显示未安装或跳转商店提示安装。 明明我可以运行python但是为什么cmd却说我没安装呢…

分布式事务组件Seata简介与使用,搭配Nacos统一管理服务端和客户端配置

文章目录 一. Seata简介二. 官方文档三. Seata分布式事务代码实现0. 环境简介1. 添加undo_log表2. 添加依赖3. 添加配置4. 开启Seata事务管理5. 启动演示 四. Seata Server配置Nacos1. 修改配置类型2. 创建Nacos配置 五. Seata Client配置Nacos1. 增加Seata关联Nacos的配置2. 在…

使用真实 Elasticsearch 进行高级集成测试

作者&#xff1a;来自 Elastic Piotr Przybyl 掌握高级 Elasticsearch 集成测试&#xff1a;更快、更智能、更优化。 在上一篇关于集成测试的文章中&#xff0c;我们介绍了如何通过改变数据初始化策略来缩短依赖于真实 Elasticsearch 的集成测试的执行时间。在本期中&#xff0…

OpenEuler学习笔记(十四):在OpenEuler上搭建.NET运行环境

一、在OpenEuler上搭建.NET运行环境 基于包管理器安装 添加Microsoft软件源&#xff1a;运行命令sudo rpm -Uvh https://packages.microsoft.com/config/centos/8/packages-microsoft-prod.rpm&#xff0c;将Microsoft软件源添加到系统中&#xff0c;以便后续能够从该源安装.…

基于Python的简单企业维修管理系统的设计与实现

以下是一个基于Python的简单企业维修管理系统的设计与实现&#xff0c;这里我们会使用Flask作为Web框架&#xff0c;SQLite作为数据库来存储相关信息。 1. 需求分析 企业维修管理系统主要功能包括&#xff1a; 维修工单的创建、查询、更新和删除。设备信息的管理。维修人员…

Van-Nav:新年,将自己学习的项目地址统一整理搭建自己的私人导航站,供自己后续查阅使用,做技术的同学应该都有一个自己网站的梦想

嗨&#xff0c;大家好&#xff0c;我是小华同学&#xff0c;关注我们获得“最新、最全、最优质”开源项目和高效工作学习方法 Van-Nav是一个基于Vue.js开发的导航组件库&#xff0c;它提供了多种预设的样式和灵活的配置选项&#xff0c;使得开发者可以轻松地定制出符合项目需求…

Android 音视频编解码 -- MediaCodec

引言 如果我们只是简单玩一下音频、视频播放&#xff0c;那么使用 MediaPlayer SurfaceView 播放就可以了&#xff0c;但如果想加个水印&#xff0c;加点其他特效什么的&#xff0c;那就不行了&#xff1b; 学习 Android 自带的硬件码类 – MediaCodec。 MediaCodec 介绍 在A…

UE 5.3 C++ 对垃圾回收的初步认识

一.UObject的创建 UObject 不支持构造参数。 所有的C UObject都会在引擎启动的时候初始化&#xff0c;然后引擎会调用其默认构造器。如果没有默认的构造器&#xff0c;那么 UObject 将不会编译。 有修改父类参数的需求&#xff0c;就使用指定带参构造 // Sets default value…

使用LLaMA-Factory对AI进行认知的微调

使用LLaMA-Factory对AI进行认知的微调 引言1. 安装LLaMA-Factory1.1. 克隆仓库1.2. 创建虚拟环境1.3. 安装LLaMA-Factory1.4. 验证 2. 准备数据2.1. 创建数据集2.2. 更新数据集信息 3. 启动LLaMA-Factory4. 进行微调4.1. 设置模型4.2. 预览数据集4.3. 设置学习率等参数4.4. 预览…

2025最新源支付V7全套开源版+Mac云端+五合一云端

2025最新源支付V7全套开源版Mac云端五合一云端 官方1999元&#xff0c; 最新非网上那种功能不全带BUG开源版&#xff0c;可以自己增加授权或二开 拥有卓越的性能和丰富的功能。它采用全新轻量化的界面UI&#xff0c;让您能更方便快捷地解决知识付费和运营赞助的难题 它基于…

Linux02——Linux的基本命令

目录 ls 常用选项及功能 综合示例 注意事项 cd和pwd命令 cd命令 pwd命令 相对路径、绝对路径和特殊路径符 特殊路径符号 mkdir命令 1. 功能与基本用法 2. 示例 3. 语法与参数 4. -p选项 touch-cat-more命令 1. touch命令 2. cat命令 3. more命令 cp-mv-rm命…

[EAI-023] FAST,机器人动作专用的Tokenizer,提高VLA模型的能力和训练效率

Paper Card 论文标题&#xff1a;FAST: Efficient Action Tokenization for Vision-Language-Action Models 论文作者&#xff1a;Karl Pertsch, Kyle Stachowicz, Brian Ichter, Danny Driess, Suraj Nair, Quan Vuong, Oier Mees, Chelsea Finn, Sergey Levine 论文链接&…

LeGO LOAM坐标系问题的自我思考

LeGO LOAM坐标系问题的自我思考 总体思考流程IMU坐标系LeGO LOAM代码分析代码 对于IMU输出测量值的integration积分过程欧拉角的旋转矩阵VeloToStartIMU()函数TransformToStartIMU(PointType *p) 总体思考流程 第一页 第二页 第三页 IMU坐标系 在LeGO LOAM中IMU坐标系的形式…

基于VMware的ubuntu与vscode建立ssh连接

1.首先安装openssh服务 sudo apt update sudo apt install openssh-server -y 2.启动并检查ssh服务状态 到这里可以按q退出 之后输入命令 &#xff1a; ip a 红色挡住的部分就是我们要的地址&#xff0c;这里就不展示了哈 3.配置vscode 打开vscode 搜索并安装&#xff1a;…

牛客网 除2!(详解)c++

题目链接&#xff1a;除2&#xff01; 1.题目解析 1&#xff1a;想让数组所有数之和尽可能小&#xff0c;肯定有个想法&#xff0c;就是我每次选数组中偶数的时候&#xff0c;我必定挑一个最大的&#xff0c;因为我挑一个最大的出来&#xff0c;把它变成一半&#xff0c;这个时…

Upscayl-官方开源免费图像AI增强软件

upscayl 链接&#xff1a;https://pan.xunlei.com/s/VOI0Szqe0fCwSSUSS8zRqKf7A1?pwdhefi#

C++并发编程指南08

以下是经过优化排版后的5.3节内容&#xff0c;详细解释了C中的同步操作和强制排序机制。每个部分都有详细的注释和结构化展示。 文章目录 5.3 同步操作和强制排序假设场景示例代码 5.3.1 同步发生 (Synchronizes-with)基本思想 5.3.2 先行发生 (Happens-before)单线程环境多线程…