pytorch 入门 （四）案例二：人脸表情识别-VGG16实现

实战教案二：人脸表情识别-VGG16实现

本文为🔗小白入门Pytorch内部限免文章
参考本文所写记录性文章，请在文章开头注明以下内容，复制粘贴即可

  • 🍨 本文为🔗小白入门Pytorch中的学习记录博客
  • 🍦 参考文章：【小白入门Pytorch】人脸表情识别-VGG16实现
  • 🍖 原作者：K同学啊

数据集下载：
链接：https://pan.baidu.com/s/1RvlpOx8v6MudY65Oi78-kQ?pwd=zhfo
提取码：zhfo
–来自百度网盘超级会员V4的分享

目录

  • 实战教案二：人脸表情识别-VGG16实现
    • 一、导入数据
    • 二、VGG-16算法模型
      • 1. 优化器与损失函数
      • 2. 模型的训练
    • 三、可视化

一、导入数据

from torchvision.datasets   import CIFAR10 # CIFAR10是一个用于计算机视觉的经典数据集，其中包含60000张32x32的彩色图像，分为10个类别，每个类别有6000张图像。
from torchvision.transforms import transforms # 这是一个常用的模块，用于图像的预处理和增强。
from torch.utils.data       import DataLoader # 可以将数据集转化为迭代器的工具，方便在训练循环中加载数据。
from torchvision            import datasets # 导入了torchvision下的所有数据集，但实际上这与前面导入CIFAR10是重复的，可能是不必要的。
from torch.optim            import Adam # 导入了Adam优化器。Adam是一个常用的、表现良好的深度学习优化器。
import torchvision.models   as models # 这个模块提供了各种预训练模型，例如ResNet、VGG、DenseNet等。
import torch.nn.functional  as F # 提供了各种激活函数、损失函数和其他的功能函数。
import torch.nn             as nn # 这个模块提供了构建神经网络所需的各种工具，如层、损失函数等。
import torch,torchvision # torch是PyTorch的核心库，提供了基础的张量操作；torchvision则是与计算机视觉相关的库，提供了数据集、预处理方法和预训练模型。

train_datadir = '/home/mw/input/kzb324321357/2-Emotion_Images/2-Emotion_Images/train'
test_datadir  = '/home/mw/input/kzb324321357/2-Emotion_Images/2-Emotion_Images/test'

train_transforms = transforms.Compose([
    transforms.Resize([48, 48]),    # 将输入图片resize成统一尺寸
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406], 
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

test_transforms = transforms.Compose([
    transforms.Resize([48, 48]),    # 将输入图片resize成统一尺寸
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406], 
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

# 使用 datasets.ImageFolder 加载训练数据集和测试数据集
# ImageFolder假定所有的文件按文件夹保存，每个文件夹下存储同一个类别的图片，文件夹名为类别的名字。
# 同时，为加载的数据应用了之前定义的预处理流程。
train_data = datasets.ImageFolder(train_datadir, transform=train_transforms)
test_data = datasets.ImageFolder(test_datadir, transform=test_transforms)

⭐ torch.utils.data.DataLoader详解

torch.utils.data.DataLoader是Pytorch自带的一个数据加载器，结合了数据集和取样器，并且可以提供多个线程处理数据集。

函数原型：

torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=None, sampler=None, batch_sampler=None, num_workers=0, collate_fn=None, pin_memory=False, drop_last=False, timeout=0, worker_init_fn=None, multiprocessing_context=None, generator=None, *, prefetch_factor=2, persistent_workers=False, pin_memory_device=‘’)

参数说明：

  • dataset(string) ：加载的数据集
  • batch_size (int,optional) ：每批加载的样本大小（默认值：1）
  • shuffle(bool,optional) : 如果为True，每个epoch重新排列数据。
  • sampler (Sampler or iterable, optional) ： 定义从数据集中抽取样本的策略。 可以是任何实现了 len 的 Iterable。 如果指定，则不得指定 shuffle 。
  • batch_sampler (Sampler or iterable, optional) ： 类似于sampler，但一次返回一批索引。与 batch_size、shuffle、sampler 和 drop_last 互斥。
  • num_workers(int,optional) ： 用于数据加载的子进程数。 0 表示数据将在主进程中加载（默认值：0）。
  • pin_memory (bool,optional) : 如果为 True，数据加载器将在返回之前将张量复制到设备/CUDA 固定内存中。 如果数据元素是自定义类型，或者collate_fn返回一个自定义类型的批次。
  • drop_last(bool,optional) : 如果数据集大小不能被批次大小整除，则设置为 True 以删除最后一个不完整的批次。 如果 False 并且数据集的大小不能被批大小整除，则最后一批将保留。 （默认值：False）
  • timeout(numeric,optional) : 设置数据读取的超时时间 ， 超过这个时间还没读取到数据的话就会报错。（默认值：0）
  • worker_init_fn(callable,optional) ： 如果不是 None，这将在步长之后和数据加载之前在每个工作子进程上调用，并使用工作 id（[0，num_workers - 1] 中的一个 int）的顺序逐个导入。 （默认：None）
# 创建训练数据加载器（data loader），用于将数据分成小批次进行训练
train_loader = torch.utils.data.DataLoader(train_data,
                                           batch_size=16,      # 每个批次包含的图像数量
                                           shuffle=True,       # 随机打乱数据
                                           num_workers=4)      # 使用多少个子进程来加载数据

# 创建测试数据加载器（data loader），用于将测试数据分成小批次进行测试
test_loader = torch.utils.data.DataLoader(test_data,
                                          batch_size=16,      # 每个批次包含的图像数量
                                          shuffle=True,       # 随机打乱数据
                                          num_workers=4)      # 使用多少个子进程来加载数据

# 打印数据集的信息
# 请注意，这里使用len(train_loader) * 16来计算图像总数是基于批次大小为16的假设。
# 实际上，最后一个批次的图像数量可能少于16。
print("The number of images in a training set is: ", len(train_loader) * 16)  # 计算训练集中的图像总数
print("The number of images in a test set is: ", len(test_loader) * 16)      # 计算测试集中的图像总数
print("The number of batches per epoch is: ", len(train_loader))             # 计算每个 epoch 中的批次数

# 定义数据集的类别标签
classes = ('Angry', 'Fear', 'Happy', 'Surprise')

The number of images in a training set is:  18480
The number of images in a test set is:  2320
The number of batches per epoch is:  1155

二、VGG-16算法模型

device = "cuda" if torch.cuda.is_available() else "cpu"

print("Using {} device".format(device))

# 直接调用官方封装好的VGG16模型
model = models.vgg16(pretrained = True)
model

Using cuda device

​

Downloading: "https://download.pytorch.org/models/vgg16-397923af.pth" to /home/mw/.cache/torch/hub/checkpoints/vgg16-397923af.pth

​

HBox(children=(FloatProgress(value=0.0, max=553433881.0), HTML(value='')))

​

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)
  )
)

1. 优化器与损失函数

optimizer = Adam(model.parameters(),lr = 0.0001,weight_decay = 0.0001)
loss_model = nn.CrossEntropyLoss()

import torch
from torch.autograd import Variable
# 定义训练函数
def train(model,train_loader,loss_model,optimizer):
    # 将模型移动到指定设备（如：GPU）
    model = model.to(device)
    # 将模型设置为训练模式（启用梯度计算）
    model.train()

    for i,(images,labels) in enumerate(train_loader,0):
        # 将输入数据和标签移动到指定设备
        images = Variable(images.to(device))
        labels = Variable(labels.to(device))

        # 梯度清零
        optimizer.zero_grad()
        # 前向传播得到模型输出
        outputs = model(images)
        # 计算损失
        loss = loss_model(outputs,labels)
        # 反向传播
        loss.backward()
        # 更新模型参数
        optimizer.step()

        # 每隔1000个批次输出一次损失
        if i%1000 == 0:
            print('[%5d] loss: %.3f' % (i,loss))

# 定义测试函数
def test(model,test_loader,loss_model):
    # 获取测试数据集大小
    size = len(test_loader.dataset)
    # 获取测试数据批次数
    num_batches = len(test_loader)
    # 将模型设置为评估模式（不进行梯度计算）
    model.eval()

    test_loss,correct = 0,0

    # 在不计算梯度的上下文中执行测试
    with torch.no_grad():
        for X,y in test_loader:
            X,y = X.to(device),y.to(device)
            # 使用模型进行前向传播得到预测
            pred = model(X)
            # 计算损失值，并将其累积到test_loss中
            test_loss += loss_model(pred,y).item()
            # 计算正确预测的数量
            correct += (pred.argmax(1)==y).type(torch.float).sum().item()
    
    # 计算平均测试损失和准确率
    test_loss /= num_batches
    correct /= size
    print(f"Test Error:\n Accuracy:{(100*correct):>0.1f}%,Avg loss:{test_loss:>8f} \n")
    return correct,test_loss

提问：梯度清零有三种放置方法吗，放到循环最前面或者最后面，或者反向传播之前

是的，您理解得很准确。在PyTorch中，optimizer.zero_grad()的位置有一定的灵活性。以下是这三种常见的放置方法：

  1. 循环开始时：在每次迭代的最开始，即前向传播之前，清零梯度。
  2. 反向传播之前：在前向传播之后、反向传播之前，清零梯度。这也是您提供的代码中使用的方法。
  3. 循环结束时：在每次迭代的最后，即更新参数之后，清零梯度。

这三种方法在大多数情况下都是等效的，因为关键是确保在进行下一次反向传播之前梯度是清零的。

但是，如果您在一个迭代中进行多次反向传播（例如，当您想要累加梯度时），那么您必须在每次反向传播之前清零梯度。在这种特定情境中，第二种方法（反向传播之前）是最合适的。

对于大多数常规的训练循环，选择哪种方法主要是根据个人偏好或代码的可读性来决定的。

2. 模型的训练

# 创建一个空列表用于存储每个epoch的测试集准确率
test_acc_list = []
# 定义训练的总论数
epochs = 10

# 开始训练循环，每个epoch 都会执行一下操作
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")

    # 在训练数据上训练模型
    train(model,train_loader,loss_model,optimizer)

    # 在测试数据集上测试模型的性能，并获取测试准确率和测试损失
    test_acc,test_loss = test(model,test_loader,loss_model)
    
    # 将测试准确率添加到列表中，以便后续分析
    test_acc_list.append(test_acc)

# 所有epoch完成后打印完成消息
print("Done!")

Epoch 1
-------------------------------
[    0] loss: 0.129
[ 1000] loss: 0.005
Test Error:
 Accuracy:77.4%,Avg loss:1.069592 

Epoch 2
-------------------------------
[    0] loss: 0.028
[ 1000] loss: 0.055
Test Error:
 Accuracy:78.7%,Avg loss:0.976879 

Epoch 3
-------------------------------
[    0] loss: 0.033
[ 1000] loss: 0.050
Test Error:
 Accuracy:77.9%,Avg loss:1.202651 

Epoch 4
-------------------------------
[    0] loss: 0.051
[ 1000] loss: 0.356
Test Error:
 Accuracy:79.0%,Avg loss:1.080943 

Epoch 5
-------------------------------
[    0] loss: 0.001
[ 1000] loss: 0.183
Test Error:
 Accuracy:78.7%,Avg loss:1.248081 

Epoch 6
-------------------------------
[    0] loss: 0.003
[ 1000] loss: 0.127
Test Error:
 Accuracy:78.4%,Avg loss:1.129110 

Epoch 7
-------------------------------
[    0] loss: 0.003
[ 1000] loss: 0.076
Test Error:
 Accuracy:77.6%,Avg loss:1.200314 

Epoch 8
-------------------------------
[    0] loss: 0.042
[ 1000] loss: 0.071
Test Error:
 Accuracy:78.0%,Avg loss:1.149877 

Epoch 9
-------------------------------
[    0] loss: 0.002
[ 1000] loss: 0.212
Test Error:
 Accuracy:78.0%,Avg loss:1.353625 

Epoch 10
-------------------------------
[    0] loss: 0.001
[ 1000] loss: 0.001
Test Error:
 Accuracy:78.5%,Avg loss:1.249242 

Done!

test_acc_list

[0.773552290406223,
 0.7869490060501296,
 0.7791702679343129,
 0.7904062229904927,
 0.7869490060501296,
 0.783923941227312,
 0.7757130509939498,
 0.780466724286949,
 0.780466724286949,
 0.7852203975799481]

三、可视化

import numpy as np
import matplotlib.pyplot as plt

x = [i for i in range(1,11)]

plt.plot(x,test_acc_list,label="line ACC",alpha = 0.8)

plt.xlabel("epoch")
plt.ylabel("acc")

plt.legend()
plt.show()

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

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

相关文章

ruoyi-nbcio版本从RuoYi-Flowable-Plus迁移过程记录

ruoyi-nbcio版本从RuoYi-Flowable-Plus迁移过程记录

更多ruoyi-nbcio功能请看演示系统 gitee源代码地址 前后端代码： https://gitee.com/nbacheng/ruoyi-nbcio 演示地址：RuoYi-Nbcio后台管理系统 从KonBAI / RuoYi-Flowable-Plus 项目移植过来，开始用yarn install之后yarn run dev 还是有问…
阅读更多...
腾讯云价格计算器有用过的吗？好用！

腾讯云价格计算器有用过的吗？好用！

腾讯云服务器价格计算器可以一键计算出云服务器的精准报价，包括CVM实例规格价格、CPU内存费用、公网带宽收费、存储系统盘和数据盘详细费用，腾讯云百科txybk.com分享腾讯云价格计算器链接入口、使用方法说明： 腾讯云服务器价格计算器 打开腾…
阅读更多...
Java八股文 ---Java并发篇

Java八股文 ---Java并发篇

线程安全 线程安全就是多个线程去执行某类，这个类始终能表现出正确的行为，那么这个类就是线程安全的 我们判断是否要处理线程安全问题，就看有没有多个线程同时访问一个共享变量 能不能保证操作的原子性，考虑atomic包下的类够不够我…
阅读更多...
Kubernetes技术与架构-网络 3

Kubernetes技术与架构-网络 3

Kubernetes集群支持为Pod或者Service申请IPV4或者IPV6的地址空间。 kube-apiserver --service-cluster-ip-range<IPv4 CIDR>,<IPv6 CIDR> kube-controller-manager --cluster-cidr<IPv4 CIDR>,<IPv6 CIDR> --service-cluster-ip-range<IPv4 CI…
阅读更多...
架构风格区别-架构案例（五十九）

架构风格区别-架构案例（五十九）

管道-过滤器和仓库的区别&#xff1f; 独立的数据仓库&#xff0c;处理流独立&#xff0c;处理数据用连接仓库工具数据与处理在一起&#xff0c;改动的话需要重启系统需要仓库工具与仓库连接&#xff0c;数据与处理分离&#xff0c;性能差可以支持并发连接访问仓库&#xff0c…
阅读更多...
MSQL系列(八) Mysql实战-SQL存储引擎

MSQL系列(八) Mysql实战-SQL存储引擎

Mysql实战-SQL存储引擎 前面我们讲解了索引的存储结构&#xff0c;BTree的索引结构&#xff0c;我们一般都知道Mysql的存储引擎有两种&#xff0c;MyISAM和InnoDB,今天我们来详细讲解下Mysql的存储引擎 文章目录 Mysql实战-SQL存储引擎1.存储引擎2.MyISAM的特点3. InnoDB的特…
阅读更多...
基于单片机设计的防煤气泄漏装置

基于单片机设计的防煤气泄漏装置

一、前言 煤气泄漏是一个严重的安全隐患&#xff0c;可能导致火灾、爆炸以及对人体健康的威胁。为了提高家庭和工业环境中煤气泄漏的检测和预防能力&#xff0c;设计了一种基于单片机的防煤气泄漏装置。 单片机选择STC89C52作为主控芯片。为了检测煤气泄漏&#xff0c;采用了…
阅读更多...
kuaishou web端did注册激活 学习记录

kuaishou web端did注册激活 学习记录

快手web端 did 注册激活的流程大概如下&#xff1a; 1.访问web端的接口&#xff0c;主动触发滑块&#xff0c;拿到滑块信息 2.然后滑块验证did 获取captchaToken 3.携带captchaToken访问接口 4.最后校验web端的did 是否激活 最后激活以后的效果如下&#xff1a; 经过测试&…
阅读更多...
我是这样保持精力充沛的

我是这样保持精力充沛的

精力管理就好比是计算机的内存清理&#xff0c;你以为关掉一些程序就行了&#xff0c;结果你还是卡成翔。 我的现状 雷猴啊&#xff0c;我是一个临期程序员。打过几年工&#xff0c;被好几个同事问过我为什么精力这么旺盛。 这两年我大多数情况都是早上8点前就到公司*(原本9点上…
阅读更多...
摄影测量编码点源文件

摄影测量编码点源文件

源文件下载链接。
阅读更多...
《红蓝攻防对抗实战》三.内网探测协议出网之HTTP/HTTPS协议探测出网

《红蓝攻防对抗实战》三.内网探测协议出网之HTTP/HTTPS协议探测出网

目录 一. 在 Windows 操作系统中探测 HTTP/HTTPS 出网 1. Bitsadmin 命令 2.Certuil 命令 2.Linux系统探测HTTP/HTTPS出网 1.Curl命令 2.Wget命令 对目标服务器探测 HTTP/HTTPS 是否出网时&#xff0c;要根据目标系统类型执行命令&#xff0c;不同类型的操作系统使用的探…
阅读更多...
一文说尽零售数据分析指标体系

一文说尽零售数据分析指标体系

零售的本质业务模式是通过在各种渠道上吸引客户来购买我们的商品来实现盈利&#xff0c;其实就是客户-渠道-商品&#xff0c;也就是我们常说的“人、场、货”&#xff0c;除此之外还有供应链、财务等起到重要的辅助作用。因此如果要构建起系统化的零售数据分析指标体系&#xf…
阅读更多...
单片机设计基于STM32的空气净化器设计

单片机设计基于STM32的空气净化器设计

**单片机设计介绍&#xff0c;1615[毕设课设]基于STM32的空气净化器设计 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图pcb设计图 五、 程序六、 文章目录 一 概要 此设计资料主要包含原理图、PCB、源程序、元器件清等资料&#xff0c; 二、功能设计 设计思路 …
阅读更多...
[AutoSAR系列] 1.3 AutoSar 架构

[AutoSAR系列] 1.3 AutoSar 架构

依AutoSAR及经验辛苦整理&#xff0c;原创保护&#xff0c;禁止转载。 专栏 《深入浅出AutoSAR》 1. 整体架构 ​ 图片来源&#xff1a; AutoSar 官网 从官往图中可以看出autosar作为汽车ECU软件架构&#xff0c;是通过分层来实现软硬件隔离。就像大多数操作系统一样&#xff…
阅读更多...
深度学习_5_模型拟合_梯度下降原理

深度学习_5_模型拟合_梯度下降原理

需求: 想要找到一条直线&#xff0c;能更好的拟合这一些点 如何确定上述直线就是最优解呢&#xff1f; 由计算机算出所有点与我们拟合直线的误差&#xff0c;常见的是均方误差 例如&#xff1a;P1与直线之间的误差为e1 将P1坐标带入直线并求误差得&#xff1a; 推广到所有点&a…
阅读更多...
Pico示波器 汽车振动异响(NVH)解决方案

Pico示波器 汽车振动异响(NVH)解决方案

汽车振动异响故障可能有多个潜在原因&#xff0c;包括发动机、传动系统、悬挂系统、制动系统等等。技师需要对汽车各个方面有全面的了解&#xff0c;才能更好地进行故障排查。 振动和异响可能由多个因素引起。例如&#xff0c;可能是零部件损坏、松脱、磨损或者不正确安装。这…
阅读更多...
某全球领先的晶圆代工企业：替代FTP实现大规模文件的高效传输

某全球领先的晶圆代工企业：替代FTP实现大规模文件的高效传输

全球领先的集成电路晶圆代工企业之一 该企业不仅是全球领先的集成电路晶圆代工企业之一&#xff0c;也是中国内地技术最先进、配套最完善、规模最大、跨国经营的集成电路制造企业集团。主要业务是根据客户本身或第三者的集成电路设计&#xff0c;为客户制造集成电路芯片&#…
阅读更多...
Opencv-图像插值与LUT查找表

Opencv-图像插值与LUT查找表

图像像素的比较 白色是255&#xff0c;黑色是0 min(InputArray src1,InputArray src2,OutputArray dst) max(InputArray src1,InputArray src2,OutpurArray dstsrc1:第一个图像矩阵&#xff0c;通道数任意src2&#xff1a;第二个图像矩阵&#xff0c;尺寸和通道数以及数据类型…
阅读更多...
面试题：Java 类加载过程是怎么样的？

面试题：Java 类加载过程是怎么样的？

首先&#xff0c;我们编写好的Java代码&#xff0c;经过编译变成.class文件&#xff0c;然后类加载器把.class字节码文件加载到JVM中&#xff0c;接着执行我们的代码&#xff0c;最后将类卸载出JVM。而从类加载到虚拟机到卸载出虚拟机的这一整个生命周期总共可以分为7个步骤&am…
阅读更多...
亚马逊注册账号时老是显示内部错误

亚马逊注册账号时老是显示内部错误

最近你们是否遇到注册亚马逊账号时一直遇到"内部错误"的情况&#xff1f;&#xff0c;这可能是由多种原因引起的。以下是一些可能有助于解决这个问题的步骤&#xff1a; 1、清除缓存和Cookie&#xff1a;有时浏览器缓存和Cookie中的问题可能导致网站错误。可以试试清…
阅读更多...
最新文章

Copyright @ 2022~2023