精华内容
下载资源
问答
  • 行人属性识别

    2017-04-09 20:47:00
    网络资料摘抄: 技术手段:利用深度学习来实现行人的精细化识别 实现基础方面:1)行人检测 2...基于数据统计和模板匹配:行人属性识别技术主要基于数据统计和模板匹配。通过采集大量的样本,对正负样本进行特征向...

    网络资料摘抄:

    技术手段:利用深度学习来实现行人的精细化识别

    实现基础方面:1)行人检测 2)行人特点标签 3)附属物定位等...

     

    基于图像智能分析、识别行人的过程:首先需要对图像进行分割,对图像中行人的特征信息进行提取,并送入已训练好的分类器中,进行分类识别,以此来识别行人

    基于数据统计和模板匹配:行人属性识别技术主要基于数据统计和模板匹配。通过采集大量的样本,对正负样本进行特征向量提取,特征概率计算并根据最优选取原则,对行人及行人属性目标进行识别分类,并最终得到识别后的结果。

     

    转载于:https://www.cnblogs.com/liang2713020/p/6686301.html

    展开全文
  • 行人属性识别算法合集包括DeepMar,attention-heat-map-refining,RstarCNN,Weakly-supervised-Network
  • 针对监控场景的背景杂乱及行人被遮挡等问题,提出一种基于背景抑制的行人属性识别方法,该方法可以减小背景对行人属性识别的影响。首先,改进卷积神经网络以生成三个分支,将分支分别用于行人图像、人体区域、背景区域的...
  • 监视场景中行人属性识别的多属性学习
  • 基于深度学习的行人属性识别.pdf
  • 为了提高行人属性识别的准确率,提出了一种基于多尺度注意力网络的行人属性识别算法。为了提高算法的特征表达能力和属性判别能力,首先,在残差网络ResNet50的基础上,增加了自顶向下的特征金字塔和注意力模块,自顶向下...
  • 行人属性识别,PA100K

    千次阅读 热门讨论 2021-02-07 09:14:13
    行人属性识别,即识别行人的多个特征,例如:性别、年龄、戴帽子、戴眼镜等。本文将带你学习行人属性识别,主要用到的是multitask技术。

    1. 前景介绍

          最近在调研行人属性识别,有不少研究行人属性识别的论文,阅读多篇论文之后,自己独立写了一个工程,专门做行人属性识别。

          工程里面的代码主要参考两篇论文,ResNest对应的论文和Bag of Tricks for Image Classification对应的论文。

          主干网络用的是ResNet的最强改进版本:ResNest50,论文详解请看我之前的博客

          训练技巧主要运用了《Bag of Tricks for Image Classification with Convolutional Neural Networks》里面的训练技巧,详细讲解请参考我的专栏:模型训练技巧

          训练数据应用的是行人属性数据集PA100K,关于PA100K的介绍请参考我的博客

    2. 训练部分代码讲解

          一共训练10个属性,分别是:性别、年龄、朝向、是否戴帽子、是否戴眼镜、是否有手提包、是否有肩膀包、是否有背包、上衣类型、下衣类型。

        for epoch in range(1, args.e + 1):
            if epoch > args.warm:
                train_scheduler.step(epoch)
    
            #training procedure
            net.train()
    
            for batch_index, (images, labels) in enumerate(train_dataloader):
                if epoch <= args.warm:
                    warmup_scheduler.step()
    
                images = images.cuda()
                labels = labels.cuda()
    
                optimizer.zero_grad()
                predicts = net(images)
         
                loss_gender = cross_entropy(predicts[0], labels[:, 0].long())
                loss_age = cross_entropy(predicts[1], labels[:, 1].long())
                loss_orientation = cross_entropy(predicts[2], labels[:, 2].long())
                loss_hat = cross_entropy(predicts[3], labels[:, 3].long())
                loss_glasses = cross_entropy(predicts[4], labels[:, 4].long())
                loss_handBag = cross_entropy(predicts[5], labels[:, 5].long())
                loss_shoulderBag = cross_entropy(predicts[6], labels[:, 6].long())
                loss_backBag = cross_entropy(predicts[7], labels[:, 7].long())
                loss_upClothing = cross_entropy(predicts[8], labels[:, 8].long())
                loss_downClothing= cross_entropy(predicts[9], labels[:, 9].long())
    
                loss = loss_gender + loss_age + loss_orientation + loss_hat + loss_glasses + loss_handBag + loss_shoulderBag + loss_backBag + loss_upClothing + loss_downClothing
                loss.backward()
                optimizer.step()
    
                n_iter = (epoch - 1) * len(train_dataloader) + batch_index + 1
    
                if batch_index % 10 == 0:
                    print('Training Epoch: {epoch} [{trained_samples}/{total_samples}]\tLoss: {:0.4f}\tLoss_gender: {:0.4f}\tLoss_age: {:0.4f}\tLoss_ori: {:0.4f}\tLoss_hat: {:0.4f}\tLoss_glasses: {:0.4f}\tLoss_handBag: {:0.4f}\t'.format(
                        loss.item(),
                        loss_gender.item(),
                        loss_age.item(),
                        loss_orientation.item(),
                        loss_hat.item(),
                        loss_glasses.item(),
                        loss_handBag.item(),
                        epoch=epoch,
                        trained_samples=batch_index * args.b + len(images),
                        total_samples=len(train_dataloader.dataset),
                    ))
    
                #visualization
                visualize_lastlayer(writer, net, n_iter)
                visualize_train_loss(writer, loss.item(), n_iter)
    
    
            visualize_learning_rate(writer, optimizer.param_groups[0]['lr'], epoch)
            visualize_param_hist(writer, net, epoch) 
    
            net.eval()
    
            total_loss = 0
            correct = np.zeros(10)
            ignore = np.zeros(10)
            print("=>test model")
            for images, labels in tqdm(test_dataloader):
                images = images.cuda()
                labels = labels.cuda()
    
                predicts = net(images)
    
                for index in range(10):
                    _, preds = predicts[index].max(1)
                    ignore[index] += int((labels[:, index]==-1).sum())
                    correct[index] += preds.eq(labels[:, index]).sum().float()
    
                    loss = cross_entropy(predicts[index], labels[:, index].long())
                    total_loss += loss.item()
    
            test_loss = total_loss / len(test_dataloader)
            all_list = np.array([len(test_dataloader.dataset) for i in range(10)])-ignore
            acc_list = correct / all_list
            print(acc_list.tolist())

            训练过程如下:

    3. 测试代码讲解

    """
    author:guopei
    """
    import os
    import cv2
    import torch
    from torch.nn import DataParallel
    import numpy as np
    from PIL import Image,ImageDraw,ImageFont
    import transforms
    from models import resnest50
    
    
    class Person_Attribute(object):
        def __init__(self, weights="resnest50.pth"):
            self.device = torch.device("cuda")
            self.net = resnest50().to(self.device)
            self.net = DataParallel(self.net)
            self.weights = weights
            self.net.load_state_dict(torch.load(self.weights))
    
            TRAIN_MEAN = [0.485, 0.499, 0.432]
            TRAIN_STD = [0.232, 0.227, 0.266]
            self.transforms = transforms.Compose([
                        transforms.ToCVImage(),
                        transforms.Resize((128,256)),
                        transforms.ToTensor(),
                        transforms.Normalize(TRAIN_MEAN, TRAIN_STD)
            ])
    
        def recog(self, img_path):
            img = cv2.imread(img_path)
            img = self.transforms(img)
            img = img.unsqueeze(0)
    
            with torch.no_grad():
                self.net.eval()
                img_input = img.to(self.device)
                outputs = self.net(img_input)
                results = []
                for output in outputs:
                    output = torch.softmax(output, 1)
                    output = np.array(output[0].cpu())
                    label = np.argmax(output)
                    score = output[label]
                    results.append((label, score))
            return results
    
    
    name_dict = {
                    "gender":['男', '女'],
                    "age":["老年", "中年", "少年"],
                    "orientation":['正面', '侧面', '背面'],
                    "hat":["不戴帽子", "戴帽子"],
                    "glasses":["不戴眼镜", "戴眼镜"],
                    "handBag":["没有", "有"],
                    "shoulderBag":["没有", "有"],
                    "backBag":["没有", "有"],
                    "upClothing":["短袖", "长袖"],
                    "downClothing":["长裤", "短裤", "裙子"]
                }
    
    if __name__ == "__main__":
        atts = ["gender","age", "orientation", "hat", "glasses",
                "handBag", "shoulderBag", "backBag", "upClothing", "downClothing"]
    
        person_attribute = Person_Attribute("./resnest50-50-regular.pth")
        img_path = "test.jpg"
        results = person_attribute.recog(img_path)
        print(results)
        img = cv2.imread(img_path)
        img = cv2.resize(img, (128,256))
        img1 = img*0 +255
        img1[:,:,0] *= 255
        img1[:,:,2] *= 255
    
        line = ""
        labels = [i[0] for i in results]
        for att, label in zip(atts, labels):
            if label == -1:
                continue
            line += "%s:%s\n" % (att, name_dict[att][label])
    
    
        img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
        img1 = Image.fromarray(img1)
        draw = ImageDraw.Draw(img1)
        font = ImageFont.truetype("simhei.ttf", 12, encoding="utf-8")
        draw.text((0, 0), line, (255, 0, 0), font=font)
        img1 = cv2.cvtColor(np.array(img1), cv2.COLOR_RGB2BGR)
    
        img_rst = np.hstack([img, img1])
        cv2.imwrite(os.path.basename(img_path), img_rst)

              测试效果如下:

     

    注:本文所用的训练数据都是公开数据集,如果你需要训练好的模型或者训练数据或者技术交流,请留言或者微信。近期会将代码开源。

    注:很多粉丝拿到了训练的源码,对其中train.txt和val.txt有疑问,这里统一回复一下。

    train.txt和val.txt的格式如下,每类标签是从0开始的,不确定的类别用-1表示,标签之间用空格分开。

    /work/img/1.jpg 0 1 1 1 0 0 0 0 1 1
    /work/img/2.jpg 0 1 1 -1 0 0 0 0 1 1
    /work/img/3.jpg 0 1 1 0 0 0 0 0 1 1
    /work/img/4.jpg 0 1 1 1 0 1 0 0 1 1
    /work/img/5.jpg 0 1 1 1 0 1 0 0 1 1
    /work/img/6.jpg 0 1 1 1 0 0 0 0 1 1
    /work/img/7.jpg 0 1 1 1 0 0 0 0 1 1
    /work/img/8.jpg 0 1 1 1 0 0 0 0 1 1
    /work/img/9.jpg 0 1 1 1 0 1 0 0 1 1

     

    展开全文
  • OpenVINO行人属性识别

    2021-06-10 14:44:05
    OpenVINO行人属性识别详解与代码演示

    OpenVINO不仅通过其IE组件实现加速推理,其提供的预训练库还支持各种常见的图像检测、分割、对象识别等的计算机视觉任务。前面小编写过一系列的文章详细介绍过OpenVINO的各种应用,可以看这里回顾一下:

    这里分享一下如何通过OpenVINO提供的行人检测与行人属性识别模型实现一个实时的视频行人检测与属性识别的演示程序。先看一下效果:
    在这里插入图片描述
    模型:模型来自OpenVINO官方提供的预训练模型库

    行人检测模型:
    模型名称:pedestrian-detection-adas-0002
    输入格式:NCHW= [1x3x384x672]
    输出格式: DetectionOut 类型 [1, 1, N, 7]
    基于Caffe SSD MobileNet V1版本训练生成

    行人属性识别模型:
    模型名称:person-attributes-recognition-crossroad-0230
    输入格式:NCHW= [1x3x160x80]
    输出格式:
    输出层有三个,其中输出层名称为435的输出格式为
    [1, 8, 1, 1] 是八个属性
    另外两个输出层456,459表示两个颜色位置
    基于pytorch训练生成的分类网络模型,支持的八种属性与准确率如下:
    在这里插入图片描述
    两个模型均可在intel OpenVINO的官方网站下载即可

    代码实现

    mport sys
    import cv2
    import numpy as np
    import time
    import logging as log
    from openvino.inference_engine import IENetwork, IEPlugin
    plugin_dir = "C:/Intel/openvino_2019.1.148/deployment_tools/inference_engine/bin/intel64/Release"
    cpu_extension = "C:/Users/Administrator/Documents/Intel/OpenVINO/inference_engine_samples_build/intel64/Release/cpu_extension.dll"
    model_xml = "D:/projects/models/pedestrian-detection-adas-0002/FP32/pedestrian-detection-adas-0002.xml"
    model_bin = "D:/projects/models/pedestrian-detection-adas-0002/FP32/pedestrian-detection-adas-0002.bin"
    
    attribute_xml = "D:/projects/models/pedestrian-detection-adas-0002/person-attributes-recognition-crossroad-0230.xml"
    attribute_bin = "D:/projects/models/pedestrian-detection-adas-0002/person-attributes-recognition-crossroad-0230.bin"
    
    attrs = ['is_male', 'has_bag', 'has_backpack', 'has_hat', 'has_longsleeves', 'has_longpants', 'has_longhair', 'has_coat_jacket']
    
    def demo():
        # 加载MKLDNN - CPU Target
        log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
        plugin = IEPlugin(device="CPU", plugin_dirs=plugin_dir)
        plugin.add_cpu_extension(cpu_extension)
    
        lut = [];
        lut.append((0, 0, 255))
        lut.append((255, 0, 0))
        lut.append((0, 255, 0))
        lut.append((0, 255, 255))
        lut.append((255, 0, 255))
        # 加载IR
        log.info("Reading IR...")
        net = IENetwork(model=model_xml, weights=model_bin)
        pedestrian_attr_net = IENetwork(model=attribute_xml, weights=attribute_bin)
    
        if plugin.device == "CPU":
            supported_layers = plugin.get_supported_layers(net)
            not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
            if len(not_supported_layers) != 0:
                log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
                          format(plugin.device, ', '.join(not_supported_layers)))
                log.error("Please try to specify cpu extensions library path in demo's command line parameters using -l "
                          "or --cpu_extension command line argument")
                sys.exit(1)
        assert len(net.inputs.keys()) == 1, "Demo supports only single input topologies"
        assert len(net.outputs) == 1, "Demo supports only single output topologies"
    
        # 获取输入输出层
        input_blob = next(iter(net.inputs))
        out_blob = next(iter(net.outputs))
    
        lm_input_blob = next(iter(pedestrian_attr_net.inputs))
        lm_output_blob = next(iter(pedestrian_attr_net.outputs))
        log.info("Loading IR to the plugin...")
    
        # 创建可执行网络
        exec_net = plugin.load(network=net, num_requests=2)
        lm_exec_net = plugin.load(network=pedestrian_attr_net)
        n, c, h, w = net.inputs[input_blob].shape
        del net
    
        # we did not need pedestrian model any more
        mn, mc, mh, mw = pedestrian_attr_net.inputs[lm_input_blob].shape
        del pedestrian_attr_net
    
        # 开始视频文件或者摄像头
        cap = cv2.VideoCapture("D:/images/video/fromis-songs.mp4")
        # cap = cv2.VideoCapture(0)
    
        cur_request_id = 0
        next_request_id = 1
    
        log.info("Starting inference in async mode...")
        log.info("To switch between sync and async modes press Tab button")
        log.info("To stop the demo execution press Esc button")
        is_async_mode = True
        render_time = 0
    
        # 读取视频流
        ret, frame = cap.read()
        initial_w = cap.get(3)
        initial_h = cap.get(4)
    
        # 开始检测
        while cap.isOpened():
            if is_async_mode:
                ret, next_frame = cap.read()
            else:
                ret, frame = cap.read()
            if not ret:
                break
    
            # next_frame = cv2.flip(next_frame, 1)
    
            # 开启同步或者异步执行模式
            inf_start = time.time()
            if is_async_mode:
                in_frame = cv2.resize(next_frame, (w, h))
                in_frame = in_frame.transpose((2, 0, 1))  # Change data layout from HWC to CHW
                in_frame = in_frame.reshape((n, c, h, w))
                exec_net.start_async(request_id=next_request_id, inputs={input_blob: in_frame})
            else:
                in_frame = cv2.resize(frame, (w, h))
                in_frame = in_frame.transpose((2, 0, 1))  # Change data layout from HWC to CHW
                in_frame = in_frame.reshape((n, c, h, w))
                exec_net.start_async(request_id=cur_request_id, inputs={input_blob: in_frame})
            if exec_net.requests[cur_request_id].wait(-1) == 0:
    
                # 解析DetectionOut
                res = exec_net.requests[cur_request_id].outputs[out_blob]
                for obj in res[0][0]:
                    # Draw only objects when probability more than specified threshold
                    if obj[2] > 0.5:
                        xmin = int(obj[3] * initial_w)
                        ymin = int(obj[4] * initial_h)
                        xmax = int(obj[5] * initial_w)
                        ymax = int(obj[6] * initial_h)
                        class_id = int(obj[1])
    
                        # Draw box and label\class_id
                        cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (0, 0, 255), 2)
                        if xmin > 0 and ymin > 0 and (xmax < initial_w) and (ymax < initial_h):
                            roi = frame[ymin:ymax, xmin:xmax, :]
                            pedestrian_roi = cv2.resize(roi, (mw, mh))
                            pedestrian_roi = pedestrian_roi.transpose((2, 0, 1))
                            pedestrian_roi = pedestrian_roi.reshape((mn, mc, mh, mw))
    
                            # 行人属性识别
                            lm_exec_net.infer(inputs={'0': pedestrian_roi})
                            attr_res = lm_exec_net.requests[0].outputs[lm_output_blob]
                            attr_res = np.reshape(attr_res, (8, 1))
    
                            # 解析行人八个属性指标
                            for i in range(len(attrs)):
                                if attr_res[i][0] > 0.5:
                                    cv2.putText(frame, attrs[i] + ": " + str(1),
                                                (xmin+30, ymin+20*i),
                                                cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 255), 1)
                                else:
                                    cv2.putText(frame, attrs[i] + ": " + str(0),
                                                (xmin + 30, ymin + 20 * i),
                                                cv2.FONT_HERSHEY_COMPLEX, 0.5, (0, 0, 255), 1)
                            cv2.putText(frame, "Person" + ' ' + str(round(obj[2] * 100, 1)) + ' %', (xmin, ymin - 7),
                                        cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 0, 0), 1)
                inf_end = time.time()
                det_time = inf_end - inf_start
    
                # 显示绘制文本
                inf_time_message = "Inference time: {:.3f} ms, FPS:{:.3f}".format(det_time * 1000, 1000 / (det_time * 1000 + 1))
                render_time_message = "OpenCV rendering time: {:.3f} ms".format(render_time * 1000)
                async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id) if is_async_mode else \
                    "Async mode is off. Processing request {}".format(cur_request_id)
    
                cv2.putText(frame, inf_time_message, (15, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (255, 255, 0), 1)
                cv2.putText(frame, render_time_message, (15, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
                cv2.putText(frame, async_mode_message, (10, int(initial_h - 20)), cv2.FONT_HERSHEY_COMPLEX, 0.5,
                            (10, 10, 200), 1)
    
            # 显示
            render_start = time.time()
            cv2.imshow("OpenVINO-face-landmark-detection@57558865", frame)
            render_end = time.time()
            render_time = render_end - render_start
    
            # ready for next frame
            if is_async_mode:
                cur_request_id, next_request_id = next_request_id, cur_request_id
                frame = next_frame
    
            key = cv2.waitKey(50)
            if key == 27:
                break
    
        # 释放资源
        cv2.destroyAllWindows()
        del exec_net
        del lm_exec_net
        del plugin
    
    
    if __name__ == '__main__':
        sys.exit(demo() or 0)
    

    使用两段视频测试截图分别如下:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 基于深度学习的行人属性识别综述.pdf
  • Improving Pedestrian Attribute Recognition With Weakly-Supervised Multi-Scale Attribute-Specific ...行人属性识别任务本质上是一个分类任务,输入一个人的图像,得到人的性别、年龄、穿衣等的属性。相比

    Improving Pedestrian Attribute Recognition With Weakly-Supervised Multi-Scale Attribute-Specific Localization

    文章:https://arxiv.org/abs/1910.04562

    代码:https://github.com/chufengt/iccv19_attribute

    1、行人属性识别任务

    行人属性识别任务本质上是一个分类任务,输入一个人的图像,得到人的性别、年龄、穿衣等的属性。相比于传统的分类,属性的识别有的时候较为依赖于局部的特征,比方说一个人是否带墨镜就只和人脸的区域有关系,于是为了提高分类的效果,论文一般都会采用一些局部的方法,提高属性识别的正确率。

                                                                        图1 a 原图 b 裁剪的局部区域 c 基于注意力机制的热力图 d 多个局部区域

    2、本文思想

    本文是针对单幅图像进行行人属性分析的论文,核心思想有两点:

    1)使用多尺度的特征进行行人属性的判别,低层次的特征用于局部属性的判别,如是否佩戴帽子;高层次的特征用于语义属性信息的判别,如性别

    2)对每一个属性都使用了一个属性定位模块(Attribute Localization Module,ALM),在输入图像上定位和当前属性相关联的图像区域,基于定位的区域进行属性的判别。ALM也属于一种视觉注意力机制,但是针对各个属性都去学习一个对应的ALM,并且作者使用了STN(Spatial Trabnsformer Net),用弱监督的方式进行了感兴趣区域的学习。ALM内部也结合了来自于SENet的channel混合的思想。

    STN网络(Spatial Transform Network),关于该网络可以参考下面的文章和pytorch官方教程:

    1、【注意力机制】空间注意力机制之Spatial Transformer Network:

    https://zhuanlan.zhihu.com/p/105347822

    2、SPATIAL TRANSFORMER NETWORKS TUTORIAL

    https://pytorch.org/tutorials/intermediate/spatial_transformer_tutorial.html

    3、网络结构

    从图中可以看到网络的大致流程:

    1)首先图像进入一个Backbone的网络,不同层的特征还进行了融合。

    2)融合后的特征进入黄色的Attribute Localization Module,最后输出使用softmax进行分类。

    3)可以看到上图中有多个绿色部分(预测结果),对多个结果进行融合,得到最终的结果。

    上面的Attribute Localization Module就是上文提到的STN改进得到的,结构如下:

    这个模块相当于STN添加了一个Channel wise的attention。网络可以通过交叉熵进行End-To-End训练。

    4、网络结构描述

    4.1、主干网络

    作者使用的骨干网络是BN-Inception,将inception_3b,inception_4b,inception_5b三个尺度的输出取出构建多尺度的特征,这三个尺度的特征的空间尺寸相对于输入图像的stride分别是8,16,32。具体的实现是,对三个尺度的输出特征,分别使用1 * 1的卷积,将其channel数变为256,而后两个尺度的特征进行上采样操作,空间尺度扩大2倍。因此,对于第一、第二个尺度的输出,进行的操作为:f 表示1 * 1的卷积操作,g 表示的是对相邻的下一个尺度的输出进行的空间上采样的操作。这两个输出进行concatenate的操作,作为当前尺度的最终输出feature map。对于第三个尺度的输出,因为其为最后一个尺度,因此,没有可供上采样的下一尺度的特征,唯一的操作是对其应用1 * 1的卷积,即:

    4.2、ALM

    ALM进行和属性相关的图像区域定位,作者认为一个注意力网络同时进行多个属性定位时,定位出来的不同属性间的感兴趣区域之间是存在混叠的,因此作者针对每一个属性都单独训练了一个ALM。ALM的具体结构如下图所示:

    STN:在训练ALM的过程中,因为现有的数据集都没有标注各行人属性对应的bounding box的位置,因此作者采用了弱监督的方式进行ALM的训练。具体来说就是使用STN。STN是一个可微的模型,可以对feature map进行空间变换(裁剪、平移、缩放等)。本文中,作者使用了简化版本的STN,因为和某个属性相关的感兴趣区域可以当成一个bounding box进行处理。具体来说,是执行了下面的变换公式:

    sx,sy​是缩放参数,tx,ty是平移参数, (xi^s,yi^s)和(xi^t,yi^t)是第i 个像素的原始坐标和变换后的坐标。上面这个简化后的变换可以当成是一个可微的ROI池化,可以在未标注区域的情况下进行端到端的训练。为了加速收敛,作者限制sx​,sy​∈(0,1),tx​,ty​∈(−1,1),因此可以使用sigmoid和tanh函数得到对应的值。

    channel attention:作者借鉴了SENet中的channel attention的思想,应用1 * 1的卷积操作先进行channel数量缩减,然后再使用1*1卷积进行channel数量的扩充。这是因为,每个ALM的输入都是来自于多个尺度的融合后的特征,如果这些不同尺度的特征对要某个属性的区域定位具有相同的影响力的话,可能不利于属性的定位。比如,针对细粒度的属性,就应该让低层的特征的影响力更大,对于全局的属性,就应该让高层的属性的影响力更大。因此作者使用channel attention的思想,就是想针对每一个尺度的每一个属性,让模型自己去选择最合适的尺度的属性,也就是去选择最合适的channel。

    4.3、deep Supervision

    和常规的深度学习机制相比,深度监督学习不仅在网络的最后输出结果out,同时在网络的中间特征图,经过反卷积和上采样操作,得到和out尺寸一致的输出out_m,然后结合out-m和out,共同训练网络。在GoogleNet中用到了这种学习机制。

    深度卷积的好处:

    1)可加速神经网络收敛,更小化损失

    2)可获得更平滑的卷积核,更明显的模式

    如完整模型结构所示,对四个尺度的输出feature map,作者应用了deep supervison机制进行训练。所谓的deep supervison就是指在训练时,四个尺度的输出都和ground-truth计算损失。这是因为每一个ALM都应该直接根据损失值判定属性区域定位是否准确,如果对四个尺度的输出进行取平均或者取最大值的操作,最终的损失无法衡量每一个尺度对属性区域定位的准确性,可能造成某些尺度的ALM训练不充分。

    在测试决断,四个尺度的输出进行投票,从四个尺度中选择针对某一属性的最精确的区域。

    5、损失函数

    训练过程中,把所有的属性都变成了二分类属性。因此,损失函数使用的加权的sigmoid交叉熵损失。四个尺度的损失之和作为最终的损失。

    6、实验效果

    6.1、数据集和评价指标

    该方法在三个公开的行人属性数据集上进行了评价:

     PETA数据集由19000个图像组成,其中61个为二值属性,4个为多值属性。根据前面的工作[1,25],整个数据集被随机分成三个子集:9500用于训练,1900用于验证,7600用于测试。选择正例比例大于5%的35个属性进行评价。

     RAP数据集包含从26个室内监视摄像机收集的41585个图像,其中每个图像用72个细粒度属性进行注释。根据官方协议,我们将整个数据集分成33268个训练图像和8317个测试图像。选择正例比例大于1%的51个属性进行评价。

     PA-100K数据集是迄今为止用于行人属性识别的最大数据集,其中包含从室外监控摄像头收集的总共100000张行人图像,每张图像都有26个常用属性。根据官方设置[20],整个数据集随机分为80000个训练图像、10000个验证图像和10000个测试图像。

    我们采用两种类型的指标进行评价:

    基于标签:计算平均准确度(mA)作为每个属性的正准确度和负准确度的平均值。

    基于实例:我们采用了四个众所周知的标准,accuracy、precision、召回率和F1分数。mA标准可以表述为:

    6.2、消融实验

    Baseline是指BN-Inception;

    1)前两行可以看出,加上ALM之后有很大提升,并且三个尺度都使用ALM比只对单个尺度使用ALM的提升更大。

    2)对四个尺度的输出feature map像FPN那样进行逐元素的相加操作的效果不如concatenate好。在使用concatenate的基础上加上channel attention之后会有进一步的提升。

    3)deep supervison中取最大值操作的效果要比取均值效果好。

    6.3、可视化ALM学得的和属性相关的区域

    我们显示了六个不同属性的示例,包括抽象属性和具体属性。正如我们所看到的,所提出的ALMs能够成功地将这些具体属性,例如背包、塑料袋和帽子,定位到相应的信息区域,尽管存在极端的遮挡(a,c)或姿势变化(e)。在识别更抽象的属性Clerk和BodyFat时,ALMs倾向于探索更大的区域,因为它们通常需要从整个图像中获取高级语义。

    6.4、对比其他算法

    在三个数据集上都取得了更高的mA和F1值。

    6.5、不同的Attribute-Specific方法

    这项工作最重要的贡献是为每个属性定位一个单独的信息区域,我们称之为Attribute-Specific的,在以前的工作中没有得到很好的研究。在本小节中,我们将通过与其他特定属性的定位方法(如视觉注意力机制和预定义parts)进行比较,以实验来证明我们提出方法的优势。

    与图1中所示的属性不可知的注意力机制和身体parts不同,我们将它们扩展到属性特定的版本进行比较。对于注意力机制,我们用一个空间注意模块来代替所提出的ALM,同时保持其他模块不变,以便进行公平的比较。具体来说,我们像HA-CNN[17]一样,通过一个全局cross-channel averaging layer和一个3×3卷积层,为每个属性生成单独的注意masks。

    对于预定义parts,我们将整个图像分成三个固定部分(头部、上半身和下半身),并使用RoI pooling层提取基于part的特征,然后手动定义attribute-part的关系,例如仅从头部部分识别帽子。关于比较方法的更多细节见附录B。实验结果见表2,如预期的那样,所提出的方法在很大程度上优于其他两种方法(在mA中分别提高了5.3%和3.5%)。为了更好地理解这些差异,我们在图6中可视化了这些定位结果。我们可以看到,由ALMs生成的属性区域是最精确和最有区别的。虽 然注意力机制模型取得了不错的效果,但是生成的注意masks可能会注意到不相关或偏离的区域。预定义parts获得的识别框不能覆盖全部的预期区域,而且还将几乎相同的区域定位在不同的输入图像上。相比之下,本文方法能够成功地处理位置不确定性和姿态变化。我们在图S4中提供了更多的可视化结果。

    相关资源:

    模型参数可视化:https://github.com/utkuozbulak/pytorch-cnn-visualizations

    展开全文
  • 行人属性识别是一个多任务问题,是计算机视觉中的一项流行任务。 通常,深度学习端到端网络来预测属性是解决此问题的基本方法。 为了充分利用深度神经网络,本文提出了一种新颖的网络结构,称为筏块。 筏块不仅可以...
  • 基于动态多任务平衡方法的行人属性识别深度学习网络.pdf
  • 行人属性识别综述(持续学习中)

    千次阅读 2020-04-10 15:15:23
    行人属性识别(Pedestrian Attribute Recognition,PAR),目的是从输入图像中挖掘行人的属性信息,如图1所示。 行人属性识别挖掘得到的是行人的高层语义信息,这些信息和低层特征不同,对视角变换和成像条件的变化比较...
  • 通过弱监督多尺度的属性定位来增强行人属性识别、 摘要 行人属性识别需要定位属性相关的属性来识别属性。现有的方法采用属性不确定的视觉注意或启发式身体部位定位机制来增强局部特征表示,而忽略了使用属性来定义...
  • 行业分类-物理装置-基于注意力模型的行人属性识别方法.zip
  • 行人属性识别 基于VesPA,WPAL的一些行人属性识别方法。 PA-100K和RAP进行培训。
  • 行业分类-作业装置-一种基于多尺度空间校正的行人属性识别方法.7z
  • 行人属性识别是一个预测属性标签的行人从表面图像,这是一个非常具有挑战的任务对于计算机视觉由于差的图像质量和小的训练数据集。它是观察语义行人属性来识别趋向展示语义或空间相关性。属性可以分组使用相关,...
  • 监控场景下的行人属性识别是要预测一系列的属性标签,由于图像质量问题,外表的变化,以及不平衡的标签让他成为了一项很有挑战性的工作。在本文中,我们把它当成是多标签分类并且提出了一种新的基于图卷积神经的方法...
  • 基于改进损失函数的多阶段行人属性识别方法 一、 摘要 文中基于深度学习理论提出多阶段行人属性识别方法,同时探索属性间的正、负相关性。 二、网络结构 三、算法流程 第一阶段   第一阶段将网络最后一个全连接层...
  • Pedestrian Attribute Recognition 行人属性识别 Github开源项目 https://github.com/lanmengyiyu/yolov5-deepmar https://github.com/dangweili/pedestrian-attribute-recognition-pytorch ... ...
  • 行业分类-作业装置-基于注意力机制的行人属性识别方法、系统、装置.7z
  • 中为行人属性识别任务实现的简单基线,评估 Market-1501-attribute 和 DukeMTMC-reID-attribute 数据集。 数据集 您可以从 . 您还需要下载 Market-1501 和 DukeMTMC-reID 数据集。 然后,在您的数据集路径下创建一个...
  • 通过弱监督的多尺度特定属性本地化改善行人属性识别 论文代码“通过弱监督的多尺度特定属性本地化来改善行人属性识别”,ICCV 2019,首尔。 联系人: 或 环境 Python 3.6+ PyTorch 0.4+ 数据集 RAP: : PETA: ...
  • 行人属性识别 PETA数据集

    千次阅读 2018-05-15 15:02:44
    数据集主页(内含数据集下载地址): http://mmlab.ie.cuhk.edu.hk/projects/PETA.html 百度网盘连接: ... 描述:  PETA (PEdesTrian Attribute)数据集包含了8705个行人,共19000张图像(分辨...
  • 行人属性识别纸张列表[ ] 人物属性识别纸质清单 从2014年到2020年在PETA和RAP数据集上的性能比较。我们发现,在两个大型基准数据集上,基线方法CNN-SVM的性能远胜于最近基于深度学习的PAR方法。 有趣的是,我们还...
  • 论文“行人属性识别的本地化指导学习”的源代码。 被接受。 作者 刘鹏泽,,, 最初在具有几个附加层的定制Caffe上实现: CalOverlap :将两个框之间的IoU用作投标和属性框之间的相似性。 参考: CamBox :从CAM中...
  • Attribute-Recognition行人属性识别资料

    千次阅读 2019-09-30 09:31:37
    3.2 基于局部特征的行人属性检测方法 3.2.1 Poselets (ICCV-2011) 3.2.2 PANDA(CVPR-2014) 其中关键poselet采用3.2.1《Describing people: A poselet-based approach to attribute classification》中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,338
精华内容 1,335
关键字:

行人属性识别