基于YOLOv5n/s/m不同参数量级模型开发构建茶叶嫩芽检测识别模型，使用pruning剪枝技术来对模型进行轻量化处理，探索不同剪枝水平下模型性能影响

news2024/9/25 1:24:12

今天有点时间就想着之前遗留的一个问题正好拿过来做一下看看，主要的目的就是想要对训练好的目标检测模型进行剪枝处理，这里就以茶叶嫩芽检测数据场景为例了，在我前面的博文中已经有过相关的实践介绍了，感兴趣的话可以自行移步阅读即可：

《融合CBAM注意力机制基于YOLOv5开发构建毛尖茶叶嫩芽检测识别系统》

这里就不再赘述了。

本文选取了n/s/m三款不同量级的模型来依次构建训练模型，所有的参数保持同样的设置，之后探索在不同剪枝处理操作下的性能影响。

简单看下数据集情况：

 三款模型的训练指令如下所示：

#yolov5n
python3 train.py --cfg models/yolov5n.yaml --weights weights/yolov5n.pt --name yolov5n --epochs 100 --batch-size 4 --img-size 416

#yolov5s
python3 train.py --cfg models/yolov5s.yaml --weights weights/yolov5s.pt --name yolov5s --epochs 100 --batch-size 4 --img-size 416

#yolov5m
python3 train.py --cfg models/yolov5m.yaml --weights weights/yolov5m.pt --name yolov5m --epochs 100 --batch-size 4 --img-size 416

主要是两点，一是batchsize这里设置的比较小因为同时在跑三款模型，这里设置的都是4；另一方面是imgsize，这里为了加快实验节奏，设置的是416，比较低的分辨率而不是640。

默认都是100次epoch的迭代计算，接下来依次看下实际训练情况：
【yolov5n】

 【yolov5s】

 【yolov5m】

 从最终模型的评估结果上面来看：s系列的模型结果还不如n系列的模型，或者说是二者差异不大，m系列模型的结果要优于其他两款模型。

为了能够整体直观地对三款不同参数量级的模型进行直观地对比分析，这里对其主要指标进行了可视化处理，如下所示：

【Precision曲线】
精确率曲线（Precision-Recall Curve）是一种用于评估二分类模型在不同阈值下的精确率性能的可视化工具。它通过绘制不同阈值下的精确率和召回率之间的关系图来帮助我们了解模型在不同阈值下的表现。
精确率（Precision）是指被正确预测为正例的样本数占所有预测为正例的样本数的比例。召回率（Recall）是指被正确预测为正例的样本数占所有实际为正例的样本数的比例。
绘制精确率曲线的步骤如下：
使用不同的阈值将预测概率转换为二进制类别标签。通常，当预测概率大于阈值时，样本被分类为正例，否则分类为负例。
对于每个阈值，计算相应的精确率和召回率。
将每个阈值下的精确率和召回率绘制在同一个图表上，形成精确率曲线。
根据精确率曲线的形状和变化趋势，可以选择适当的阈值以达到所需的性能要求。
通过观察精确率曲线，我们可以根据需求确定最佳的阈值，以平衡精确率和召回率。较高的精确率意味着较少的误报，而较高的召回率则表示较少的漏报。根据具体的业务需求和成本权衡，可以在曲线上选择合适的操作点或阈值。
精确率曲线通常与召回率曲线（Recall Curve）一起使用，以提供更全面的分类器性能分析，并帮助评估和比较不同模型的性能。


【Recall曲线】
召回率曲线（Recall Curve）是一种用于评估二分类模型在不同阈值下的召回率性能的可视化工具。它通过绘制不同阈值下的召回率和对应的精确率之间的关系图来帮助我们了解模型在不同阈值下的表现。
召回率（Recall）是指被正确预测为正例的样本数占所有实际为正例的样本数的比例。召回率也被称为灵敏度（Sensitivity）或真正例率（True Positive Rate）。
绘制召回率曲线的步骤如下：
使用不同的阈值将预测概率转换为二进制类别标签。通常，当预测概率大于阈值时，样本被分类为正例，否则分类为负例。
对于每个阈值，计算相应的召回率和对应的精确率。
将每个阈值下的召回率和精确率绘制在同一个图表上，形成召回率曲线。
根据召回率曲线的形状和变化趋势，可以选择适当的阈值以达到所需的性能要求。
通过观察召回率曲线，我们可以根据需求确定最佳的阈值，以平衡召回率和精确率。较高的召回率表示较少的漏报，而较高的精确率意味着较少的误报。根据具体的业务需求和成本权衡，可以在曲线上选择合适的操作点或阈值。
召回率曲线通常与精确率曲线（Precision Curve）一起使用，以提供更全面的分类器性能分析，并帮助评估和比较不同模型的性能。


【F1值曲线】
F1值曲线是一种用于评估二分类模型在不同阈值下的性能的可视化工具。它通过绘制不同阈值下的精确率（Precision）、召回率（Recall）和F1分数的关系图来帮助我们理解模型的整体性能。
F1分数是精确率和召回率的调和平均值，它综合考虑了两者的性能指标。F1值曲线可以帮助我们确定在不同精确率和召回率之间找到一个平衡点，以选择最佳的阈值。
绘制F1值曲线的步骤如下：
使用不同的阈值将预测概率转换为二进制类别标签。通常，当预测概率大于阈值时，样本被分类为正例，否则分类为负例。
对于每个阈值，计算相应的精确率、召回率和F1分数。
将每个阈值下的精确率、召回率和F1分数绘制在同一个图表上，形成F1值曲线。
根据F1值曲线的形状和变化趋势，可以选择适当的阈值以达到所需的性能要求。
F1值曲线通常与接收者操作特征曲线（ROC曲线）一起使用，以帮助评估和比较不同模型的性能。它们提供了更全面的分类器性能分析，可以根据具体应用场景来选择合适的模型和阈值设置。

 【loss曲线】

 整体来看m系列模型无意识这三款不同参数量级模型中表现最好的，n和s系列模型的表现相近。

接下来要对三款模型进行剪枝处理，这里使用到一个很好用的第三方模块torch_pruning，官方项目地址在这里，如下所示：

 安装方式很简单如下所示：

pip install torch-pruning 
或者
git clone https://github.com/VainF/Torch-Pruning.git

在结构修剪中，“组”被定义为可以在深度网络中移除的最小单元。这些组由多个相互依赖的层组成，需要一起修剪，以保持生成结构的完整性。然而，深度网络的层之间往往存在复杂的依赖关系，这使得结构修剪成为一项具有挑战性的任务。这项工作通过引入一种名为“DepGraph”的自动化机制来解决这一挑战。DepGraph允许无缝的参数分组，并有助于在各种类型的深度网络中进行修剪。

官方提供很多可用的实例，如下所示：

【Naive pruning】

为了演示依赖性的含义，让我们在ResNet-18上尝试结构化修剪。以下代码片段尝试从第一个model.conv1中删除由0和1索引的通道：

from torchvision.models import resnet18
import torch_pruning as tp

model = resnet18(pretrained=True).eval()
tp.prune_conv_out_channels(model.conv1, idxs=[0,1]) # remove channel 0 and channel 1
output = model(torch.randn(1,3,224,224)) # test


输出 
ResNet(
  (conv1): Conv2d(3, 62, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
...

【An improved version】

事实上，上述情况下的依赖关系比我们已经观察到的要复杂得多。让我们改进我们的代码，看看如果处理BN和Conv会发生什么。

from torchvision.models import resnet18
import torch_pruning as tp

model = resnet18(pretrained=True).eval()
tp.prune_conv_out_channels(model.conv1, idxs=[0,1]) 
tp.prune_batchnorm_out_channels(model.bn1, idxs=[0,1])
tp.prune_batchnorm_in_channels(model.layer1[0].conv1, idxs=[0,1])
output = model(torch.randn(1,3,224,224))

【A Minimal Example】

import torch
from torchvision.models import resnet18
import torch_pruning as tp

model = resnet18(pretrained=True).eval()

# 1. build dependency graph for resnet18
DG = tp.DependencyGraph().build_dependency(model, example_inputs=torch.randn(1,3,224,224))

# 2. Specify the to-be-pruned channels. Here we prune those channels indexed by [2, 6, 9].
group = DG.get_pruning_group( model.conv1, tp.prune_conv_out_channels, idxs=[2, 6, 9] )

# 3. prune all grouped layers that are coupled with model.conv1 (included).
if DG.check_pruning_group(group): # avoid full pruning, i.e., channels=0.
    group.prune()
    
# 4. Save & Load
model.zero_grad() # We don't want to store gradient information
torch.save(model, 'model.pth') # without .state_dict
model = torch.load('model.pth') # load the model object

上面的示例演示了使用DepGraph的基本修剪管道。目标层resnet.conv1与多个层耦合，这需要在结构修剪中同时移除。让我们打印该组，并观察修剪操作是如何“触发”其他修剪操作的。在以下输出中，A=>B表示修剪操作A触发修剪操作B。group[0]表示DG.get_pruning_group中的修剪根。

--------------------------------
          Pruning Group
--------------------------------
[0] prune_out_channels on conv1 (Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)) => prune_out_channels on conv1 (Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)), idxs=[2, 6, 9] (Pruning Root)
[1] prune_out_channels on conv1 (Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)) => prune_out_channels on bn1 (BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)), idxs=[2, 6, 9]
[2] prune_out_channels on bn1 (BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)) => prune_out_channels on _ElementWiseOp_20(ReluBackward0), idxs=[2, 6, 9]
[3] prune_out_channels on _ElementWiseOp_20(ReluBackward0) => prune_out_channels on _ElementWiseOp_19(MaxPool2DWithIndicesBackward0), idxs=[2, 6, 9]
[4] prune_out_channels on _ElementWiseOp_19(MaxPool2DWithIndicesBackward0) => prune_out_channels on _ElementWiseOp_18(AddBackward0), idxs=[2, 6, 9]
[5] prune_out_channels on _ElementWiseOp_19(MaxPool2DWithIndicesBackward0) => prune_in_channels on layer1.0.conv1 (Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)), idxs=[2, 6, 9]
[6] prune_out_channels on _ElementWiseOp_18(AddBackward0) => prune_out_channels on layer1.0.bn2 (BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)), idxs=[2, 6, 9]
[7] prune_out_channels on _ElementWiseOp_18(AddBackward0) => prune_out_channels on _ElementWiseOp_17(ReluBackward0), idxs=[2, 6, 9]
[8] prune_out_channels on _ElementWiseOp_17(ReluBackward0) => prune_out_channels on _ElementWiseOp_16(AddBackward0), idxs=[2, 6, 9]
[9] prune_out_channels on _ElementWiseOp_17(ReluBackward0) => prune_in_channels on layer1.1.conv1 (Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)), idxs=[2, 6, 9]
[10] prune_out_channels on _ElementWiseOp_16(AddBackward0) => prune_out_channels on layer1.1.bn2 (BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)), idxs=[2, 6, 9]
[11] prune_out_channels on _ElementWiseOp_16(AddBackward0) => prune_out_channels on _ElementWiseOp_15(ReluBackward0), idxs=[2, 6, 9]
[12] prune_out_channels on _ElementWiseOp_15(ReluBackward0) => prune_in_channels on layer2.0.downsample.0 (Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)), idxs=[2, 6, 9]
[13] prune_out_channels on _ElementWiseOp_15(ReluBackward0) => prune_in_channels on layer2.0.conv1 (Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)), idxs=[2, 6, 9]
[14] prune_out_channels on layer1.1.bn2 (BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)) => prune_out_channels on layer1.1.conv2 (Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)), idxs=[2, 6, 9]
[15] prune_out_channels on layer1.0.bn2 (BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)) => prune_out_channels on layer1.0.conv2 (Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)), idxs=[2, 6, 9]
--------------------------------

【High-level Pruners】

利用DependencyGraph，我们在这个存储库中开发了几个高级修剪器，以方便轻松修剪。通过指定所需的通道稀疏性，可以修剪整个模型，并使用自己的训练代码对其进行微调。有关这个过程的详细信息，请参阅本教程，它展示了如何从头开始实现瘦身修剪器。此外，您可以在benchmarks/main.py中找到更实用的示例。

import torch
from torchvision.models import resnet18
import torch_pruning as tp

model = resnet18(pretrained=True)

# Importance criteria
example_inputs = torch.randn(1, 3, 224, 224)
imp = tp.importance.TaylorImportance()

ignored_layers = []
for m in model.modules():
    if isinstance(m, torch.nn.Linear) and m.out_features == 1000:
        ignored_layers.append(m) # DO NOT prune the final classifier!

iterative_steps = 5 # progressive pruning
pruner = tp.pruner.MagnitudePruner(
    model,
    example_inputs,
    importance=imp,
    iterative_steps=iterative_steps,
    ch_sparsity=0.5, # remove 50% channels, ResNet18 = {64, 128, 256, 512} => ResNet18_Half = {32, 64, 128, 256}
    ignored_layers=ignored_layers,
)

base_macs, base_nparams = tp.utils.count_ops_and_params(model, example_inputs)
for i in range(iterative_steps):
    if isinstance(imp, tp.importance.TaylorImportance):
        # Taylor expansion requires gradients for importance estimation
        loss = model(example_inputs).sum() # a dummy loss for TaylorImportance
        loss.backward() # before pruner.step()
    pruner.step()
    macs, nparams = tp.utils.count_ops_and_params(model, example_inputs)
    # finetune your model here
    # finetune(model)
    # ...

还有很多其他的功能实例，这里就不再一一赘述了，可以参考使用即可，这里我借鉴官方的实例来完成对yolov5n/s/m三款不同参数量级模型的剪枝处理。剪枝完成后结果如下所示：

 接下来我想直接使用剪枝后的模型来进行评估测试，不出意外的话结果应该会很差的，先来简单看下吧。

【yolov5n_layer_pruning】

 【yolov5s_layer_pruning】

 【yolov5m_layer_pruning】

 果然是惨不忍睹，直接使用剪枝后的模型文件是不行的，这样破坏了原始完整的模型结构，导致原有学习后的知识已经无效了。

接下来就需要基于剪枝后的结构来进行微调训练。这里我同样保持了与最初模型训练一样的参数设置，如下所示：

#yolov5n
python3 train.py --weights yolov5n_layer_pruning.pt --pt --name yolov5n_pruning  --epochs 100 --batch-size 4 --img-size 416

#yolov5s
python3 train.py --weights yolov5s_layer_pruning.pt --pt --name yolov5s_pruning  --epochs 100 --batch-size 4 --img-size 416

#yolov5m
python3 train.py --weights yolov5m_layer_pruning.pt --pt --name yolov5m_pruning  --epochs 100 --batch-size 4 --img-size 416

这里其实也可以不用训练100次epoch，只不过我想默认保持一样的参数设置，等待一段时间后来看下结果记录。

【yolov5n_pruning】

 【yolov5s_pruning】

 【yolov5m_pruning】

 这里从评估结果上来看：n<s<m。接下来我们同样对其进行对比可视化分析展示。

【F1值】

 【精确率】

 【召回率】

 【loss】

 上述的三组剪枝实验结果是建立在剪枝30%的基础上，产生的结果，可以看到：甚至剪枝后的效果还要优于原始的模型，这也说明了原始的模型中存在相当量的参数冗余。

接下来我们想要进一步探索不同程度剪枝水平对于模型性能的影响程度，前车之鉴，这里写CSDN博文都不敢一篇文章写太多内容，不然突然页面崩溃就会好心酸。。。。。。

我把这部分的内容放在下一篇博文中，如下所示：
《基于YOLOv5n/s/m不同参数量级模型开发构建茶叶嫩芽检测识别模型，预计pruning剪枝技术来对模型进行轻量化处理，探索不同剪枝水平下模型性能影响【续】》

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

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

相关文章

QT的设计器介绍

QT的设计器介绍

设计器介绍 Qt制作 UI 界面&#xff0c;一般可以通过UI制作工具QtDesigner和纯代码编写两种方式来实现。纯代码实现暂时在这里不阐述了在后续布局章节详细说明&#xff0c;QtDesigner已经继承到开发环境中&#xff0c;在工程中直接双击ui文件就可以直接在QtDesigner设计器中打…
阅读更多...
AtCoder Beginner Contest 314 E题题解

AtCoder Beginner Contest 314 E题题解

文章目录 Roulettes问题建模问题分析1.分析每个转盘对所求的作用2.从集合的角度思考每个积分的贡献代码 Roulettes 问题建模 给定n个轮盘&#xff0c;每个轮盘上有p个积分&#xff0c;每次转动轮盘需要一定的代价&#xff0c;在转动轮盘后可以等概率获得p个积分中的一个&#…
阅读更多...
【通俗易懂】如何使用GitHub上传文件，如何用git在github上传文件

【通俗易懂】如何使用GitHub上传文件，如何用git在github上传文件

目录 创建 GitHub 仓库 使用 Git 进行操作 步骤 1&#xff1a;初始化本地仓库 步骤 2&#xff1a;切换默认分支 步骤 3&#xff1a;连接到远程仓库 步骤 4&#xff1a;获取远程更改 步骤 5&#xff1a;添加文件到暂存区 步骤 6&#xff1a;提交更改 步骤 7&#xff1a…
阅读更多...
频繁full gc 调参

频繁full gc 调参

Error message from spark is:java.lang.Exception: application_1678793738534_17900289 Driver Disassociated [akka.tcp://sparkDriverClient11.71.243.117:37931] <- [akka.tcp://sparkYarnSQLAM9.10.130.149:38513] disassociated! 日志里频繁full gc &#xff0c;可以…
阅读更多...
nginx代理请求到内网不同服务器

nginx代理请求到内网不同服务器

需求&#xff1a;之前用的是frp做的内网穿透&#xff0c;但是每次电脑断电重启&#xff0c;路由或者端口会冲突&#xff0c;现在使用汉土云盒替换frp。 需要把公网ip映射到任意一台内网服务器上&#xff0c;然后在这台内网服务器上用Nginx做代理即可访问内网其它服务器&#xf…
阅读更多...
微服务中间件--微服务保护

微服务中间件--微服务保护

微服务保护 微服务保护a.sentinelb.sentinel限流规则1) 流控模式1.a) 关联模式1.b) 链路模式 2) 流控效果2.a) 预热模式2.b) 排队等待 3) 热点参数限流 c.隔离和降级1) Feign整合Sentinel2) 线程隔离2.a) 线程隔离&#xff08;舱壁模式&#xff09; 3) 熔断降级3.a) 熔断策略-慢…
阅读更多...
Xshell安装使用教程安排～

Xshell安装使用教程安排～

简介 Xshell 是一个强大的安全终端模拟软件&#xff0c;它支持SSH1, SSH2, 以及Microsoft Windows 平台的TELNET 协议。Xshell 通过互联网到远程主机的安全连接以及它创新性的设计和特色帮助用户在复杂的网络环境中享受他们的工作。 Xshell可以在Windows界面下用来访问远端不…
阅读更多...
蔚来李斌卖手机：安卓系统，苹果售价，一年一发

蔚来李斌卖手机：安卓系统，苹果售价，一年一发

‍作者 | Amy 编辑 | 德新 车圈大佬的玩法真让人寻不着套路&#xff01; 苹果的库克和小米的雷布斯&#xff0c;甚至是FF贾老板准备许久&#xff0c;都想分一块新能源车的蛋糕&#xff0c;蔚来李斌却反手进军手机界&#xff0c;从宣布造手机到手机入网仅仅隔了一年。 近期…
阅读更多...
微盟集团中报增长稳健 重点发力智慧零售AI赛道

微盟集团中报增长稳健 重点发力智慧零售AI赛道

零售数字化进程已从渠道构建走向了用户的深度运营。粗放式用户运营体系无法适应“基于用户增长所需配套的精细化运营能力”,所以需要有个体、群体、个性化、自动化运营——即在对的时候、以对的方式、把对的内容推给用户。 出品|产业家 2023年已经过半&#xff0c;经济复苏成为…
阅读更多...
生信豆芽菜-两组比较的柱状图

生信豆芽菜-两组比较的柱状图

网址&#xff1a;http://www.sxdyc.com/visualsPlotMutiBar 1、数据准备 准备一个两列的数据 2、输入图片的宽度和高度&#xff0c;如果这里选择不转置&#xff0c;选择颜色&#xff0c;这里的颜色个数由输入数据第一列分组的个数决定&#xff0c;如果选择转置&#xff0c;选…
阅读更多...
随手笔记——g2o实现BA

随手笔记——g2o实现BA

随手笔记——g2o实现BA 说明源代码 说明 源代码 bundle_adjustment_g2o.cpp #include <g2o/core/base_vertex.h> #include <g2o/core/base_binary_edge.h> #include <g2o/core/block_solver.h> #include <g2o/core/optimization_algorithm_levenberg.h&…
阅读更多...
MapReduce介绍

MapReduce介绍

目录 ​一、什么是MapReduce 二、MapReduce 的设计思想 2.1 分而治之 2.2 构建抽象模型&#xff1a;Map和Reduce 2.3 隐藏系统层细节 三、MapReduce 的框架原理 3.1 MRv1工作原理 3.1.1 MRv1架构工作原理图 3.1.1.1 流程说明 3.1.1.1.1 作业的提交 3.1.1.1.2 作业的初始化 3…
阅读更多...
在线客户评论——电商行业的终极销售人员

在线客户评论——电商行业的终极销售人员

电子商务评论是最近购买或使用产品或服务的人对产品或服务的评估&#xff0c;是一种反馈&#xff0c;可帮助在线购物者做出更好的购买决策&#xff0c;帮助企业主完善其产品和服务范围。您的在线声誉取决于有多少客户喜欢您的品牌购物体验&#xff0c;那些与贵公司有积极互动的…
阅读更多...
代码随想录算法训练营第四十二天|LeetCode 121，122

代码随想录算法训练营第四十二天|LeetCode 121，122

目录 LeetCode 121.买卖股票的最佳时机 动态规划五步曲&#xff1a; 1.确定dp[i][j] 的含义 2.找出递推公式 3.初始化dp数组 4.确定遍历方向 5.打印dp数组 LeetCode 122.买卖股票的最佳时间II 动态规划五步曲&#xff1a; 1.确定dp[i][j] 的含义 2.找出递推公式 3.初始化dp数组…
阅读更多...
【C++起飞之路】类和对象 —— 类

【C++起飞之路】类和对象 —— 类

类 ~ ~ ~ 一、面向过程和面向对象初步认识a. 面向过程编程b. 面向对象编程例如&#xff1a;无人机送货系统1、面向过程编程方式2、面向对象编程方式 二、类的引入1、定义类的关键字2、栈的手动实现a. C语言实现栈b. C实现栈 三、类的定义类的两种定义方式&#xff1a; 四、类的…
阅读更多...
Linux6.40 Kubernetes 配置资源管理

Linux6.40 Kubernetes 配置资源管理

文章目录 计算机系统5G云计算第三章 LINUX Kubernetes 配置资源管理一、Secret1.Secret 四种类型1&#xff09;kubernetes.io/service-account-token2&#xff09;Opaque3&#xff09;kubernetes.io/dockerconfigjson4&#xff09;kubernetes.io/tls 2.Pod 需要先引用才能使用某…
阅读更多...
售后服务管理系统哪家好？云部署的售后服务软件有什么优势？

售后服务管理系统哪家好？云部署的售后服务软件有什么优势？

如今&#xff0c;越来越多的企业开始利用数字化系统来监控他们建造、操作或维护的高科技设备的技术属性。然而&#xff0c;仍然有很多公司依赖于孤立的低技术解决方案&#xff0c;比如使用Excel电子表格和手动流程来管理工作。当然&#xff0c;对于一家公司来说&#xff0c;寻找…
阅读更多...
【AI大模型】训练Al大模型 （上篇）

【AI大模型】训练Al大模型 （上篇）

大模型超越AI 前言 洁洁的个人主页 我就问你有没有发挥&#xff01; 知行合一&#xff0c;志存高远。 目前所指的大模型&#xff0c;是“大规模深度学习模型”的简称&#xff0c;指具有大量参数和复杂结构的机器学习模型&#xff0c;可以处理大规模的数据和复杂的问题&#x…
阅读更多...
QT的工程文件认识

QT的工程文件认识

目录 1、QT介绍 2、QT的特点 3、QT模块 3.1基本模块 3.2扩展模块 4、QT工程创建 1.选择应用的窗体格式 2.设置工程的名称与路径 3.设置类名 4.选择编译器 5、QT 工程解析 xxx.pro 工程配置 xxx.h 头文件 main.cpp 主函数 xxx.cpp 文件 6、纯手工创建一个QT 工程…
阅读更多...
spring框架之AOP模块，附带通知类型-----详细介绍

spring框架之AOP模块，附带通知类型-----详细介绍

一&#xff0c;AOP简介 是Spring框架中的一个重要模块&#xff0c;它提供了一种通过面向切面编程的方式来实现横切关注点的模块化的方法。AOP可以将应用程序的核心业务逻辑与横切关注点&#xff08;如日志记录、事务管理、安全性等&#xff09;分离开来&#xff0c;从而提高代码…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023