P6 VGG-16算法-Pytorch实现人脸识别

最新推荐文章于 2025-07-03 20:20:19 发布
原创 最新推荐文章于 2025-07-03 20:20:19 发布 · 849 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#pytorch #人工智能

部署运行你感兴趣的模型镜像

一、前期准备

1.设置GPU

import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms,datasets
import os,PIL,pathlib,warnings

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

device(type=‘cuda’)

2.导入数据

import os,PIL,random,pathlib

data_dir = r'D:\z_temp\data\48-data\48-data'
data_dir = pathlib.Path(data_dir)

data_paths = list(data_dir.glob('*'))
classNames = [str(path).split('\\')[5] for path in data_paths]
classNames

[‘Angelina Jolie’,
‘Brad Pitt’,
‘Denzel Washington’,
‘Hugh Jackman’,
‘Jennifer Lawrence’,
‘Johnny Depp’,
‘Kate Winslet’,
‘Leonardo DiCaprio’,
‘Megan Fox’,
‘Natalie Portman’,
‘Nicole Kidman’,
‘Robert Downey Jr’,
‘Sandra Bullock’,
‘Scarlett Johansson’,
‘Tom Cruise’,
‘Tom Hanks’,
‘Will Smith’]

train_transforms = transforms.Compose([
    transforms.Resize([224,224]),
    transforms.ToTensor(),
    transforms.Normalize(
        mean =[0.485,0.456,0.406],
        std = [0.229,0.224,0.225])
])

total_data = datasets.ImageFolder(r'D:\z_temp\data\48-data\48-data',transform = train_transforms)
total_data

Dataset ImageFolder
Number of datapoints: 1800
Root location: D:\z_temp\data\48-data\48-data
StandardTransform
Transform: Compose(
Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=True)
ToTensor()
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
)

total_data.class_to_idx

{‘Angelina Jolie’: 0,
‘Brad Pitt’: 1,
‘Denzel Washington’: 2,
‘Hugh Jackman’: 3,
‘Jennifer Lawrence’: 4,
‘Johnny Depp’: 5,
‘Kate Winslet’: 6,
‘Leonardo DiCaprio’: 7,
‘Megan Fox’: 8,
‘Natalie Portman’: 9,
‘Nicole Kidman’: 10,
‘Robert Downey Jr’: 11,
‘Sandra Bullock’: 12,
‘Scarlett Johansson’: 13,
‘Tom Cruise’: 14,
‘Tom Hanks’: 15,
‘Will Smith’: 16}

3.划分数据集

train_size = int(0.8*len(total_data))
test_size = len(total_data)-train_size
train_dataset,test_dataset = torch.utils.data.random_split(total_data,[train_size,test_size])
train_dataset,test_dataset

(<torch.utils.data.dataset.Subset at 0x1e38d321490>,
<torch.utils.data.dataset.Subset at 0x1e38d3217c0>)

batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                      batch_size = batch_size,
                                      shuffle = True,
                                      num_workers = 1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                     batch_size = batch_size,
                                     shuffle = True,
                                     num_workers = 1)


for X,y in test_dl:
    print("Shape of X [N,C,H,W:]",X.shape)
    print("Shape of y:",y.shape,y.dtype)
    break

Shape of X [N,C,H,W:] torch.Size([32, 3, 224, 224])
Shape of y: torch.Size([32]) torch.int64

二、调用官方VGG-16模型

from torchvision.models import vgg16
device = "cuda" if torch.cuda.is_available() else "cpu"
print("Using {} device".format(device))

from torchvision.models import vgg16
device = “cuda” if torch.cuda.is_available() else “cpu”
print(“Using {} device”.format(device))

model = vgg16(pretrained = True).to(device)

for param in model.parameters():
    param.requires_grad = False
    
model.classifier._modules['6']= nn.Linear(4096,len(classNames))
model.to(device)
model

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=17, bias=True)
)
)

三、训练模型

1.编写训练函数

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    
    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)
        
        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新
        
        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()
            
    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss

2.编写测试函数

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小
    num_batches = len(dataloader)          # 批次数目, (size/batch_size，向上取整)
    test_loss, test_acc = 0, 0
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            
            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)
            
            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

3.设置动态学习率

learn_rate = 1e-4 # 初始学习率
# 调用官方动态学习率接口时使用
lambda1 = lambda epoch: 0.92 ** (epoch // 4)
optimizer = torch.optim.SGD(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1) #选定调整方法

4.正式训练

import copy

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
epochs     = 40

train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

best_acc = 0    # 设置一个最佳准确率，作为最佳模型的判别指标

for epoch in range(epochs):
    # 更新学习率（使用自定义学习率时使用）
    # adjust_learning_rate(optimizer, epoch, learn_rate)
    
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)
    scheduler.step() # 更新学习率（调用官方动态学习率接口时使用）
    
    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    
    # 保存最佳模型到 best_model
    if epoch_test_acc > best_acc:
        best_acc   = epoch_test_acc
        best_model = copy.deepcopy(model)
    
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    # 获取当前的学习率
    lr = optimizer.state_dict()['param_groups'][0]['lr']
    
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, 
                          epoch_test_acc*100, epoch_test_loss, lr))

Epoch: 1, Train_acc:7.6%, Train_loss:2.899, Test_acc:11.1%, Test_loss:2.811, Lr:1.00E-04
Epoch: 2, Train_acc:8.3%, Train_loss:2.853, Test_acc:12.5%, Test_loss:2.789, Lr:1.00E-04
Epoch: 3, Train_acc:8.1%, Train_loss:2.843, Test_acc:14.2%, Test_loss:2.757, Lr:1.00E-04
Epoch: 4, Train_acc:11.0%, Train_loss:2.788, Test_acc:16.1%, Test_loss:2.723, Lr:9.20E-05
Epoch: 5, Train_acc:11.9%, Train_loss:2.775, Test_acc:16.1%, Test_loss:2.707, Lr:9.20E-05
Epoch: 6, Train_acc:11.7%, Train_loss:2.748, Test_acc:16.1%, Test_loss:2.687, Lr:9.20E-05
Epoch: 7, Train_acc:13.2%, Train_loss:2.734, Test_acc:16.4%, Test_loss:2.653, Lr:9.20E-05
Epoch: 8, Train_acc:13.5%, Train_loss:2.703, Test_acc:16.7%, Test_loss:2.661, Lr:8.46E-05
Epoch: 9, Train_acc:14.7%, Train_loss:2.698, Test_acc:16.7%, Test_loss:2.655, Lr:8.46E-05
Epoch:10, Train_acc:15.6%, Train_loss:2.681, Test_acc:15.3%, Test_loss:2.621, Lr:8.46E-05
Epoch:11, Train_acc:15.4%, Train_loss:2.654, Test_acc:15.6%, Test_loss:2.613, Lr:8.46E-05
Epoch:12, Train_acc:14.5%, Train_loss:2.664, Test_acc:16.1%, Test_loss:2.604, Lr:7.79E-05
Epoch:13, Train_acc:15.0%, Train_loss:2.647, Test_acc:16.1%, Test_loss:2.596, Lr:7.79E-05
Epoch:14, Train_acc:15.8%, Train_loss:2.622, Test_acc:16.4%, Test_loss:2.566, Lr:7.79E-05
Epoch:15, Train_acc:16.2%, Train_loss:2.609, Test_acc:16.9%, Test_loss:2.550, Lr:7.79E-05
Epoch:16, Train_acc:15.9%, Train_loss:2.605, Test_acc:16.9%, Test_loss:2.558, Lr:7.16E-05
Epoch:17, Train_acc:18.2%, Train_loss:2.585, Test_acc:17.2%, Test_loss:2.564, Lr:7.16E-05
Epoch:18, Train_acc:17.0%, Train_loss:2.571, Test_acc:16.9%, Test_loss:2.550, Lr:7.16E-05
Epoch:19, Train_acc:16.7%, Train_loss:2.576, Test_acc:16.7%, Test_loss:2.540, Lr:7.16E-05
Epoch:20, Train_acc:18.3%, Train_loss:2.571, Test_acc:16.7%, Test_loss:2.514, Lr:6.59E-05
Epoch:21, Train_acc:18.6%, Train_loss:2.539, Test_acc:16.7%, Test_loss:2.526, Lr:6.59E-05
Epoch:22, Train_acc:17.8%, Train_loss:2.565, Test_acc:16.9%, Test_loss:2.517, Lr:6.59E-05
Epoch:23, Train_acc:17.5%, Train_loss:2.536, Test_acc:16.9%, Test_loss:2.498, Lr:6.59E-05
Epoch:24, Train_acc:16.5%, Train_loss:2.531, Test_acc:16.7%, Test_loss:2.517, Lr:6.06E-05
Epoch:25, Train_acc:18.2%, Train_loss:2.517, Test_acc:16.7%, Test_loss:2.499, Lr:6.06E-05
Epoch:26, Train_acc:18.8%, Train_loss:2.489, Test_acc:16.7%, Test_loss:2.476, Lr:6.06E-05
Epoch:27, Train_acc:18.0%, Train_loss:2.509, Test_acc:16.9%, Test_loss:2.472, Lr:6.06E-05
Epoch:28, Train_acc:18.5%, Train_loss:2.499, Test_acc:16.9%, Test_loss:2.460, Lr:5.58E-05
Epoch:29, Train_acc:19.3%, Train_loss:2.490, Test_acc:17.2%, Test_loss:2.484, Lr:5.58E-05
Epoch:30, Train_acc:17.6%, Train_loss:2.509, Test_acc:17.2%, Test_loss:2.470, Lr:5.58E-05
Epoch:31, Train_acc:18.7%, Train_loss:2.481, Test_acc:17.2%, Test_loss:2.443, Lr:5.58E-05
Epoch:32, Train_acc:19.6%, Train_loss:2.475, Test_acc:17.2%, Test_loss:2.455, Lr:5.13E-05
Epoch:33, Train_acc:17.5%, Train_loss:2.477, Test_acc:17.2%, Test_loss:2.447, Lr:5.13E-05
Epoch:34, Train_acc:18.2%, Train_loss:2.472, Test_acc:17.5%, Test_loss:2.441, Lr:5.13E-05
Epoch:35, Train_acc:19.2%, Train_loss:2.470, Test_acc:17.8%, Test_loss:2.450, Lr:5.13E-05
Epoch:36, Train_acc:18.8%, Train_loss:2.457, Test_acc:18.1%, Test_loss:2.447, Lr:4.72E-05
Epoch:37, Train_acc:19.0%, Train_loss:2.461, Test_acc:18.3%, Test_loss:2.444, Lr:4.72E-05
Epoch:38, Train_acc:19.3%, Train_loss:2.436, Test_acc:18.3%, Test_loss:2.400, Lr:4.72E-05
Epoch:39, Train_acc:18.9%, Train_loss:2.436, Test_acc:18.3%, Test_loss:2.429, Lr:4.72E-05
Epoch:40, Train_acc:19.4%, Train_loss:2.438, Test_acc:18.6%, Test_loss:2.432, Lr:4.34E-05

# 保存最佳模型到文件中
PATH = r'D:\z_temp\data\P6_model.pth'  # 保存的参数文件名
torch.save(model.state_dict(), PATH)

print('Done')

四、结果可视化

1.lcc与acc图

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

from datetime import datetime
current_time = datetime.now() # 获取当前时间

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.xlabel(current_time) # 打卡请带上时间戳，否则代码截图无效

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

在这里插入图片描述

2.指定图片预测

from PIL import Image 

classes = list(total_data.class_to_idx)

def predict_one_image(image_path, model, transform, classes):
    
    test_img = Image.open(image_path).convert('RGB')
    plt.imshow(test_img)  # 展示预测的图片

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)
    
    model.eval()
    output = model(img)

    _,pred = torch.max(output,1)
    pred_class = classe![请添加图片描述](https://i-blog.csdnimg.cn/direct/6a346d33e94a41dabf62ce11e0649598.png)
s[pred]
    print(f'预测结果是：{pred_class}')

预测结果是：Scarlett Johansson

在这里插入图片描述

3.模型评估

best_model.eval()
epoch_test_acc, epoch_test_loss = test(test_dl, best_model, loss_fn)

epoch_test_acc, epoch_test_loss

(0.18611111111111112, 2.428501307964325)

# 查看是否与我们记录的最高准确率一致
epoch_test_acc

0.18611111111111112

您可能感兴趣的与本文相关的镜像

PyTorch 2.5

PyTorch 2.5

PyTorch
Cuda

PyTorch 是一个开源的 Python 机器学习库，基于 Torch 库，底层由 C++ 实现，应用于人工智能领域，如计算机视觉和自然语言处理

AMHSA
关注
Pytorch入门实战第六周：VGG-16算法-Pytorch实现人脸识别
weixin_46620278的博客
04-19 2015
🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客**🍖 原作者：[K同学啊](https://mtyjkh.blog.youkuaiyun.com/)说在前面本周学习目标：保存训练过程中的最佳模型权重，调用官方的VGG-16网络框架；拔高——使得测试集准确率达到60%(难度稍微有些大)，手动搭建VGG-16网络框架我的环境：Python3.8、Pycharm2020、torch1.12.1+cu113。
P6 Pytorch入门实战——VGG-16算法实现人脸识别
weixin_43934209的博客
10-11 758
VGG-16（Visual Geometry Group-16）是由牛津大学视觉几何组（Visual Geometry Group）提出的一种深度卷积神经网络架构，用于图像分类和对象识别任务。VGG-16在2014年被提出，是VGG系列中的一种。VGG-16之所以备受关注，是因为它在ImageNet图像识别竞赛中取得了很好的成绩，展示了其在大规模图像识别任务中的有效性。
pytorch_vgg16_classify.py
09-07
pytorch1.5实现的vgg16分类。在真实数据集测试成功 pytorch1.5实现的vgg16分类。在真实数据集测试成功 pytorch1.5实现的vgg16分类。在真实数据集测试成功
利用PyTorch实现VGG16教程
09-16
主要介绍了利用PyTorch实现VGG16教程，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
使用pytorch实现VGG16模型(小白学习,详细注释)
热门推荐
m0_50127633的博客
05-19 3万+
VGG16的模型 首先我们可以看到VGG一共有六个模型,每个模型根据卷积层和全连接层的层数进行分类,第二张图就是VGG16的基本模型. 代码实现 Vgg16Net.py from torch import nn class Vgg16_net(nn.Module): def __init__(self): super(Vgg16_net, self).__init__() self.layer1=nn.Sequential( nn.C
Pytorch：VGG16
weixin_42782833的博客
07-08 2064
import torch import torch.nn as nn import torch.nn.functional as F class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init__() #输入图片大小为：3 * 224 * 224 self.conv1_1 = nn.Conv2d(3, 64, 3) #
第P6周学习打卡：VGG-16算法-Pytorch实现人脸识别
最新发布
m0_45033896的博客
07-03 1021
在人脸识别任务中，深度卷积神经网络表现出色，尤其以 VGG-16 网络结构为代表。VGG-16 以其层次深、结构简单、迁移性强等优势，广泛应用于图像分类与特征提取任务中。本文基于 PyTorch 框架，构建并训练了一个基于 VGG-16 的人脸识别模型，通过数据加载、模型微调、训练优化等步骤，完成对人脸图像的分类与识别。本项目实现了基于 VGG-16 的人脸识别系统，利用 PyTorch 框架进行了完整的训练流程，包括数据预处理、模型加载与迁移学习、训练测试以及模型保存。
深度学习第P6周：VGG-16算法-Pytorch实现人脸识别
weixin_43414521的博客
07-12 2064
1、本周无意间安装上了GPU版本，跑起来确实速度提升十分明显。可能是放假导致网速提升的原因。2、学习了VGG16的总结结构及每一步的运行方式，在结果不满意的状态下修改了VGG16的全连接层及优化器，最后得出比较满意的结果。
P6-VGG16 Pytorch实现人脸识别
ur_Dear_Dad的博客
02-21 234
本节为打卡第六课，目的为使用VGG-16算法 Pytorch对人脸进行识别.
P6：使用pytorch实现人脸识别
apwpasy的博客
02-21 1630
更新学习率（使用自定义学习率时使用）scheduler.step() # 更新学习率（调用官方动态学习率接口时使用）# 保存最佳模型到 best_modelbest_model = copy.deepcopy(model) #这里保存的是最佳模型的深拷贝，如果 model 已经在 GPU 上，那么 best_model 也会在 GPU 上# 获取当前的学习率# 保存最佳模型到文件中PATH = './best_model.pth' # 保存的参数文件名修正后的代码如下。
VGG16-PyTorch-master.zip
08-20
Vgg16分类源码
Pytorch使用VGG16模型进行预测猫狗二分类
qq_43649937的博客
07-31 4652
pytorch python
pytorch实现VGG16 (2)
m0_50127633的博客
05-19 1887
VGG16Net.py from torch import nn class Vgg16_net(nn.Module): def __init__(self): super(Vgg16_net, self).__init__() self.layer1=nn.Sequential( nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,stride=1,padding=1), #(32
【使用Pytorch实现VGG16网络模型】
vcsir的专栏
07-30 7922
VGG-Network是K.Simonyan和A.Zisserman在论文“VeryDeepConvolutionalNetworksforLarge-ScaleImageRecognition”中提出的卷积神经网络模型。该架构在ImageNet中实现了92.7%的top-5测试准确率，该网络拥有超过1400万张属于1000个类别的图像。•模型的输入是固定大小的224×224224×224RGB图像•预处理是从每个像素中减去训练集RGB值的平均值。......
VGG16网络结构复现（Pytorch版）
YOLOv8项目贡献者
06-01 1045
VGG16 Pytorch复现
pytorch——使用VGG-16实现cifar-10多分类，准确率90.97%
qq_28383747的博客
12-02 2万+
刚入门卷积神经网络，在cifar-10数据集上复现了LeNet、AlexNet和VGG-16网络，发现VGG-16网络分类准确率最高，之后以VGG-16网络为基础疯狂调参，最终达到了90.97%的准确率。（继续进行玄学调参，可以更高）二、VGG-16网络介绍VGG-16论文该模型在2014年的ILSVRC中取得了分类任务第二、定位任务第一的优异成绩。VGG网络架构。
vgg16-pytorch
qq_51014805的博客
07-10 1568
在第一个池化这里，图片长宽都缩小二倍，当池化核为2x2时，取最显著的一个特征可达到这个标准，因此池化核为2，输入长和宽为224，输出长和宽为112，计算池化的步长。刚听完土哥的入门pytorch，试着写一个不完善的vgg16。
PyTorch：VGG16网络模型
己亥谷雨
02-08 582
深度学习界的小学生一枚 从头开始，先了解一下VGG16，哈哈哈 VGG16的结构图随便百度一下就好 import torch.nn as nn from torchsummary import summary import torch class VGG16(nn.Module): def __init__(self): super(VGG16, self).__init__() self.maxpool1 = nn.Sequential(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值