devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于VGG-Face的年龄估计（论文总结与代码解释）_vggface

作者：小丑西瓜9 | 2024-06-17 05:53:52

赞

踩

vggface

目录

1.本文改进

2.模型结构

3.训练模型

4.预测数据

5.实验结果

6.模型比较

7.结论分析 

8.数据集分析 

9.完整代码 

1.本文改进

本文主要是使用VGG-Face模型（卷积层不变，改变全连接层）在Adience数据库上进行年龄估计。

在深度神经网络中，由于深度神经网络有数百万个参数，由于它们有若干层和数千个节点，因此过拟合问题变得更加严重。所有用于年龄分类和预测的数据库都相对较小。它们在大小上无法与其他用于人脸识别和图像分类任务的数据库相提并论。为了克服过度拟合的问题，我们通过使用在一个非常大的数据库上训练的人脸识别深度CNN模型来构建我们提出的用于年龄估计的深度CNN。 

2.模型结构

       有一些CNN模型被成功地训练用于人脸识别任务。在这篇论文中，使用在2015年提出的VGG-face模型，该模型在LFW]和YFT数据库上取得了最先进的结果。VGG-Face由11个层、8个卷积层和3个全连接层组成。如下图所示，每个卷积层后面都有一个整流层（ReLU函数），在每个卷积块的末端运行一个max pool层。 

 VGG-Face模型在2015年的Deep Face Recognition论文中已提出，本文就是使用该模型进行年龄估计。VGG-Face模型如下：

本文保持VGG- Face模型的卷积层不变，在前两个Conv的relu函数之后添加BatchNorm2d进行数据的归一化处理，这使得数据在进行Relu之前不会因为数据过大而导致网络性能的不稳定。 同时用四个新的全连接层替换全连接层，构建并重新训练VGG- Face模型用于年龄估计。 前三个全连接层之后是dropout=0.5层和relu层。 第一全连接层尺寸为4096，第二、第三全连接层尺寸为5000。 最后一个全连接层表示一个N-way类预测器，其中N表示数据库中标签(类)的数量，该模型输出层的输出大小表示年龄标签的数量为8。

注：为什么全连接层的类型也属于卷积层？因为全连接层是卷积层的一种特殊情况，其中过滤器的大小和输入数据是相同的。 卷积层可以通过改变卷积基转变为全连接层。 

下面是使用pytorch实现模型结构：

卷积层：

  1. def cnn_layers(in_channels, batch_norm=False):  # 卷积层不变，不使用归一化处理
  2.     # fmt: off
  3.     config = [  # 卷积层布局
  4.         64, 64, "M",  # 卷积、卷积、池化、
  5.         128, 128, "M",  # 卷积、卷积、池化、
  6.         256, 256, 256, "M",  # 卷积、卷积、卷积、池化、
  7.         512, 512, 512, "M",  # 卷积、卷积、卷积、池化、
  8.         512, 512, 512, "M"  # 卷积、卷积、卷积、池化、
  9.     ]  # 总共5个卷积层
  10.  
  11.     layers = []  # 创建一个存放层的空列表
  12.  
  13.     for v in config:
  14.  
  15.         # maxpool
  16.         if v == "M":  # 添加池化层
  17.             layers += [nn.MaxPool2d(kernel_size=2, stride=2)]  # 2*2大小的窗口，步幅为2
  18.  
  19.         # conv2d layers
  20.         else:  # 否则继续添加卷积层
  21.             conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)  # 卷积层3*3
  22.             #  在前两个卷积层relu函数后面添加归一化处理
  23.             if batch_norm:
  24.                 layers += [
  25.                     conv2d,
  26.                     nn.BatchNorm2d(v),
  27.                     nn.ReLU(inplace=True),
  28.                 ]
  29.             else:
  30.                 layers += [conv2d, nn.ReLU(inplace=True)]  # 添加激活函数
  31.  
  32.             # update in_channels
  33.             in_channels = v
  34.  
  35.     return nn.Sequential(*layers)
  36. # *作用在形参上，代表这个位置接收任意多个非关键字参数，转化成元组方式；*作用在实参上，代表的是将输入迭代器拆成一个个元素。

 全连接层：

  1. def fc_layers(num_classes):
  2.     # fully connected layers of vgg
  3.  
  4.     return nn.Sequential(
  5.         nn.Linear(512 * 7 * 7, 512),
  6.         nn.ReLU(True),
  7.         nn.Dropout(),
  8.         nn.Linear(512, 512),
  9.         nn.ReLU(True),
  10.         nn.Dropout(),
  11.         nn.Linear(512, num_classes),
  12.     )

VGG16：

然后我们创建一个VGG16模型的类，全连接层和卷积层是必须要放入这个类中的，但是由于代码行数比较多，我们单独定义函数，再在类中调用。

  1. class vgg16(nn.Module):  # nn.Module是nn中十分重要的类，包含网络各层的定义及forward方法
  2.     def __init__(self, num_classes, channels=3):
  3.         # __init__还是有个特殊之处，那就是它不允许有返回值
  4.         # 一般把网络中具有可学习参数的层放在构造函数__init__()中。
  5.         # 不具有可学习参数的层（如ReLU）可放在构造函数中
  6.         
  7.  
  8.         # vgg16 module
  9.         # 
  10.         # parameters -------------------------
  11.         # - num_classes   -   number of outputs to predict要预测的输出数量
  12.         # - channels      -   number of input channels (eg. RGB:3)
  13.         
  14.  
  15.         # inheriting from module class
  16.         # 从模块类继承
  17.         super(vgg16, self).__init__()  # 这是对继承自父类的属性进行初始化
  18.  
  19.         # metadata
  20.         self.name = "vgg16"
  21.         self.num_classes = num_classes  # 左边为示例属性，右边的是_init_的参数
  22.  
  23.         # layers
  24.         self.features = cnn_layers(channels)  # 调用卷积层
  25.         self.classifier = fc_layers(num_classes) # 调用全连接层
  26.  
  27.         self.init_weights()  # 权重初始化
  28.  
  29.         # transfer to gpu if cuda found
  30.         if torch.cuda.is_available():
  31.             self.cuda()
  32.  
  33.     def forward(self, x):
  34.         x = self.features(x)
  35.         # input首先经过self.features(x)卷积层，此时的输出x是包含batchsize维度为4的tensor，
  36.         # 即(batchsize，channels，x，y)，x.size(0)指batchsize的值。
  37.  
  38.         x = x.view(x.size(0), -1)
  39.         # 将前面多维度的tensor展平成一维，简化x = x.view(batchsize, -1)
  40.         # 其中batchsize指转换后有几行，而-1指在不告诉函数有多少列的情况下，根据原tensor数据和batchsize自动分配列数。
  41.         # 其实相当于x = torch.flatten(x, 1)。四维[n,c,h,w]转换成二维[n,c*h*w]
  42.         x = self.classifier(x)  # 分类器
  43.  
  44.         return x
  45.  
  46.     def memory_usage(self):
  47.         
  48.         # Get the total parameters of the model获取模型的总参数
  49.        
  50.  
  51.         def multiply_iter(iterable):
  52.             res = 1
  53.             for x in iterable:
  54.                 res *= x
  55.             return res
  56.  
  57.         def add_params(parameter):
  58.             res = 0
  59.             for x in parameter:
  60.                 res += multiply_iter(x.shape)
  61.             return res
  62.  
  63.         feat = add_params(self.features.parameters())  # 卷积层的参数
  64.         clsf = add_params(self.classifier.parameters())  # 全连接层的参数
  65.         total = feat + clsf  # 总参数
  66.  
  67.         mb_f = 4 / 1024 ** 2
  68.  
  69.         print("Conv   : {0}".format(feat))
  70.         print("FC     : {0}".format(clsf))
  71.         print("-----------------")
  72.         print("Total  : {0}".format(total))
  73.         print("Memory : {0:.2f}MB".format(total * mb_f))
  74.         print("")
  75.  
  76.        def init_weights(self):  # 权重初始化
  77.  
  78.         for m in self.modules():
  79.             # 来判断一个对象是否是一个已知的类型，类似type()
  80.             # isinstance(object, classinfo) object -- 实例对象。
  81.             # classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
  82.             if isinstance(m, nn.Conv2d):  # 判断m是否为卷积层
  83.                 nn.init.kaiming_normal_(
  84.                     m.weight, mode="fan_out", nonlinearity="relu"
  85.                 )
  86.                 if m.bias is not None:
  87.                     nn.init.constant_(m.bias, 0)
  88.             # tensor – n 维 torch.Tensor
  89.             # a – 该层后面一层的整流函数中负的斜率 (默认为 0，此时为 Relu)
  90.             # mode – ‘fan_in’ (default) 或者 ‘fan_out’。使用fan_in保持weights的方差在前向传播中不变；使用fan_out保持weights的方差在反向传播中不变。
  91.             # nonlinearity – 非线性函数 (nn.functional 中的名字)，推荐只使用 ‘relu’ 或 ‘leaky_relu’ (default)
  92.  
  93.  
  94.             elif isinstance(m, nn.BatchNorm2d):
  95.                 nn.init.constant_(m.weight, 1)  # 用值1填充m.weight
  96.                 nn.init.constant_(m.bias, 0)  # 用值0填充m.bias
  97.  
  98.             elif isinstance(m, nn.Linear):
  99.                 nn.init.normal_(m.weight, 0, 0.01)  # torch.nn.init.normal_(tensor, mean=0.0, std=1.0)
  100.                 # N(mean, std^2) 用正态分布的值填充m.weight
  101.                 nn.init.constant_(m.bias, 0)
  102.     def load_weights(self, saved_dict, ignore_keys=[]):
  103.  
  104.         # indexable ordered dict
  105.         state_dict = self.state_dict()
  106.         saved_dict = list(saved_dict.items())
  107.  
  108.         # update state_dict where pretrained dict is similar
  109.         for i, (key, val) in enumerate(state_dict.items()):
  110.  
  111.             space = " " * (25 - len(str(key))) + " "
  112.             n_val = saved_dict[i][1]
  113.  
  114.             if (
  115.                 key not in ignore_keys
  116.                 and val.shape == n_val.shape
  117.             ):
  118.                 state_dict[key] = n_val
  119.                 print("   " + str(key) + space + "Loaded")
  120.  
  121.             else:
  122.                 print("   " + str(key) + space + "Ignored")
  123.  
  124.         self.load_state_dict(state_dict)
  125.  
  126.     def freeze_cnn_layers(self, except_last=0):
  127.  
  128.         num_params = len(list(self.features.parameters()))  # 卷积层总的参数个数
  129.         state_keys = [key for key in self.features.state_dict()]
  130.         """
  131.         pytorch 中的 state_dict 是一个简单的python的字典对象,将每一层与它的对应参数建立映射关 
  132.         系.(如model的每一层的weights及偏置等等)
  133.         (注意,只有那些参数可以训练的layer才会被保存到模型的state_dict中,如卷积层,线性层等等)
  134.         优化器对象Optimizer也有一个state_dict,它包含了优化器的状态以及被使用的超参数(如lr, 
  135.         momentum,weight_decay等)
  136.         """
  137.         for i, param in enumerate(self.features.parameters()):  # 把所有参数自动编号
  138.  
  139.             key = state_keys[i]
  140.             space = " " * (25 - len(str(key))) + " "
  141.  
  142.             if num_params - i > except_last:
  143.                 param.requires_grad = False  # 卷积层
  144.                 print("   " + str(key) + space + "Frozen")
  145.  
  146.             else:
  147.                 param.requires_grad = True  # 全连接层
  148.                 print("   " + str(key) + space + "Active")

3.训练模型

       输入图像被缩放到256 x 256像素，然后随机裁剪成224 x 224像素的小块。 采用随机梯度下降法对网络进行优化，最小批数为256，动量值为0.9。 此外，权重衰减设置为10-3。 在训练过程中，使用0.6的dropout rate对网络参数进行正则化。 训练以0.1的学习率开始，然后当验证集的准确性结果没有改善时，学习率降低10倍。 新添加的全连接层之间的权值采用均值为零、标准差为10-2的高斯分布初始化，而偏差初始化为零。

       RGB输入图像被馈送到网络的输入层。 然后将每一隐藏层的输出作为输入馈送到下一隐藏层，直到计算出网络输出层(最后一层)的概率。   随机梯度象限法优化并找到连接层的参数，使用于估计年龄的softmax-log-loss预测最小化。 同时，卷积层的参数保持不变。 换句话说，我们优化了全连接层的参数来预测被试的年龄，而不改变卷积层的参数，卷积层是为人脸识别任务而训练和优化的。

  1. import numpy
  2. import torch
  3.  
  4. from torch.utils.data import DataLoader
  5. # Dataset是一个包装类，用来将数据包装为Dataset类，然后传入DataLoader中，我们再使用DataLoader这个类来更加快捷的对数据进行操作。
  6. # DataLoader是一个比较重要的类，它为我们提供的常用操作有：batch_size(每个batch的大小),
  7. # shuffle(是否进行shuffle操作), num_workers(加载数据的时候使用几个子进程)
  8. from torch.utils.data.sampler import SubsetRandomSampler
  9.  
  10. from torchvision import datasets
  11. from torchvision import transforms
  12. # 计算机视觉常用工具包，包含常用图像预处理、常用数据集实现、常用模型预训练。
  13.  
  14. # global variables 全局变量
  15. # can change from outside
  16. random_scale = (0.4, 1.0)
  17. mean = [0.5, 0.5, 0.5]
  18. std = [0.2, 0.2, 0.2]
  19.  
  20.  
  21. def get_transforms():  # 定义一个图像变换函数做预处理
  22.     #  global语句是一个声明，它保存了整个当前代码块。这意味着列出的标识符将被解释为全局标识符。
  23.     # 如果没有global，就不可能给全局变量赋值，尽管自由变量可以在没有声明global的情况下引用globals。
  24.     # 在全局语句中列出的名称不能在该全局语句文本前面的同一代码块中使用。
  25.     # 全局语句中列出的名称不能定义为形式参数，也不能定义为for循环控制目标、类定义、函数定义或import语句。
  26.     global std
  27.     global mean
  28.     global random_scale
  29.  
  30.     # Compose()类，这个类的主要作用是串联多个图片变换的操作
  31.     # 将transforms列表里面的transform操作进行遍历
  32.     train_transform = transforms.Compose(  # 训练数据的预处理
  33.         [
  34.             transforms.RandomResizedCrop((224, 224), scale=random_scale),  # 随机长宽比裁剪
  35.             transforms.RandomHorizontalFlip(),  # 依概率p水平翻转
  36.             transforms.ToTensor(),
  37.             # 将PIL Image或者 ndarray 转换为tensor，是将输入的数据shape W，H，C ——> C，W，H，并且归一化至[0-1]
  38.             transforms.Normalize(mean=mean, std=std),  # 用平均值和标准偏差归一化张量图像
  39.         ]
  40.     )
  41.  
  42.     valid_transform = transforms.Compose(  # 验证数据的预处理
  43.         [
  44.             transforms.Resize((224, 224)),  # 调整图像大小
  45.             transforms.ToTensor(),  # 归一化
  46.             transforms.Normalize(mean=mean, std=std),  # # 用平均值和标准偏差归一化张量图像
  47.         ]
  48.     )
  49.  
  50.     return (train_transform, valid_transform)
  51.  
  52.  
  53. def find_mean_std(train_dir):
  54.     """
  55.     Get the mean and std per channel
  56.     very slow because of two passes
  58.     parameters -------------------------
  59.     - train_dir     -   path of training set 训练集路径
  61.     returns ----------------------------
  62.     - mean          -   mean of the dataset per channel
  63.     - std           -   standard deviation per channel
  64.     """
  65.  
  66.     pin_memory = True if torch.cuda.is_available() else False  # 判断GPU是否可用
  67.     train_transform = transforms.Compose(  # Compose()类，这个类的主要作用是串联多个图片变换的操作
  68.                                             # 将transforms列表里面的transform操作进行遍历
  69.         [transforms.Resize((224, 224)), transforms.ToTensor()]
  70.     )  # torchvision.datasets这个包中包含MNIST、FakeData、COCO、LSUN、ImageFolder、DatasetFolder、ImageNet、CIFAR等一些常用的数据集，；
  71.     train_dataset = datasets.ImageFolder(train_dir, train_transform)
  72.     # 在train_dir路径下的图像进行train_transform
  73.     # ImageFolder是一个通用的数据加载器，它要求我们以下面这种格式来组织数据集的训练、验证或者测试图片。；
  74.     train_loader = DataLoader(  # 数据读取
  75.         #  DataLoader是一个比较重要的类，它为我们提供的常用操作有：batch_size(每个batch的大小),
  76.         # # shuffle(是否进行shuffle操作), num_workers(加载数据的时候使用几个子进程)
  77.         train_dataset,
  78.         batch_size=1,
  79.         num_workers=0,
  80.         pin_memory=pin_memory,
  81.     )
  82.  
  83.     mn = torch.Tensor([0, 0, 0])  # 创建一个一维张量
  84.     st = torch.Tensor([0, 0, 0])
  85.     count = len(train_loader)  # 多少个图片
  86.  
  87.     for input, target in train_loader:
  88.         mn += input.mean([0, 2, 3])
  89.     
  90.     mn = mn / count  # 平均值
  91.  
  92.     for input, target in train_loader:  # 三个通道
  93.         ch0 = (input[0][0] - mn[0])
  94.         ch1 = (input[0][1] - mn[1])
  95.         ch2 = (input[0][2] - mn[2])
  96.         st[0] += torch.mul(ch0, ch0).sum() / 50176
  97.         st[1] += torch.mul(ch1, ch1).sum() / 50176
  98.         st[2] += torch.mul(ch2, ch2).sum() / 50176
  99.  
  100.     # st = root(sum(x^2) / N)
  101.     st = torch.sqrt(st / count)
  102.  
  103.     return (mn, st)
  104.  
  105.  
  106. def split_loader(
  107.     train_dir, valid_frac=0.1, batch_size=32, shuffle=True,
  108. ):
  109.     """
  110.     Function for splitting and loading train and valid iterators
  111.     函数用于分割和加载训练和验证迭代器
  112.     
  113.     parameters -------------------------
  114.     - train_dir     -   path of training set 训练集路径
  115.     - valid_frac    -   fraction split of the training set used for validation训练集分割用于验证的
  116.     - batch_size    -   how many samples per batch to load
  117.     - shuffle       -   whether to shuffle the train or validation indices打乱数据
  119.     returns ----------------------------
  120.     - train_loader  -   training set iterator
  121.     - valid_loader  -   validation set iterator
  122.     """
  123.  
  124.     # valid frac range assert
  125.     error_msg = "Error : valid_frac should be in the range [0, 1]"
  126.     assert (valid_frac >= 0) and (valid_frac <= 1), error_msg
  127.  
  128.     # override if cuda is available
  129.     pin_memory = True if torch.cuda.is_available() else False  # 判断GPU是否可用
  130.  
  131.     # load as dataset
  132.     train_transform, valid_transform = get_transforms()
  133.     train_dataset = datasets.ImageFolder(train_dir, train_transform)
  134.     valid_dataset = datasets.ImageFolder(train_dir, valid_transform)
  135.  
  136.     # get indices
  137.     num_train = len(train_dataset)
  138.     indices = list(range(num_train))  # 0到99的向量
  139.     split = int(valid_frac * num_train)  #
  140.  
  141.     # shuffle if required
  142.     if shuffle:
  143.         numpy.random.shuffle(indices)  # [1,2,3]打乱成[2,3,1]
  144.  
  145.     # samplers
  146.     train_idx, valid_idx = indices[split:], indices[:split]  # 分开训练验证
  147.     train_sampler = SubsetRandomSampler(train_idx)
  148.     valid_sampler = SubsetRandomSampler(valid_idx)
  149.     # 采样器都随机地从原始的数据集中抽样数据。抽样数据采用permutation。 生成任意一个下标重排，从而利用下标来提取dataset中的数据的方法
  150.  
  151.     # dataloaders 数据加载
  152.     train_loader = DataLoader(
  153.         train_dataset,
  154.         batch_size=batch_size,
  155.         sampler=train_sampler,
  156.         num_workers=0,  # 使用多进程加载的进程数，0代表不使用多进程
  157.         # dataloader一次性创建num_worker个worker，（也可以说dataloader一次性创建num_worker个工作进程，worker也是普通的工作进程），
  158.         # 并用batch_sampler将指定batch分配给指定worker，worker将它负责的batch加载进RAM。
  159.         pin_memory=pin_memory,
  160.     )
  161.     valid_loader = DataLoader(
  162.         valid_dataset,
  163.         batch_size=batch_size,
  164.         sampler=valid_sampler,
  165.         num_workers=0,
  166.         pin_memory=pin_memory,
  167.     )
  168.  
  169.     return (train_loader, valid_loader)
  170.  
  171.  
  172. def separate_loader(
  173.     train_dir, valid_dir, batch_size=32, shuffle=True,
  174. ):
  175.     """
  176.     Function for splitting and loading train and valid iterators
  177.     
  178.     parameters -------------------------
  179.     - train_dir     -   path of training set
  180.     - valid_dir     -   path of validation set
  181.     - batch_size    -   how many samples per batch to load
  182.     - shuffle       -   whether to shuffle the train or validation indices
  184.     returns ----------------------------
  185.     - train_loader  -   training set iterator
  186.     - valid_loader  -   validation set iterator
  187.     """
  188.  
  189.     # load as dataset
  190.     train_transform, valid_transform = get_transforms()
  191.     train_dataset = datasets.ImageFolder(train_dir, train_transform)
  192.     valid_dataset = datasets.ImageFolder(valid_dir, valid_transform)
  193.  
  194.     # override if cuda is available
  195.     pin_memory = True if torch.cuda.is_available() else False
  196.  
  197.     # dataloaders
  198.     train_loader = DataLoader(
  199.         train_dataset,
  200.         shuffle=shuffle,
  201.         batch_size=batch_size,
  202.         num_workers=0,
  203.         pin_memory=pin_memory,
  204.     )
  205.  
  206.     valid_loader = DataLoader(
  207.         valid_dataset,
  208.         shuffle=False,
  209.         batch_size=batch_size,
  210.         num_workers=0,
  211.         pin_memory=pin_memory,
  212.     )
  213.  
  214.     return (train_loader, valid_loader)
  215.  
  216.  
  217. def test_loader(test_dir, batch_size=32, shuffle=False):
  218.     """
  219.     Function for loading test image iterators迭代器
  220.     
  221.     parameters -------------------------
  222.     - test_dir      -   path of image folder
  223.     - batch_size    -   how many samples per batch to load
  225.     returns ----------------------------
  226.     - test_loader   -   data iterator
  227.     """
  228.  
  229.     # override if cuda is available
  230.     pin_memory = True if torch.cuda.is_available() else False
  231.  
  232.     # load as dataset
  233.     valid_transform = get_transforms()
  234.     test_dataset = datasets.ImageFolder(test_dir, valid_transform)
  235.  
  236.     # dataloaders
  237.     test_loader = DataLoader(
  238.         test_dataset,
  239.         batch_size=batch_size,
  240.         num_workers=0,
  241.         pin_memory=pin_memory,
  242.         shuffle=shuffle,
  243.     )
  244.  
  245.     return test_loader
  246.  
  247.  
  248. def load_pth(path):
  249.     # just for code completeness
  250.     device = "cuda:0" if torch.cuda.is_available() else "cpu"
  251.     return torch.load(path, map_location=device)
  1. import time
  2. import shutil
  3. import torch
  4.  
  5. # global variables全局变量
  6. best_acc1 = 0
  7.  
  8.  
  9. # Average Value Computer Class
  10. class AverageMeter(object):  # AverageMeter类来管理一些变量的更新
  11.     def __init__(self):
  12.         self.reset()
  13.  
  14.     def reset(self):  # 重置方法reset
  15.         self.val = 0  # 精度
  16.         self.avg = 0  # 平均值
  17.         self.sum = 0  # 总和
  18.         self.count = 0  # 图片总个数
  19.  
  20.     def update(self, val, n=1):  # 变量更新
  21.         self.val = val
  22.         self.sum += val * n
  23.         self.count += n
  24.         self.avg = self.sum / self.count
  25.  
  26.  
  27. def _train(train_loader, model, criterion, optimizer, epoch):
  28.     """
  29.     One epoch train function
  31.     parameters -------------------------
  32.     - train_loader  -   train data generator object
  33.     - model         -   torch model object
  34.     - criterion     -   loss function object
  35.     - optimizer     -   optimizer object
  36.     - epoch         -   epoch number to train
  38.     returns ----------------------------
  39.     - None
  40.     """
  41. # 对各个参数进行重置
  42.     losses = AverageMeter()
  43.     top1 = AverageMeter()
  44.     # top1--就是你预测的label取最后概率向量里面最大的那一个作为预测结果，
  45.     # 如果你的预测结果中概率最大的那个分类正确，则预测正确。否则预测错误
  46.     top5 = AverageMeter()
  47.     # top5-就是最后概率向量最大的前五名中，只要出现了正确概率即为预测正确。否则预测错误。
  48.  
  49.     cuda_exists = torch.cuda.is_available()
  50.     len_train = len(train_loader)  # 训练数据个数
  51.  
  52.     # switch to train mode
  53.     model.train()  # 训练模型
  54.     print("")
  55.     print("EPOCH : {}".format(epoch))
  56.  
  57.  
  58.  
  59.     for i, (input, target) in enumerate(train_loader):  # 数据迭代读取的循环函数#， 遍历整个训练数据，自动将所有数据按顺序编号
  60.         if cuda_exists:
  61.             input = input.cuda(non_blocking=True)
  62.             target = target.cuda(non_blocking=True)
  63.  
  64.         # compute output
  65.         output = model(input)  # 计算输出
  66.         loss = criterion(output, target)  # 计算损失
  67.  
  68.         # measure accuracy and record loss测量精度和记录损失
  69.         acc1, acc5 = _accuracy(output, target, topk=(1, 5))
  70.         losses.update(loss.item(), input.size(0))
  71.         top1.update(acc1[0], input.size(0))
  72.         top5.update(acc5[0], input.size(0))
  73.  
  74.         # compute gradient and do SGD step
  75.         # 计算梯度和做随机梯度下降步长
  76.         optimizer.zero_grad()  # 梯度归0
  77.         loss.backward()  # 损失回传
  78.         optimizer.step()  # 步长
  79.  
  80.         # 20 bars to display progress
  81.         bar = (20 * (i + 1)) // len_train
  82.  
  83.         print(
  84.             "\r"
  85.             "(" + str(i + 1) + "/" + str(len_train) + ")"
  86.             "[" + "=" * bar + "_" * (20 - bar) + "]       "
  87.             "Loss: {loss.val:.4f} ({loss.avg:.4f})        "
  88.             "Acc@1: {top1.val:.3f} ({top1.avg:.3f})       "
  89.             "Acc@5: {top5.val:.3f} ({top5.avg:.3f})".format(
  90.                 loss=losses, top1=top1, top5=top5,
  91.             ),
  92.             end="",
  93.         )
  94.  
  95.     print("")
  96.  
  97.  
  98. def _validate(valid_loader, model, criterion):
  99.     """
  100.     Validation function
  102.     parameters -------------------------
  103.     - valid_loader  -   validation data generator object
  104.     - model         -   torch model object
  105.     - criterion     -   loss function object
  107.     returns ----------------------------
  108.     - top1.avg      -   top 1 average accuracy
  109.     """
  110.  
  111.     losses = AverageMeter()
  112.     top1 = AverageMeter()
  113.     top5 = AverageMeter()
  114.  
  115.     cuda_exists = torch.cuda.is_available()
  116.     len_valid = len(valid_loader)
  117.  
  118.     # switch to evaluate mode
  119.     model.eval()
  120.     print("VALIDATION :")
  121.  
  122.     with torch.no_grad():  # 是一个上下文管理器
  123.         for i, (input, target) in enumerate(valid_loader):
  124.  
  125.             if cuda_exists:
  126.                 input = input.cuda(non_blocking=True)
  127.                 target = target.cuda(non_blocking=True)
  128.  
  129.             # compute output
  130.             output = model(input)
  131.             loss = criterion(output, target)
  132.  
  133.             # measure accuracy and record loss
  134.             acc1, acc5 = _accuracy(output, target, topk=(1, 5))
  135.             losses.update(loss.item(), input.size(0))
  136.             top1.update(acc1[0], input.size(0))
  137.             top5.update(acc5[0], input.size(0))
  138.  
  139.             # 20 bars to display progress
  140.             bar = (20 * (i + 1)) // len_valid
  141.  
  142.             print(
  143.                 "\r"
  144.                 "(" + str(i + 1) + "/" + str(len_valid) + ")"
  145.                 "[" + "=" * bar + "_" * (20 - bar) + "]       "
  146.                 "Loss: {loss.val:.4f} ({loss.avg:.4f})        "
  147.                 "Acc@1: {top1.val:.3f} ({top1.avg:.3f})       "
  148.                 "Acc@5: {top5.val:.3f} ({top5.avg:.3f})".format(
  149.                     loss=losses, top1=top1, top5=top5,
  150.                 ),
  151.                 end="",
  152.             )
  153.  
  154.         print("")
  155.  
  156.     return top1.avg
  157.  
  158.  
  159. def _accuracy(output, target, topk=(1,)):
  160.     """
  161.     Compute the accuracy over the k top predictions
  162.     计算前面k个预测的准确性
  163.     parameters -------------------------
  164.     - output        -   model output tensor
  165.     - target        -   actual label tensor
  166.     - topk          -   top k accuracy values to return
  168.     returns ----------------------------
  169.     - res           -   list of k top accuracies
  170.     """
  171.  
  172.     num_classes = 1
  173.     for dim in output.shape[1:]:
  174.         num_classes *= dim
  175.  
  176.     with torch.no_grad():  # torch.no_grad() 是一个上下文管理器，被该语句 wrap 起来的部分将不会track 梯度。
  177.         maxk = max(topk)
  178.         maxk = min(maxk, num_classes)
  179.         batch_size = target.size(0)
  180.  
  181.         _, pred = output.topk(maxk, 1, True, True)
  182.         pred = pred.t()
  183.         correct = pred.eq(target.view(1, -1).expand_as(pred))
  184.  
  185.         res = []
  186.         for k in topk:
  187.             if k < num_classes:
  188.                 correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)
  189.                 res.append(correct_k.mul_(100.0 / batch_size))
  190.             else:
  191.                 res.append([0, 0])
  192.  
  193.         return res
  194.  
  195.  
  196. def train(
  197.     model,
  198.     loaders,
  199.     lr=0.01,
  200.     momentum=0.9,
  201.     weight_decay=1e-4,
  202.     epochs=10,
  203.     checkpoint=None,
  204. ):
  205.     """
  206.     The main worker function used to train network
  208.     parameters -------------------------
  209.     - model         -   torch nn module
  210.     - loaders       -   tuple of train and validation DataLoader
  211.     - lr            -   learning rate of model
  212.     - momentum      -   weighted average coefficient (alpha)
  213.     - weight_decay  -   decay of weights coefficient (eta)
  214.     - epochs        -   number of iterations to train
  215.     - checkpoint    -   checkpoint dict
  217.     returns ----------------------------
  218.     - None
  219.     """
  220.  
  221.     global best_acc1
  222.  
  223.     # create model
  224.     print("=> training", model.name)
  225.  
  226.     # unpack loaders
  227.     train_loader, valid_loader = loaders
  228.  
  229.     # find device
  230.     if torch.cuda.is_available():
  231.         device = torch.device("cuda:0")
  232.         print("=> found cuda compatible gpu")
  233.     else:
  234.         device = torch.device("cpu")
  235.         print("=> no cuda devices found, using cpu for training")
  236.  
  237.     # device switches and optimization
  238.     torch.backends.cudnn.benchmark = True
  239.  
  240.     # loss and optimizer
  241.     criterion = torch.nn.CrossEntropyLoss().to(device=device)
  242.     optimizer = torch.optim.SGD(
  243.         model.parameters(), lr, momentum, weight_decay=weight_decay,
  244.     )
  245.  
  246.     # resume from a checkpoint
  247.     if checkpoint:
  248.         start_epoch = checkpoint["epoch"]
  249.         best_acc1 = checkpoint["best_acc1"]
  250.         model.load_state_dict(checkpoint["state_dict"])
  251.         optimizer.load_state_dict(checkpoint["optimizer"])
  252.         print("=> loaded checkpoint", end=" ")
  253.         print("with epoch = %d" % start_epoch, end=" ")
  254.         print("and accuracy = %.2f" % best_acc1)
  255.     else:
  256.         start_epoch = 0
  257.  
  258.     crtm = time.ctime().split()[1:-1]
  259.     print("=> checkpoints will be saved as checkpoint.pth")
  260.     print("=> training started at %s-%s %s" % (crtm[0], crtm[1], crtm[2]))
  261.  
  262.     # training
  263.     for epoch in range(start_epoch, epochs):
  264.  
  265.         # adjust learning rate
  266.         lr_adj = lr * (0.1 ** (epoch // 30))
  267.         for param_group in optimizer.param_groups:
  268.             param_group["lr"] = lr_adj
  269.  
  270.         # train for one epoch
  271.         _train(
  272.             train_loader, model, criterion, optimizer, epoch,
  273.         )
  274.  
  275.         # remember best accuracy
  276.         acc1 = _validate(valid_loader, model, criterion)
  277.         is_best = acc1 > best_acc1
  278.         best_acc1 = max(acc1, best_acc1)
  279.  
  280.         # save checkpoint
  281.         save_dict = {
  282.             "epoch": epoch + 1,
  283.             "arch": model.name,
  284.             "best_acc1": best_acc1,
  285.             "state_dict": model.state_dict(),
  286.             "optimizer": optimizer.state_dict(),
  287.         }
  288.         torch.save(save_dict, "checkpoint.pth")
  289.  
  290.  
  291. def confusion_matrix(model, valid_loader):
  292.     """
  293.     Obtain confusion matrix from prediction
  294.     and actual labels
  295.     由预测得到混淆矩阵 和实际的标签  
  296.     """
  297.  
  298.     len_valid = len(valid_loader)
  299.     cuda_exists = True if torch.cuda.is_available() else False
  300.  
  301.     # confusion matrix of ncls * ncls
  302.     ncls = model.num_classes
  303.     conf_matrix = torch.zeros(ncls, ncls)
  304.  
  305.     # switch to evaluate mode
  306.     model.eval()
  307.     print("VALIDATION :")
  308.  
  309.     with torch.no_grad():
  310.         for i, (input, target) in enumerate(valid_loader):
  311.  
  312.             # compute output
  313.             if cuda_exists:
  314.                 input = input.cuda(non_blocking=True)
  315.                 target = target.cuda(non_blocking=True)
  316.  
  317.             output = model(input)
  318.             _, preds = torch.max(output, 1)
  319.  
  320.             for t, p in zip(target.view(-1), preds.view(-1)):
  321.                 conf_matrix[t.long(), p.long()] += 1
  322.  
  323.             # 20 bars to display progress
  324.             bar = (20 * (i + 1)) // len_valid
  325.  
  326.             print(
  327.                 "\r"
  328.                 "(" + str(i + 1) + "/" + str(len_valid) + ")"
  329.                 "[" + "=" * bar + "_" * (20 - bar) + "]",
  330.                 end="",
  331.             )
  332.         print("")
  333.  
  334.     # horiz normalization to get percentage
  335.     norm_conf = []
  336.     for row in conf_matrix:
  337.         factor = float(row.sum())
  338.         normed = [float(i) / factor for i in row]
  339.         norm_conf.append(normed)
  340.  
  341.     return norm_conf

4.预测数据

测试图像被缩放到256x256像素。 然后提取大小为224x224的三幅图像。 第一幅图像是从原始测试图像的中心得到的。 第二幅图像和第三幅图像分别从原始测试图像的左下角和右上角提取。 利用训练后的CCN网络，将提取的三幅图像输入模型，计算每幅图像的softmax概率输出向量。 获得对原始测试图像的类分数的最终概率向量，对三幅图像的输出分数向量进行平均。 这种方法减少了低分辨率和遮挡等低质量图像的影响。

5.实验结果

1-off精度，表示结果在左或右一个相邻的年龄标签的误差时的精度。根据我们的结果，在精确精度和1-off精度方面，所提议的工作显著优于最先进的结果。这些结果证实了所提出的工作的有效性。表2给出了建议模型的混淆矩阵。

 

 

6.模型比较

与修改的GoogleNet模型进行比较： 为了进一步证明所提工作的有效性，对GoogLeNet模型进行了图像训练 ，在ImageNet ILSVRC数据库上进行了重新训练、微调和测试。 我们修改和微调了GoogLeNet CNN来执行年龄预测，完全替换连接层和改变节点的数量。 在修改后的体系结构中，有四个完全连接的层   每层节点数分别为1024、2048、2048和8。 然后修改后的  GoogLeNet被重新训练和微调，同时在训练期间保持卷积层不变  。

 改进后的GoogLeNet CNN在年龄估计方面达到了45.07%。 表六世通过使用VGG-Face CNN和GoogLeNet CNN，给出了所提模型的性能 估计。   为了进行年龄估计，使用了经过训练的GoogLeNet CNN进行图像分类任务   提供合理的结果。 但是，从表VI的结果可以明显看出，使用CNN提取的特征针对人脸识别任务训练的CNN模型比使用CNN模型提取的特征更有效图像分类训练。  

7.结论分析 

在本文中，提出了一个基于面部图像的年龄估计模型，该模型使用深度CNN称为VGG-Face，它是在一个大型数据库上训练的人脸识别。 对VGG-Face CNN进行了改进和微调，以进行年龄估计。 提出的模型在Adience数据库上比之前的算法提高了9%，Adience数据库是最新的具有挑战性的年龄估计基准，由无约束的人脸图像组成。 GoogLeNet是在一个包含数百万训练图像的大型数据库上进行训练的，它在年龄估计方面的性能与提出的使用VGG-Face的模型不具有竞争力。 不仅训练图像的数量和训练数据库中被训练对象的数量影响年龄估计的性能，而且所使用的CNN的训练前任务也决定了网络的年龄估计性能。

8.数据集分析 

9.完整代码 

完整代码 ：总共4个py文件：loader.py、models.py、worker.py、vgg16.py(下面代码）

  1. # 读取CSV文件
  2. import pandas as pd
  3. frames = []
  4. folder_path = "F:/研究生/数据集/Adience_adience/adience/"
  5. for i in range(5):
  6.     temp_df = pd.read_csv(folder_path + "fold_" + str(i) + "_data.txt", delimiter="\t")
  7.     """
  8.     pandas提供了pd.read_csv()方法可以读取其中的数据并且转换成DataFrame数据帧(一个矩阵样式的数据表)。
  9.     python的强大之处就在于他可以把不同的数据库类型，比如txt/csv/.xls/.sql转换成统一的DataFrame格式然后进行统一的处理。真是做到了标准化
  10.     """
  11.     frames.append(temp_df)  # 加载5个文件，依次放入frames列表的末尾中
  12. df = pd.concat(frames)  # 把各个文件数据根据不同的轴简单融合
  13. df.head()  # 观察前5行的数据。括号内没有数字默认为5个，要加载任意个数需添加任意的数
  14. # print(df.head())
  15. # print(df)
  16. # for cleaning anomalies清理异常
  17. # 不同年龄放入不同的年龄区间段,字典
  18. map_dict = {
  19.     "13": "(08, 12)",
  20.     "2": "(00, 02)",
  21.     "22": "(15, 20)",
  22.     "23": "(25, 32)",
  23.     "29": "(25, 32)",
  24.     "3": "(00, 02)",
  25.     "32": "(25, 32)",
  26.     "34": "(25, 32)",
  27.     "35": "(25, 32)",
  28.     "36": "(38, 43)",
  29.     "42": "(38, 43)",
  30.     "45": "(38, 43)",
  31.     "46": "(48, 53)",
  32.     "55": "(48, 53)",
  33.     "56": "(48, 53)",
  34.     "57": "(60, 100)",
  35.     "58": "(60, 100)",
  36.  
  37.     "(8, 23)": "(08, 12)",
  38.     "(27, 32)": "(25, 32)",
  39.     "(38, 42)": "(38, 43)",
  40.     "(38, 48)": "(38, 43)",
  41.  
  42.     "(00, 02)": "(00, 02)",
  43.     "(04, 06)": "(04, 06)",
  44.     "(08, 12)": "(08, 12)",
  45.     "(15, 20)": "(15, 20)",
  46.     "(25, 32)": "(25, 32)",
  47.     "(38, 43)": "(38, 43)",
  48.     "(48, 53)": "(48, 53)",
  49.     "(60, 100)": "(60, 100)"
  50. }
  51.  
  52. def map_func(x):   # 定义一个年龄分布函数
  53.     if x in map_dict:
  54.         return map_dict[x]
  55.     else:
  56.         return x
  57. df["age"] = df["age"].map(map_func)  # map()函数
  58.  
  59.  
  60.  
  61. # 重组目录
  62. import os
  63. import shutil
  64. folder_path = "F:/研究生/数据集/Adience_adience/adience/faces/"  # 原始数据
  65. file_list = []  # 创建一个空文件列表
  66. formats = ["jpg", "png"]
  67. # 对数据集进行处理：指定文件路径-找文件夹包含的文件-把路径和文件名称连接起来-判断路径是否为目录-
  68. # pytorch数据加载程序无法识别目录结构。
  69. # 为了重组树，使它是可读的，每个文件都被移动到以其类命名的子文件夹下。
  70. for subdir in os.listdir(folder_path):  # os.listdir用于返回指定的文件夹包含的文件或文件夹的名字的列表
  71.     subpath = os.path.join(folder_path, subdir)  # 连接两个或更多的路径名组件
  72.     if os.path.isdir(subpath):  # 判断某一路径是否为目录
  73.         for f in os.listdir(subpath):
  74.             filepath = os.path.join(subpath, f)
  75.             part = f.split(".")  # 拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）
  76.             # os.path.split()：按照路径将文件名和路径分割开
  77.             if os.path.isfile(filepath) and part[-1] in formats:  # 用于判断某一对象(需提供绝对路径)是否为文件
  78.                 file_list.append((subpath, f))
  79.  
  80. im_len = len(file_list)
  81. print(im_len)
  82.  
  83. for i, (filepath, filename) in enumerate(file_list):  # 把所有文件路径和文件名按顺序编号
  84.  
  85.     # get the identifiers
  86.     parts = filename.split(".")  # 把文件名 filename按.分开
  87.     user_id = filepath.split("/")[-1]  # 把文件路径按/分开，去最后一个路径
  88.     file_id = parts[-2] + "." + parts[-1]  # 取文件名最后两个路径、
  89.     face_id = int(parts[-3])  # 文件倒数第三个路径转化为整形
  90.  
  91.     # find class  df是一个字典
  92.     if df[(df["user_id"] == user_id) &(df["original_image"] == file_id) &(df["face_id"] == face_id)].empty:
  93.         continue
  94.     else:
  95.         class_ = df[(df["user_id"] == user_id) & (df["original_image"] == file_id) & (df["face_id"] == face_id)]["age"].values[0]
  96.  
  97.  
  98.     new_path = os.path.join('F:/研究生/数据集/Adience_adience/adience/faces/', class_)
  99.  
  100.  
  101.     if not os.path.exists(new_path):
  102.         os.makedirs(new_path)
  103.  
  104.         # move file
  105.     new_path = os.path.join(new_path, filename)
  106.     file_path=os.path.join(filepath, filename)
  107.     shutil.move(file_path, new_path)
  108.  
  109.     # progress
  110.     prog = (20 * (i + 1)) // im_len
  111.     print("\r[" + "=" * prog + "_" * (20 - prog) + "]", end="")
  112.  
  113.  
  114. for subdir in os.listdir(folder_path):
  115.     subpath = os.path.join(folder_path, subdir)
  116.     if os.path.isdir(subpath):
  117.         if subdir[0] != "(":
  118.            shutil.rmtree(subpath)  # 表示递归删除文件夹下的所有子文件夹和子文件。
  119.     elif os.path.isfile(subpath):
  120.         os.remove(subdir)  # 删除subdir文件路径
  121.  
  122.  
  123.  
  124. # 准备
  125. import torch
  126. import source.models as models
  127. import source.worker as worker
  128. import source.loader as loader
  129.  
  130. # the mean and std of dataset are found by running this
  131. # 通过运行该程序，可以得到数据集的均值和标准差
  132. # takes some time to iterate twice
  133. # 需要一些时间迭代两次
  134. loader.find_mean_std("F:/研究生/数据集/Adience_adience/adience/faces/")
  135. loader.random_scale = (0.8, 1.0)
  136. loader.mean = [0.437, 0.340, 0.304]
  137. loader.std  = [0.286, 0.252, 0.236]
  138. # Dataset Loader to feed into network
  139. # 数据集加载器将馈送到网络
  140. # 20% of data is used for validation
  141. loaders = loader.split_loader("F:/研究生/数据集/Adience_adience/adience/faces/", valid_frac=0.2, batch_size=32)
  142. # pretrained weights - for convolution layers
  143. state = loader.load_pth("F:/研究生/论文/vgg-age-master/vgg_face_dag.pth")
  144.  
  145.  
  146. # 模型初试化
  147. model = models.vgg16(num_classes=8)  # 8类
  148. model.load_weights(state)  # 加载权重
  149. model.memory_usage()  # 模型的总参数
  150.  
  151. worker.train(model, loaders, lr=0.01, epochs=3)  # 训练
  152. check = loader.load_pth("checkpoint.pth")
  153. model.load_weights(check["state_dict"])
  154. valid_loader = loaders[1]
  155. conf_mat = worker.confusion_matrix(model, valid_loader)
  156.  
  157. # 混淆矩阵
  158. for row in conf_mat:
  159.     for elem in row:
  160.         print("%.2f"%(elem*100), end="\t")
  161.     print("")
  162. ncls = len(conf_mat)
  163. tot_acc = 0
  164.  
  165. for i in range(ncls):
  166.  
  167.     acc = conf_mat[i][i]
  168.  
  169.     # add left
  170.     if i > 0:
  171.         acc += conf_mat[i][i - 1]
  172.  
  173.     if i < ncls - 1:
  174.         acc += conf_mat[i][i + 1]
  175.  
  176.     tot_acc += acc
  177.  
  178. tot_acc = tot_acc / ncls
  179. print("%.2f" % (tot_acc * 100))
  180.  
  181.  
  182.  
  183. # 相应的预测和目标标签随输入图像一起可视化。
  184. import os
  185. import torch
  186. import source.models as models
  187. import source.worker as worker
  188. import source.loader as loader
  189. import matplotlib.pyplot as plt
  190. import torchvision.transforms as transforms
  191. # from NewSource import model
  192. # from NewSource import valid_loader
  193. dire = "F:/研究生/数据集/Adience_adience/adience/faces/"
  194. classes = os.listdir(dire)
  195. classes.sort()
  196. idx_to_class = {i:classes[i] for i in range(len(classes))}
  197. print(idx_to_class)
  198. model.eval()
  199. batch_size = 32
  200. model.to(torch.device("cpu"))
  201. mean = loader.mean
  202. std  = loader.std
  203. mn_inv = [-m/s for m, s in zip(mean, std)]
  204. sd_inv = [1/s for s in std]
  205. inv_transform = transforms.Normalize(mean=mn_inv, std=sd_inv)
  206. with torch.no_grad():
  207.     for i, (input, target) in enumerate(valid_loader):
  208.  
  209.         output = model(input)
  210.         _, preds = torch.max(output, 1)
  211.  
  212.         fig=plt.figure(figsize=(15, 15))
  213.         columns = 4
  214.         rows = 5
  215.  
  216.         for i in range(1, columns*rows + 1):
  217.  
  218.             pred_class = idx_to_class[int(preds[i])]
  219.             real_class = idx_to_class[int(target[i])]
  220.  
  221.             ax = fig.add_subplot(rows, columns, i)
  222.             ax.title.set_text("pred:" + pred_class + "," + "real:" + real_class)
  223.             ax.axis("off")
  224.  
  225.             plt.imshow(inv_transform(input[i]).permute(1, 2, 0))
  226.  
  227.         break
  228.  
  229.  
  230. plt.show()

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/729877
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号