深度学习模型训练套路与验证套路以及如何使用GPU进行模型训练

完整的模型训练套路：代码模板

数据集以经典的 CIFAR10 为例。

这个例子是很简单的，可能不太实用，但重点是通过这个例子掌握一种模型训练的写法套路，因此很有必要学习。

import torch.optim
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter# 1、准备训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset2", train=True,transform=torchvision.transforms.ToTensor(), download=True)# 2、准备测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset2", train=False,transform=torchvision.transforms.ToTensor(), download=True)# 3、查看数据集的大小
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))# 4、利用 DataLoader 加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)# 5、搭建神经网络：完成一个十分类的任务
class NetWork(nn.Module):def __init__(self):super(NetWork, self).__init__()self.model = nn.Sequential(nn.Conv2d(3, 32, 5, 1, 2),nn.MaxPool2d(2),nn.Conv2d(32, 32, 5, 1, 2),nn.MaxPool2d(2),nn.Conv2d(32, 64, 5, 1, 2),nn.MaxPool2d(2),nn.Flatten(),nn.Linear(64 * 4 * 4, 64),nn.Linear(64, 10),)def forward(self, x):x = self.model(x)return x# 6、创建网络模型
network = NetWork()# 7、定义损失函数
loss_fn = nn.CrossEntropyLoss()# 8、定义优化器
# 为神经网络network定义一个SGD（随机梯度下降）优化器，并使用指定的学习率learning_rate来更新其参数。
learning_rate = 0.01
# torch.optim.SGD：这是PyTorch中SGD优化器的定义。SGD是一种常用的优化算法，用于在训练过程中最小化损失函数。
# network.parameters()：这是一个生成器，它返回神经网络network中所有可训练的参数（如权重和偏置）。
#                       在PyTorch中，模型通常是一个nn.Module的子类，并且模型中的参数可以通过.parameters()方法获取。
# lr=learning_rate：这是SGD优化器的一个参数，表示学习率（learning rate）。
#                   学习率是一个超参数，用于控制参数更新的步长。较大的学习率可能导致训练不稳定，而较小的学习率可能导致训练速度较慢。
#                   你需要根据具体的任务和模型结构来选择合适的学习率。
optimizer = torch.optim.SGD(network.parameters(), lr=learning_rate)# 9、设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10# 10、添加 tensorboard 显示
writer = SummaryWriter("./logs_train")# 11、开始训练
for i in range(epoch):print("----------第 {} 轮训练开始----------".format(i+1))# 训练步骤开始# network.train() 这一步对于当前网络来说并不是必要的，有无皆可，但如果网络中涉及了 Dropout 层 或者 BatchNorm 层等才必须加上for data in train_dataloader:imgs, targets = dataoutputs = network(imgs)# 计算模型预测与真实目标之间的损失# 它接受模型的输出（outputs）和真实的目标值（targets）作为输入，并返回一个表示两者差异的数值（通常是一个标量张量）。loss = loss_fn(outputs, targets)# 优化器开始调优，优化模型参数# 在每次训练迭代（iteration）开始时，都会调用这个zero_grad()方法来清除之前累积的梯度。# 这是因为在PyTorch中，梯度是累积的，如果你不清除之前的梯度，# 那么在下一次迭代时，梯度就会是之前迭代梯度的累加，这通常不是我们想要的。optimizer.zero_grad()# backward()这个方法会计算损失函数关于模型参数的梯度，并将结果存储在参数的.grad属性中。这是反向传播（backpropagation）的核心步骤。loss.backward()# step()这个方法会根据之前计算得到的梯度来更新模型的参数。# 具体来说，它会根据优化器（如SGD）中定义的算法来更新模型的参数，使其朝着损失函数减小的方向前进。optimizer.step()total_train_step = total_train_step + 1# 控制一下打印的频率，让其每逢100次时再打印日志if total_train_step % 100 == 0:# 在 PyTorch 中，当你计算得到一个损失（loss）或任何单元素张量（scalar tensor）时，这个值通常是一个 PyTorch 张量（tensor）。# 然而，在很多情况下，你可能想要将这个张量值转换为一个 Python 的基本数据类型（如 float 或 int），以便进行更简单的数学运算或打印。# loss.item() 就是用来做这个转换的。它会返回张量中的单个元素值作为一个 Python 数字。# 注意，这个方法只能在单元素张量（scalar tensor）上调用，即那些形状为 torch.Size([]) 的张量。print("训练次数: {}, Loss: {}".format(total_train_step, loss.item()))# 在 TensorBoard 中添加一个名为 'train_loss' 的标量（scalar）数据点，# 其值为当前的损失值（loss.item()），并将其与训练步骤 total_train_step 相关联”# "train_loss"：这是你要在 TensorBoard 中显示的数据的标签。#               当你打开 TensorBoard 并查看数据时，你会在图表或表格中看到这个标签。# loss.item()：这是从 PyTorch 的张量（tensor）中提取出的单个元素值（在这个情况下是损失值）。# total_train_step：这是训练步骤的编号或索引。在训练过程中，随着每个批次的迭代，这个值通常会递增。#                   它用于在 TensorBoard 的图表中跟踪损失值随时间（或训练步骤）的变化。writer.add_scalar("train_loss", loss.item(), total_train_step)# 测试步骤开始（每完成一个轮回，即一次前向和反向传播完整个训练数据集，就测试一下效果，看测试集上的损失值大小）# network.eval() 这一步对于当前网络来说并不是必要的，有无皆可，但如果网络中涉及了 Dropout 层 或者 BatchNorm 层等才必须加上total_test_loss = 0# 在 PyTorch 中，torch.no_grad() 并不是一个函数调用，而是一个上下文管理器（context manager），# 通常与 with 关键字一起使用，以确保在 with 语句块中的操作不会计算梯度，从而节省内存和计算资源。with torch.no_grad():for data in test_dataloader:imgs, targets = dataoutputs = network(imgs)loss = loss_fn(outputs, targets)total_test_loss = total_test_loss + loss.item()print("整体测试集上的Loss: {}".format(total_test_loss))writer.add_scalar("test_loss", total_test_loss, total_test_step)total_test_step = total_test_step + 1# 12、保存下每一轮训练的模型torch.save(network.load_state_dict(), "network_{}.pth".format(i+1))print("模型已保存")# 13、关闭 tensorboard
writer.close()

上述代码就是目标检测或者分割类 CV 任务的基本模板了，但其实我们看很多的开源项目或者是别人的代码，习惯上都喜欢将第五步搭建神经网络部分给单独封装到一个 python 文件当中从而进行调用，因此我们也可以仿照着这样做。

将搭建神经网络的部分单独封装成一个 model.py 文件（注意要和我们自己的训练文件位于同一目录下嗷）：

# 5、搭建神经网络：完成一个十分类的任务
import torch
from torch import nn# 5、搭建神经网络：完成一个十分类的任务
class NetWork(nn.Module):def __init__(self):super(NetWork, self).__init__()self.model = nn.Sequential(nn.Conv2d(3, 32, 5, 1, 2),nn.MaxPool2d(2),nn.Conv2d(32, 32, 5, 1, 2),nn.MaxPool2d(2),nn.Conv2d(32, 64, 5, 1, 2),nn.MaxPool2d(2),nn.Flatten(),nn.Linear(64 * 4 * 4, 64),nn.Linear(64, 10),)def forward(self, x):x = self.model(x)return x# 在这里测试一下网络的正确性
if __name__ == '__main__':network = NetWork()# 看一下输出的尺寸是不是我们想要的，如果是那么就应该是正确的input = torch.ones((64, 3, 32, 32))output = network(input)print(output.shape)

然后在我们的训练文件 train.py 中进行引入：

import torch.optim
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from model import *# 1、准备训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset2", train=True,transform=torchvision.transforms.ToTensor(), download=True)# 2、准备测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset2", train=False,transform=torchvision.transforms.ToTensor(), download=True)# 3、查看数据集的大小
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))# 4、利用 DataLoader 加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)# 5、引入我们在 model.py 中搭建好的神经网络：完成一个十分类的任务# 6、创建网络模型
network = NetWork()# 7、定义损失函数
loss_fn = nn.CrossEntropyLoss()# 8、定义优化器
# 为神经网络network定义一个SGD（随机梯度下降）优化器，并使用指定的学习率learning_rate来更新其参数。
learning_rate = 0.01
# torch.optim.SGD：这是PyTorch中SGD优化器的定义。SGD是一种常用的优化算法，用于在训练过程中最小化损失函数。
# network.parameters()：这是一个生成器，它返回神经网络network中所有可训练的参数（如权重和偏置）。
#                       在PyTorch中，模型通常是一个nn.Module的子类，并且模型中的参数可以通过.parameters()方法获取。
# lr=learning_rate：这是SGD优化器的一个参数，表示学习率（learning rate）。
#                   学习率是一个超参数，用于控制参数更新的步长。较大的学习率可能导致训练不稳定，而较小的学习率可能导致训练速度较慢。
#                   你需要根据具体的任务和模型结构来选择合适的学习率。
optimizer = torch.optim.SGD(network.parameters(), lr=learning_rate)# 9、设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10# 10、添加 tensorboard 显示
writer = SummaryWriter("./logs_train")# 11、开始训练
for i in range(epoch):print("----------第 {} 轮训练开始----------".format(i+1))# 训练步骤开始# network.train() 这一步对于当前网络来说并不是必要的，有无皆可，但如果网络中涉及了 Dropout 层 或者 BatchNorm 层等才必须加上for data in train_dataloader:imgs, targets = dataoutputs = network(imgs)# 计算模型预测与真实目标之间的损失# 它接受模型的输出（outputs）和真实的目标值（targets）作为输入，并返回一个表示两者差异的数值（通常是一个标量张量）。loss = loss_fn(outputs, targets)# 优化器开始调优，优化模型参数# 在每次训练迭代（iteration）开始时，都会调用这个zero_grad()方法来清除之前累积的梯度。# 这是因为在PyTorch中，梯度是累积的，如果你不清除之前的梯度，# 那么在下一次迭代时，梯度就会是之前迭代梯度的累加，这通常不是我们想要的。optimizer.zero_grad()# backward()这个方法会计算损失函数关于模型参数的梯度，并将结果存储在参数的.grad属性中。这是反向传播（backpropagation）的核心步骤。loss.backward()# step()这个方法会根据之前计算得到的梯度来更新模型的参数。# 具体来说，它会根据优化器（如SGD）中定义的算法来更新模型的参数，使其朝着损失函数减小的方向前进。optimizer.step()total_train_step = total_train_step + 1# 控制一下打印的频率，让其每逢100次时再打印日志if total_train_step % 100 == 0:# 在 PyTorch 中，当你计算得到一个损失（loss）或任何单元素张量（scalar tensor）时，这个值通常是一个 PyTorch 张量（tensor）。# 然而，在很多情况下，你可能想要将这个张量值转换为一个 Python 的基本数据类型（如 float 或 int），以便进行更简单的数学运算或打印。# loss.item() 就是用来做这个转换的。它会返回张量中的单个元素值作为一个 Python 数字。# 注意，这个方法只能在单元素张量（scalar tensor）上调用，即那些形状为 torch.Size([]) 的张量。print("训练次数: {}, Loss: {}".format(total_train_step, loss.item()))# 在 TensorBoard 中添加一个名为 'train_loss' 的标量（scalar）数据点，# 其值为当前的损失值（loss.item()），并将其与训练步骤 total_train_step 相关联”# "train_loss"：这是你要在 TensorBoard 中显示的数据的标签。#               当你打开 TensorBoard 并查看数据时，你会在图表或表格中看到这个标签。# loss.item()：这是从 PyTorch 的张量（tensor）中提取出的单个元素值（在这个情况下是损失值）。# total_train_step：这是训练步骤的编号或索引。在训练过程中，随着每个批次的迭代，这个值通常会递增。#                   它用于在 TensorBoard 的图表中跟踪损失值随时间（或训练步骤）的变化。writer.add_scalar("train_loss", loss.item(), total_train_step)# 测试步骤开始（每完成一个轮回，即一次前向和反向传播完整个训练数据集，就测试一下效果，看测试集上的损失值大小）# network.eval() 这一步对于当前网络来说并不是必要的，有无皆可，但如果网络中涉及了 Dropout 层 或者 BatchNorm 层等才必须加上total_test_loss = 0# 在 PyTorch 中，torch.no_grad() 并不是一个函数调用，而是一个上下文管理器（context manager），# 通常与 with 关键字一起使用，以确保在 with 语句块中的操作不会计算梯度，从而节省内存和计算资源。with torch.no_grad():for data in test_dataloader:imgs, targets = dataoutputs = network(imgs)loss = loss_fn(outputs, targets)total_test_loss = total_test_loss + loss.item()print("整体测试集上的Loss: {}".format(total_test_loss))writer.add_scalar("test_loss", total_test_loss, total_test_step)total_test_step = total_test_step + 1# 12、保存一下每一轮训练的模型torch.save(network.state_dict(), "network_{}.pth".format(i+1))print("模型已保存")# 13、关闭 tensorboard
writer.close()

使用GPU进行模型训练

CUDA是什么

在使用 GPU 之前，先了解一下什么是 CUDA：

CUDA（Compute Unified Device Architecture）是由NVIDIA公司推出的一种通用并行计算架构，主要用于解决复杂的计算问题。这个架构包含了CUDA指令集架构（ISA）以及GPU内部的并行计算引擎，使得GPU能够像CPU一样执行复杂的计算任务。

CUDA的主要特点包括：

并行计算：CUDA允许开发者利用GPU的并行处理能力，将计算任务划分为许多小的、可以独立执行的部分，并在多个处理器核心上同时执行。这种并行处理方式可以显著提高计算速度。
编程模型：CUDA提供了一组扩展的C、C++和Fortran语言的编程接口，使得开发者能够在GPU上编写程序。这些程序通常包括在CPU上运行的主机代码和在GPU上运行的设备代码。
应用领域：CUDA在科学计算、人工智能、深度学习、图像处理等领域得到了广泛的应用。通过在GPU上运行计算密集型任务，CUDA可以显著加速应用程序的执行。
内存管理：CUDA提供了对GPU内存的直接访问和管理，允许开发者控制数据在主机和GPU之间的传输。
架构优化：CUDA平台设计用于充分利用NVIDIA GPU的架构，包括它们的多核处理能力和高速内存访问，适用于需要线程间通信或数据重用的场景。

CUDA的出现使得开发者能够更加方便地利用GPU的计算能力，实现了用更加廉价的设备资源实现更高效的并行计算的目标。随着GPU技术的不断发展，CUDA的应用范围也在不断扩大，成为了计算领域的重要工具之一。

使用GPU进行模型训练的第一种方式（不推荐）

使用 GPU 训练模型有两种方式，方式一主要有下面这几步：

在这里插入图片描述

注意下面代码的改动依然是建立在上面的模板代码中的，因此我只给出了被改动地方的代码。

1、找到我们的网络模型，使用网络模型对象调用 cuda() 方法。

# 6、创建网络模型
network = NetWork()
# 调用 GPU 进行训练
if torch.cuda.is_available():network = network.cuda() # 对于网络来说，可以不进行赋值，直接network.cuda()也可

2、找到我们的损失函数定义的位置，使用损失函数对象调用 cuda() 方法

# 7、定义损失函数
loss_fn = nn.CrossEntropyLoss()
# 损失函数也要调用 GPU 进行训练
if torch.cuda.is_available():loss_fn = loss_fn.cuda() # 对于损失函数来说，可以不进行赋值，直接loss_fn.cuda()也可

3、找到我们训练数据的地方，使用的数据对象也需要调用 cuda() 方法

# 训练步骤开始# network.train() 这一步对于当前网络来说并不是必要的，有无皆可，但如果网络中涉及了 Dropout 层 或者 BatchNorm 层等才必须加上for data in train_dataloader:imgs, targets = data# 数据也要进行 GPU 调度if torch.cuda.is_available():imgs = imgs.cuda() # 对于数据来说，必须进行赋值，不能直接imgs.cuda()targets = targets.cuda() # 对于数据来说，必须进行赋值，不能直接targets.cuda()outputs = network(imgs)

还有测试数据的地方也要嗷：

    with torch.no_grad():for data in test_dataloader:imgs, targets = dataif torch.cuda.is_available():imgs = imgs.cuda() # 对于数据来说，必须进行赋值，不能直接imgs.cuda()targets = targets.cuda() # 对于数据来说，必须进行赋值，不能直接targets.cuda()outputs = network(imgs)loss = loss_fn(outputs, targets)total_test_loss = total_test_loss + loss.item()print("整体测试集上的Loss: {}".format(total_test_loss))

然后就可以运行程序了，可以和普通的 CPU 版本比较一下，甚至都不需要使用计时工具就能发现使用 GPU 明显要快很多，这里就不演示了。

使用GPU进行模型训练的第二种方式（推荐）

1、先定义一个训练设备的对象

# 定义训练的设备
# device = torch.device("cpu")
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")# 1、准备训练数据集
train_data = torchvision.datasets.CIFAR10(root="./dataset2", train=True,transform=torchvision.transforms.ToTensor(), download=True)# 2、准备测试数据集
test_data = torchvision.datasets.CIFAR10(root="./dataset2", train=False,transform=torchvision.transforms.ToTensor(), download=True)

2、剩下的操作就和第一种方式差不多了，把下面四个部分的代码对应的修改一下，也就是将 cuda() 方法换成了 to() 方法而已

# 6、创建网络模型
network = NetWork()
network = network.to(device)  # 对于网络来说，可以不进行赋值，直接network.to()也可

# 7、定义损失函数
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device) # 对于损失函数来说，可以不进行赋值，直接loss_fn.to()也可

# 训练步骤开始# network.train() 这一步对于当前网络来说并不是必要的，有无皆可，但如果网络中涉及了 Dropout 层 或者 BatchNorm 层等才必须加上for data in train_dataloader:imgs, targets = dataimgs = imgs.to(device) # 对于数据来说，必须进行赋值，不能直接imgs.to()targets = targets.to(device) # 对于数据来说，必须进行赋值，不能直接targets.to()outputs = network(imgs)

# 测试步骤开始（每完成一个轮回，即一次前向和反向传播完整个训练数据集，就测试一下效果，看测试集上的损失值大小）total_test_loss = 0with torch.no_grad():for data in test_dataloader:imgs, targets = dataimgs = imgs.to(device) # 对于数据来说，必须进行赋值，不能直接imgs.cuda()targets = targets.to(device) # 对于数据来说，必须进行赋值，不能直接targets.cuda()

运行效果就不再赘述了，可以自己测试看看，比 CPU 快不少捏。

完整的模型验证（测试）套路

模型验证的含义：使用已经训练好的模型，然后给它提供新的输入数据（测试集）进行测试。

参考 Github 上众多优秀的开源项目不难发现，在每一个项目中都有会训练文件，比如本文开头讲的完整的模型训练套路 train.py ，同理也都会有一个测试模型验证的文件 test.py ，而这一节要说的就是如何写一份完整的模型验证的套路模板。

import torch
import torchvision
from PIL import Image
from model import NetWork# 1、加载测试数据集（这里以一个简单的图片为例）
image_path = "./images/img.png"# 注意：PNG格式的图片是四通道的，记得转成三通道的进行使用，否则会报错
image = Image.open(image_path).convert("RGB")
print(image)# 2、对测试用的数据集进行转换，转换成 PyTorch 能接受的形式
transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32, 32)),torchvision.transforms.ToTensor(),
])image = transform(image)
print(image.shape)# 3、加载我们训练好的模型
# 注意：如果是用GPU训练出来的模型要放在CPU上跑，那么要记得再加一个参数 map_location=torch.device("cpu")
model = torch.load("network_1.pth")
network = NetWork()
network.load_state_dict(model)
print(network)# 4、将数据输入到模型中进行测试
# 先将数据转换成 pytorch 可以接受的样子，因为 pytorch 中除了图片本身的 C、H、W 之外，还要一个 batch_size
# 因此我们需要将其进行一个转换：batch_size=1, C=3, H=32, W=32
image = torch.reshape(image, (1, 3, 32, 32))
output = network(image)
print(output)

总结

模板基本就是上面这些了，对于不同的学习任务上面的模板可能需要针对性的稍微的进行一点改动，但大体上都是如此，可以多参考 GitHub 上优秀的项目源码。

一定要继续加油嗷！

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

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

相关文章

java-串口通讯-连接硬件

java-串口通讯-连接硬件

串口通信（Serial Communications）的概念非常简单，串口按位（bit）发送和接收字节。尽管比按字节（byte）的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。它很…
阅读更多...
经典面试题之滑动窗口专题

经典面试题之滑动窗口专题

class Solution { public:int minSubArrayLen(int target, vector<int>& nums) {// 长度最小的子数组 // 大于等于 targetint min_len INT32_MAX;// 总和int sum 0;int start 0; // 起点for(int i 0; i< nums.size(); i) {sum nums[i];while(sum > targe…
阅读更多...
leetcode 547.省份数量

leetcode 547.省份数量

思路&#xff1a;dfs 或者这道题用bfs也是可以的。 这道题有点迷惑性&#xff0c;这里的数组给的是无向图的数组&#xff0c;而并不是地图&#xff0c;这里需要着重注意一下。 而后&#xff0c;这里的状态数组st没必要是二维的&#xff0c;我们并不会去遍历所给的数组&#…
阅读更多...
拥抱新质生产力，助力新型工业化！CMM电子展暨IARS机器人展5月东莞盛大起航

拥抱新质生产力，助力新型工业化！CMM电子展暨IARS机器人展5月东莞盛大起航

2024年5月15-17日&#xff0c;东浩兰生会展集团旗下CMM电子展&#xff06;IARS机器人展将在广东现代国际展览中心&#xff08;东莞厚街&#xff09;举办。展会面积达50000平方米&#xff0c;展示品牌700余个&#xff0c;同期论坛峰会30余场&#xff0c;预计专业观众超50000人次…
阅读更多...
代码随想录训练营Day25:贪心算法：加油站、分发糖果和K次取反的最大数组和

代码随想录训练营Day25:贪心算法：加油站、分发糖果和K次取反的最大数组和

1.1005K次取反后最大化的数组和 贪心策略&#xff1a;先按照绝对值的大小进行排序&#xff0c;绝对值大的排在前面&#xff0c;然后按照顺序&#xff0c;如果存在负值就翻转直到用完k次&#xff0c;或者遍历完之后&#xff0c;将最小的那个进行翻转即可。 class Solution { p…
阅读更多...
a表存在b表不存在的数据

a表存在b表不存在的数据

第二种&#xff1a;在卡法中最常见的left join 方法&#xff0c;实现数据的过滤。 SELECT * FROM A LEFT JOIN B ON A.IdB.Id WHERE 11 AND B.Id IS NULL;
阅读更多...
error: pathspec ‘XXX‘ did not match any file(s) known to git

error: pathspec ‘XXX‘ did not match any file(s) known to git

使用vscode&#xff0c;在本地开发切换分支时&#xff0c;报以下错误&#xff1a; error: pathspec XXX did not match any file(s) known to git 该问题是由于没有对应分支的原因。 首先使用一下命令&#xff0c;查看本地及远程的所有分支。 git branch -a 若没有对应的分…
阅读更多...
【第12章】spring-mvc自定义类型转换器

【第12章】spring-mvc自定义类型转换器

文章目录 前言一、请求对象二、自定义转换器三、注册转换器四、控制器五、执行顺序六、执行结果总结 前言 【第6章】spring类型转换器 在spring系列已经介绍了类型转换器、接下来我们通过案例了解下转换器在SpringMvc中的应用。 场景模拟&#xff1a;我们接收到客户端请求,解析…
阅读更多...
【MyBatisPlus】代码生成器、条件分页查询

【MyBatisPlus】代码生成器、条件分页查询

代码生成器 第一步 引入依赖 <!-- mybatisPlus的代码生成器--><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-generator</artifactId><version>3.3.1</version></dependency>第二步 创…
阅读更多...
极验4 一键解混淆

极验4 一键解混淆

提示&#xff01;本文章仅供学习交流&#xff0c;严禁用于任何商业和非法用途&#xff0c;未经许可禁止转载&#xff0c;禁止任何修改后二次传播&#xff0c;如有侵权&#xff0c;可联系本文作者删除&#xff01; AST简介 AST&#xff08;Abstract Syntax Tree&#xff09;&a…
阅读更多...
Linux专栏03：使用Xshell远程连接云服务器

Linux专栏03：使用Xshell远程连接云服务器

博客主页&#xff1a;Duck Bro 博客主页系列专栏&#xff1a;Linux专栏关注博主&#xff0c;后期持续更新系列文章如果有错误感谢请大家批评指出&#xff0c;及时修改感谢大家点赞&#x1f44d;收藏⭐评论✍ 使用Xshell远程连接云服务器 编号&#xff1a;03 文章目录 使用Xsh…
阅读更多...
Redis学习（九）｜如何保证MySQL和Redis的数据一致性

Redis学习（九）｜如何保证MySQL和Redis的数据一致性

文章目录 引言什么是数据一致性为什么会出现不一致的情况如何保证一致性分布式事务异步更新策略双写模式缓存失效策略定时同步策略 结论 引言 数据一致性是任何系统设计中至关重要的一个方面。在涉及到同时使用Redis和MySQL的场景中&#xff0c;保证两者之间的数据一致性尤为重…
阅读更多...
Redis 中，集合（Set）

Redis 中，集合（Set）

在 Redis 中&#xff0c;集合&#xff08;Set&#xff09;是一种无序的、由字符串组成的数据结构。集合中的每个元素都是唯一的&#xff0c;即集合不允许重复的元素。Redis 集合通过哈希表实现&#xff0c;添加、删除、查找元素的操作都能在平均常数时间内完成。 ### 集合的特…
阅读更多...
Jenkins集成Kubernetes 部署springboot项目

Jenkins集成Kubernetes 部署springboot项目

文章目录 准备部署的yml文件Harbor私服配置测试使用效果Jenkins远程调用参考文章 准备部署的yml文件 apiVersion: apps/v1 kind: Deployment metadata:namespace: testname: pipelinelabels:app: pipeline spec:replicas: 2selector:matchLabels:app: pipelinetemplate:metada…
阅读更多...
【linux系统开发基本命令】

【linux系统开发基本命令】

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 基本命令dockergitCpython总结 基本命令 sudo 管理员权限&#xff0c;一般用在命令的最前面 例如&#xff1a; sudo rm our.py删除our.py文件 pwd打印当前目录 cd…
阅读更多...
软件设计师-应用技术-数据结构及算法题4

软件设计师-应用技术-数据结构及算法题4

考题形式&#xff1a; 第一题&#xff1a;代码填空 4-5空 8-10第二题&#xff1a;时间复杂度 / 代码策略第三题&#xff1a;拓展&#xff0c;跟一组数据&#xff0c;把数据带入代码中&#xff0c;求解 基础知识及技巧&#xff1a; 1. 分治法&#xff1a; 基础知识&#xff1…
阅读更多...
STM32F103 ADC驱动程序设计

STM32F103 ADC驱动程序设计

设计了一种通过软件触发&#xff0c;循环采集的ADC驱动程序 #include "stdbool.h" #include "string.h" #include "stm32f0xx_ll_bus.h" #include "stm32f0xx_ll_gpio.h" #include "stm32f0xx_ll_adc.h" #include "stm…
阅读更多...
【Vue3 生命周期与组合式API】

【Vue3 生命周期与组合式API】

文章目录 一、Vue3 生命周期概述二、Vue3 组合式API 与选项式API 的对比1. 选项式API 生命周期钩子函数常用的生命周期钩子函数包括&#xff1a; 2. 组合式API 的优势组合式API 的主要优势包括&#xff1a;在生命周期管理上的优势 三、Vue3 组合式API 生命周期钩子函数1. setup…
阅读更多...
语音识别--降噪

语音识别--降噪

⚠申明&#xff1a; 未经许可&#xff0c;禁止以任何形式转载&#xff0c;若要引用&#xff0c;请标注链接地址。 全文共计3077字&#xff0c;阅读大概需要3分钟 &#x1f308;更多学习内容&#xff0c; 欢迎&#x1f44f;关注&#x1f440;【文末】我的个人微信公众号&#xf…
阅读更多...
三剑客之grep

三剑客之grep

grep初级简单使用&#xff1a;Liunx查找&过滤-CSDN博客 正则表达式-CSDN博客 目录 grep分类 返回值 使用返回值控制流程 grep参数示例 基本参数 grep与正则表达式的搭配使用与示例 看完正则与示例进行无答案式练习 grep 用于在文件或输入流中查找特定模式或文本。…
阅读更多...
最新文章

Copyright @ 2022~2023