Pytorch模型使用与修改、保存与加载

模型的使用及修改、保存与加载

以图像处理中torchvision为例，PyTorch通过torchvision.models模块提供了更多的预训练模型.

在图像分类当中，包括许多模型
在这里插入图片描述

import torchvision
import warnings
import torch
warnings.filterwarnings("ignore")

本文将以VGG16为例，展示Pytorch对现有模型的使用及修改的具体操作
在这里插入图片描述

VGG16是一个经典的卷积神经网络模型，由牛津大学计算机视觉组（Visual Geometry Group）提出，用于参加2014年的ImageNet图像分类。

VGG 最大的特点就是通过比较彻底地采用 3x3 尺寸的卷积核来堆叠神经网络，这样也加深整个神经网络的深度。这两个重要的改变对于人们重新定义卷积神经网络模型架构也有不小的帮助，至少证明使用更小的卷积核并且增加卷积神经网络的深度，可以更有效地提升模型的性能。

torchvision.models.vgg16(*, weights: Optional[VGG16_Weights] = None, progress: bool = True, **kwargs: Any)
  • weights(可选)：指定要加载的预训练权重。可以是None（默认值）表示不加载预训练权重，或是指定为预定义的某个预训练权重标识符。
  • progress:指示下载进度条的显示设置，默认为True显示下载进度条。
  • kwargs:其它可选参数，传递给VGG-16模型的基类torchvision.models.VGG
vgg16 = torchvision.models.vgg16(weights=True,progress=True)

print(vgg16)

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

从上述运行结果可知：VGG16网络是由13层卷积层和3层全连接层组成，最后网络输出一共有1000个分类结果。

修改VGG16模型：

  • 以CIFAR10为例

  • 使用add_module()方法在VGG16模型后增加一个线性层，实现将VGG16的1000个类别输出为类似CIFAR10的10个类别，代码如下：

import torchvision.models as models
from torch import nn

vgg16 = torchvision.models.vgg16(weights=True,progress=True)

vgg16.add_module("add_linear", nn.Linear(1000, 10))
print(vgg16)

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
  (add_linear): Linear(in_features=1000, out_features=10, bias=True)
)

由上述可以知道，add_linear是在classifier外面的，如果要在classifier里面，可以将

vgg16.add_module("add_linear", nn.Linear(1000, 10))

替换为

vgg16.classifier.add_module("add_linear", nn.Linear(1000, 10))

import torchvision.models as models
from torch import nn

vgg16 = torchvision.models.vgg16(weights=True,progress=True)

vgg16.classifier.add_module("add_linear", nn.Linear(1000, 10))
print(vgg16)

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
    (add_linear): Linear(in_features=1000, out_features=10, bias=True)
  )
)

也可以直接进行修改,例如对classifier中的 6): Linear(in_features=4096, out_features=1000, bias=True)直接修改为out_features=10

vgg16.classifier[6] = nn.Linear(in_features=4096,out_features=10,bias=True)

网络模型的保存与读取

在这里插入图片描述

模型的保存

torch.save(obj, f, pickle_protocol=DEFAULT_PROTOCOL)
参数描述
obj:要保存的对象，可以是模型、张量、字典等
f:要保存到的文件路径或文件对象
pickle_protocol:序列化协议的版本，默认为DEFAULT_PROTOCOL

方法一：保存整个模型，包括其相关的所有参数，利用torch.save()

import torchvision

vgg16 = torchvision.models.vgg16(weights=True, progress=True)
torch.save(vgg16, "vgg16_model_true.pth")

方法二：只保存模型参数，在原有vgg16对象中使用.state_dict()方法即可。

import torchvision

vgg16 = torchvision.models.vgg16(weights=True,progress=True)
torch.save(vgg16.state_dict(), "vgg16_model_true_2.pth")

运行成功后，对应的文件：vgg16_model_true.pth和 vgg16_model_true_2.pth会保存在默认路径当中

网络模型的加载

torch.load(f, map_location=None, pickle_module=pickle, *, weights_only=False, mmap=None, **pickle_load_args)
参数描述
f要加载的文件路径或文件对象
map_location可选参数，用于指定在哪个设备上加载模型。如果不提供该参数，默认会加载到当前设备
pickle_module可选参数，用于指定用于反序列化的模块。默认为pickle
pickle_load_args其他可选的用于反序列化的参数
import torch
import torchvision.models as models
from torch import nn
# 因为vgg16_model_true.pth是使用方法一保存的，故输出后是整个模型网络结构
model1 = torch.load("vgg16_model_true.pth")
print(model1)

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

# 因为vgg16_model_true_2.pth是使用方法二保存的，只保留模型参数，故输出后是整个字典类型
model2 = torch.load("vgg16_model_true_2.pth")
print(model2)

OrderedDict([('features.0.weight', tensor([[[[-5.5373e-01,  1.4270e-01,  5.2896e-01],
          [-5.8312e-01,  3.5655e-01,  7.6566e-01],
          [-6.9022e-01, -4.8019e-02,  4.8409e-01]],

         [[ 1.7548e-01,  9.8630e-03, -8.1413e-02],
          [ 4.4089e-02, -7.0323e-02, -2.6035e-01],
          [ 1.3239e-01, -1.7279e-01, -1.3226e-01]],

         [[ 3.1303e-01, -1.6591e-01, -4.2752e-01],
          [ 4.7519e-01, -8.2677e-02, -4.8700e-01],
          [ 6.3203e-01,  1.9308e-02, -2.7753e-01]]],


        [[[ 2.3254e-01,  1.2666e-01,  1.8605e-01],
          [-4.2805e-01, -2.4349e-01,  2.4628e-01],
          [-2.5066e-01,  1.4177e-01, -5.4864e-03]],

         [[-1.4076e-01, -2.1903e-01,  1.5041e-01],
          [-8.4127e-01, -3.5176e-01,  5.6398e-01],
          [-2.4194e-01,  5.1928e-01,  5.3915e-01]],

        .............省略了........

针对只保存了模型参数的第二种情况，使其显示完整的模型结构，利用.load_state_dict()

import torch
import torchvision.models as models
from torch import nn

vgg16 = models.vgg16(weights=False)

vgg16.load_state_dict(torch.load("vgg16_model_true_2.pth"))  # 针对第二种加载参数的情况，使其显示完整的网络结构
print(vgg16_true)

VGG(
  (features): Sequential(
    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (6): ReLU(inplace=True)
    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (8): ReLU(inplace=True)
    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (11): ReLU(inplace=True)
    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (13): ReLU(inplace=True)
    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (15): ReLU(inplace=True)
    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (18): ReLU(inplace=True)
    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (20): ReLU(inplace=True)
    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (22): ReLU(inplace=True)
    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (25): ReLU(inplace=True)
    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (27): ReLU(inplace=True)
    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (29): ReLU(inplace=True)
    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))
  (classifier): Sequential(
    (0): Linear(in_features=25088, out_features=4096, bias=True)
    (1): ReLU(inplace=True)
    (2): Dropout(p=0.5, inplace=False)
    (3): Linear(in_features=4096, out_features=4096, bias=True)
    (4): ReLU(inplace=True)
    (5): Dropout(p=0.5, inplace=False)
    (6): Linear(in_features=4096, out_features=1000, bias=True)
  )
)

注意： 加载模型时，要确保当前代码中使用的模型类与之前保存的模型类相同。

总结

  • torch.load()是PyTorch中用于加载保存的对象的函数，可以加载之前使用

  • torch.save()保存的模型、张量、字典等。可以指定要加载的文件路径或文件对象，并可选地指定加载到的设备、反序列化模块等参数。

在这里插入图片描述

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

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

相关文章

C++ 代码实例：并查集简单创建工具

C++ 代码实例：并查集简单创建工具

文章目录 前言代码仓库代码说明main.cppMakefile 结果总结参考资料作者的话 前言 C 代码实例：并查集简单创建工具。 代码仓库 yezhening/Programming-examples: 编程实例 (github.com)Programming-examples: 编程实例 (gitee.com) 代码 说明 简单地创建并查集注…
阅读更多...
软件测试|PO设计模式在 UI 自动化中的实践

软件测试|PO设计模式在 UI 自动化中的实践

PO的思想最早是2013年由IT大佬Martin Flower提出的：https://martinfowler.com/bliki/PageObject.html 没错，就是他 — 没错，就是他 — 在他的文章里有这样一张经典样图,图片中展示了测试代码中直接操作HTML元素和使用PO模式将page对象封装成…
阅读更多...
“锡安主义”贝尔福宣言希伯来抵抗运动犹太启蒙改革运动奋锐党闪米特人雅利安人

“锡安主义”贝尔福宣言希伯来抵抗运动犹太启蒙改革运动奋锐党闪米特人雅利安人

目录 “锡安主义” 贝尔福宣言 希伯来抵抗运动 犹太启蒙改革运动 奋锐党 闪米特人 雅利安人 “锡安主义” “锡安主义”是一种政治和民族运动，旨在支持并促进犹太人建立自己的国家并在历史上与宗教上的祖先之地——巴勒斯坦地区建立一个独立的国家。这一运动…
阅读更多...
C++11常用特性

C++11常用特性

目录 1、{}初始化 2、auto 3、decltype 4、nullptr 5、范围for 6、STL容器 7、右值引用 ①左值引用和右值引用 ②移动构造 ③移动赋值 ④万能引用与完美转发 8、新的类功能 9、可变模版参数 10、lambda表达式 捕捉列表的使用 [val]：传值捕捉 [&…
阅读更多...
GPTZero：论文打假神器

GPTZero：论文打假神器

记住这张脸他是全美学生的公敌。 别的学生在AI大浪潮间翻云覆雨，有的用GPT代写作业，有的用GPT代工论文，大家都忙的不亦乐乎。 正在大家都在欢呼雀跃跟作业拜拜时，就是这个小伙，普林斯顿大学的华裔小天才Edward Tian…
阅读更多...
C++/Qt 小知识记录4

C++/Qt 小知识记录4

工作中遇到的一些小问题，总结的小知识记录：C/Qt 小知识4 mysql导入*.sql文件提示连接超时等问题mysql局域网内访问VLC低版本的匹配QLineEdit的正则表达式限制获取windows下已加载磁盘盘符QLabel自动换行QElapsedTimer间隔计时自定义Class作为Key需要重载…
阅读更多...
Spark SQL

Spark SQL

Spark SQL 本文来自 B站 黑马程序员 - Spark教程 ：原地址 第一章 SparkSql快速入门 1.1 什么是SparkSql Spark Sql is Spark’s module for working with strutured data. Spark Sql是Spark的模块，用于处理海量结构化数据 限量：结构化数据…
阅读更多...
Tomcat的类加载器

Tomcat的类加载器

详情可以参考：https://tomcat.apache.org/tomcat-10.1-doc/class-loader-howto.html 简要说明 Tomcat安装了多种类加载器，以便容器的不同部分、容器中的应用访问能够不同的类和资源。 在Java环境中，类加载器被组织为父-子树的形式。通常情况…
阅读更多...
文件包含漏洞培训

文件包含漏洞培训

CTF介绍 MISC(Miscellaneous)类型，即安全杂项，题目或涉及流量分析、电子取证、人肉搜索、数据分析等等。CRYPTO(Cryptography)类型，即密码学，题目考察各种加解密技术，包括古典加密技术、现代加密技术甚至出题者自创加密技术。PWN类型，PWN在黑客俚语中代表着攻破、取得权限…
阅读更多...
技术分享 | app自动化测试（Android）-- 属性获取与断言

技术分享 | app自动化测试（Android）-- 属性获取与断言

断言是 UI 自动化测试的三要素之一，是 UI 自动化不可或缺的部分。在使用定位器定位到元素后，通过脚本进行业务操作的交互，想要验证交互过程中的正确性就需要用到断言。 常规的UI自动化断言 分析正确的输出结果，常规的断言一般包…
阅读更多...
Qt实现动态桌面小精灵（含源码）

Qt实现动态桌面小精灵（含源码）

目录 一、设计思路 二、部分源码演示 三、源码地址 🌈write in front🌈 🧸大家好，我是三雷科技.希望你看完之后，能对你有所帮助，不足请指正！共同学习交流. 🆔本文由三雷科技原创 CSDN首发🐒 如需转载还请通知⚠️ 📝个人主页：三雷科技🧸—CSDN博客 🎁欢…
阅读更多...
Leetcode刷题详解——字母大小写全排列

Leetcode刷题详解——字母大小写全排列

1. 题目链接：784. 字母大小写全排列 2. 题目描述： 给定一个字符串 s ，通过将字符串 s 中的每个字母转变大小写，我们可以获得一个新的字符串。 返回 所有可能得到的字符串集合 。以 任意顺序 返回输出。 示例 1： 输入&…
阅读更多...
渲染管线详解

渲染管线详解

光栅化的渲染管线一般分为三大阶段：应用程序阶段->几何阶段->光栅化阶段 也可以四大阶段： 应用程序阶段->几何阶段->光栅化阶段->逐片元操作阶段 更详细的流程如下： Vertex Specification（顶点规范化&#xff09…
阅读更多...
刚接触银行新业务测试的一些问题

刚接触银行新业务测试的一些问题

在银行金融领域的测试工作，相信很多测试工程师都会遇到自己不熟悉的业务。然后开始看文档，问开发或者需求人员。搞懂了大概的流程，然后开始进行测试。 不过遇到复杂的业务情况时，真的很需要时间去梳理。而且测试环境的配置问题、不…
阅读更多...
【自然语言处理】基于python的问答系统实现

【自然语言处理】基于python的问答系统实现

一，文件准备 该问答系统是基于已知的问题和其一一对应的答案进行实现的。首先需要准备两个文本文件，分别命名为“question.txt”和“answer.txt”，分别是问题文件和答案文件，每一行是一个问题以及对应的答案。 问题文件: 中国的首…
阅读更多...
在群晖NAS上使用AudioStation实现本地音频公网共享

在群晖NAS上使用AudioStation实现本地音频公网共享

文章目录 1. 本教程使用环境：2. 制作音频分享链接3. 制作永久固定音频分享链接： 之前文章我详细介绍了如何在公网环境下使用pc和移动端访问群晖Audio Station： 公网访问群晖audiostation听歌 - cpolar 极点云 群晖套件不仅能读写本地文件&a…
阅读更多...
Spring Boot中配置多个数据源

Spring Boot中配置多个数据源

配置数据源实际上就是配置多个数据库，在一个配置文件中配置多个数据库，这样做主要的好处有以下几点： 数据库隔离：通过配置多个数据源，可以将不同的业务数据存储在不同的数据库中，实现数据的隔离。这样可以…
阅读更多...
安全易用的文件同步程序：Syncthing | 开源日报 No.70

安全易用的文件同步程序：Syncthing | 开源日报 No.70

syncthing/syncthing Stars: 55.0k License: MPL-2.0 Syncthing 是一个持续文件同步程序，它在两台或多台计算机之间同步文件。该项目的主要功能和核心优势包括： 安全防止数据丢失抵御攻击易于使用自动化操作，仅在必要时需要用户交互适合在各…
阅读更多...
Pytest系列（16）- 分布式测试插件之pytest-xdist的详细使用

Pytest系列（16）- 分布式测试插件之pytest-xdist的详细使用

前言 平常我们功能测试用例非常多时，比如有1千条用例，假设每个用例执行需要1分钟，如果单个测试人员执行需要1000分钟才能跑完当项目非常紧急时，会需要协调多个测试资源来把任务分成两部分，于是执行时间缩短一半&#…
阅读更多...
船舶数据采集与数据模块解决方案

船舶数据采集与数据模块解决方案

标准化信息处理单元原理样机初步方案： 1）系统组成 标准化信息处理单元原理样机包含硬件部分和软件部分。 硬件部分包括集成电路板、电源模块、主控模块、采集模块、信息处理模块、通讯模块、I/O模块等。 软件部分包括协议统一标准化模块、设备互联互…
阅读更多...
最新文章

Copyright @ 2022~2023