chen-xiuwei

烹饪

2026-02-02T00:00:00+00:00

后续记录烹饪技巧。

烹饪菜品分类

肉菜

红烧排骨
姜抄鸡心

素菜

土豆丝

Prompt

2022-12-07T00:00:00+00:00

对Prompt的一个总结。

学习资源

一个总结 ___

目标

暂时写到这，有空了再来补充

Clip

2022-12-07T00:00:00+00:00

对Clip的一个总结。

学习资源

目标

暂时写到这，有空了再来补充

Data Augmentation

2022-09-04T00:00:00+00:00

合适的数据增广方法对于最后模型的精度具有重要的影响，本文总结了常用的数据增广方法。

学习资源

Autoaugment常用基础方法

ShearX(Y)是沿着x/y轴，固定另外一轴进行放射变换的过程
TranslateX(Y)就是在水平/竖直两个方向平移图像，
Rotate 旋转也是一种放射变换，围绕着旋转中心旋转一定角度
AutoContrast，Contrast 图像的对比度是指图像明亮的地方与灰暗地方的像素的差别。可以认为扩大差别或者减少。自动增加对比度是指让图像中最大的灰度变为255，最小的灰度变为0，然后依次成比率改变图像的像素。
Invert 是指对图像的像素值全部变成255
Equalize 是指把图像的密度直方图给规则化一下。图像本质上是一组采样数据，我们可以以像素值为划分，观察在每一个像素值上有多少个像素，这就是所谓的图像直方图。可以根据直方图做出F的分布函数，Equalize操作本质上是希望这个分布函数是线性均匀上升到1的，这就是均衡化操作。
Solarize 是指给定一个阈值，对像素值大于阈值的所有像素点做invert操作。
Posterize 把原来每个像素用8比特表示的图像压缩到更少的比特（一个更好的压缩方法是Vector Quantization）
Color 将颜色从RGB空间向HSV空间进行转移，其中V表示明度，S表示饱和度，H表示色调。
Brightness 就是图像的亮度，他是HSV空间的V部分，V为0的时候表示非常暗，越高代表视觉上的越亮
Sharpness 代表图像的锐度。锐度计算是通过图像的梯度进行计算的，即对图像的像素空间进行差分，一般差分值大的部分代表图像变化剧烈，这也就是所谓的边缘部分，增大这些边缘就会显得锐度变大。

其他

————

Cutout,与randomerasing类似，也是通过填充区域，从而将填充区域的图像信息遮挡，有利于提高模型的泛化能力。与RandomErasing不同的是，Cutout使用固定大小的正方形区域，采用全0填充，而且允许正方形区域在图片外。

Incremental Learning

2022-06-24T00:00:00+00:00

Incremental Learning’s Survey,挺长时间没有进行总结了，现在花点时间总结一下近期在做的方向，这段时间主要进行的是对增量学习的研究。

学习资源

目标

借用一篇论文中话” Incremental Learning aims to develop artificially intelligent systems that can continuously learn to address new tasks from new data while preserving knowledge learned from previously learned tasks.
我的理解呢？简单的说就是给你n个不同的任务（n个不同的数据集，disjoint），输入呢？就是这一个个的任务Ti，送入模型（第一个随机化的模型或者上一个任务得到的模型）进行训练，输出呢？就是经过当前任务训练完成的模型。测试就是用最后得到的模型在当前见过的所有的任务上的准确率。

难点

Catastrophic Forgetting

目前主流方法

主要分为三大类：Replay methods、Regularization-based methods、Parameter isolation methods

Replay Methods

这种方法又可以分为Rehearsal、Pseudo Rehearsal、Constrained,其中Rehearsal methods包括了ICarl、ER、SER、TEM、CoPE；Pseudo Rehearsal包括了DGR、PR、CCLUGM、LGM；Constrained包括了GEM、A-GEM、GSS。

Regularization-based methods

这种方法又可以分为Prior focused、Data focused,其中Prior focused包括了EWC、IMM、SI、R-EWC、MAS、Riemannian、Walk；Data focused包括了LWF、LFL、EBLL、DMC。

Parameter isolation methods

这种方法又可以分为Fixed Network、Dynamic Architectures，其中Fixed Network包括了PackNet、PathNet、Piggyback、HAT；Dynamic Architectures包括了PNN、Expert Gate、RCL、DAN。

常用的数据集

CIFAR100数据集，100个类，每个类有600张图片，一般500张用来训练，100张用来测试；
Tiny Imagenet数据集，200个类，每个类总共有600张图片，500张用来训练，50张验证，50张测试；
Imagenet 1k数据集，1000个类，1281167张用来训练，50000张用来验证，100000用与测试。

Low & High level

Low level, 普通的SGD优化
High Level, 将所有Task的数据集放在一起进行训练

目前效果对比

暂时写到这，有空了再来补充

马尔科夫链

2022-02-20T00:00:00+00:00

马尔可夫链的一些基础知识

资源

[百度百科]](https://baike.baidu.com/item/%E9%A9%AC%E5%B0%94%E5%8F%AF%E5%A4%AB%E9%93%BE/6171383?fromtitle=%E9%A9%AC%E5%B0%94%E7%A7%91%E5%A4%AB%E9%93%BE&fromid=4688932&fr=aladdin)
知乎
其他

介绍

马尔科夫链是一个随机过程，未来的状态只与当前的状态有关，与之前的状态无关。
马尔科夫链中随机变量的状态随时间步的变化称为演变或转移（通过转移矩阵或转移图）。
n阶马尔科夫链，其转移矩阵是其所有转移矩阵的连续矩阵乘法。

疑问

转移矩阵最后一列的状态是什么，就是最后一个状态吗？
转移矩阵的第一列元素是当前状态？

基础知识

2021-12-21T00:00:00+00:00

机器学习的一些基础知识

资源

交叉熵

相对熵=交叉熵-信息熵，其中
信息熵表示在结果出来之前对可能产生的信息量的期望（期望就是所有可能结果的概率乘以该对应的结果）。用来衡量事务不确定性的，信息熵越大，事务越具有不确定性。我的理解就是y*与y的不确定性。
相对熵用来表示两个概率分布的差异，当两个随机分布相同时，他们的相对熵为零，当两个随机分布的差别增大时，他们的相对熵也会增大。
交叉熵，由于在机器学习和深度学习中，样本和标签已知，那么信息熵相当于常量，此时，只需拟合交叉熵（此时交叉熵近似与相对熵）。

梯度范数

可以通过惩罚梯度范数来提高模型的泛化能力，原理是 penalizing the gradient norm of loss function is to encourage the optimizer to find a minimum that lies in a relatively flat neighborhood region, since such flat minima have been demonstrated to be able to lead to better model generalization than sharp ones.(becase penalize the gradient norm of loss function would motivate the loss function to have small Lipschitz constant in local. If the loss function has a smaller Lipschitz constant, it would indicate that the loss function landscape is flatter, which in consequence could lead to better model generalization)

zero(one)-shot learning

Zero-shot learning (ZSL) is a problem setup in machine learning, where at test time, a learner observes samples from classes, which were not observed during training, and needs in order to predict the class they belong to. Zero-shot methods generally work by associating observed and non-observed classes through some form of auxiliary information, which encodes observable distinguishing properties of objects.[1] For example, given a set of images of animals to be classified, along with auxiliary textual descriptions of what animals look like, an artificial intelligence (“AI”), which has been trained to recognize horses, but has never been given a zebra, can still recognize a zebra when it also knows that zebras look like striped horses. This problem is widely studied in computer vision, natural language processing, and machine perception.
One-shot learning is an object categorization problem, found mostly in computer vision. Whereas most machine learning-based object categorization algorithms require training on hundreds or thousands of samples, one-shot learning aims to classify objects from one, or only a few, samples.
Few-shot learning means making classification or regression based on a very small number of samples. Few-shot learning is the problem of making predictions based on a limited number of samples. Few-shot learning is different from standard supervised learning. The goal of few-shot learning is not to let the model recognize the images in the training set and then generalize to the test set. Instead, the goal is to learn. The goal of training is not to know what an elephant is and what a tiger is. Instead, the goal is to know the similarity and difference between objects.

Multiple Instance Learning

2021-12-05T00:00:00+00:00

总结Mutlple Intance Learning是一个什么问题？

资源

李保亮对研究生提出的六个建议

2021-11-21T00:00:00+00:00

研究生初期容易出现焦虑，不知自己的工作有没有价值，容易乱想，不知如何下手，感觉一切都在摸索。通过记录一些大牛（过来人）的经验，建议来充实一下。

主题

李保亮，2021年新晋最年轻院士（46岁），来自武汉大学，主要研究从事胆固醇代谢平衡调控的研究
来源百度知识

文章

各位老师，亲爱的同学们：

大家下午好！

非常荣幸作为教师代表在这里发言。首先要热烈祝贺同学们来到武汉大学——这所有着126年厚重历史和人文底蕴的全国最美大学。相较于本科阶段宽口径厚基础的学习，研究生阶段才是你们科研生涯的正式开始，是你们探索自然和人类社会更多未知领域的起点。

习近平总书记强调，高校应该成为使人心静下来的地方，教师要静心从教，学生要静心学习，通过研究学问提升境界，通过读书学习升华气质，以学养人、治心养性。看到你们朝气蓬勃的笑脸，我不禁想起了我的研究生生涯，我的师长、我的同学，以及我带过的学生们。

1997年，我从南京大学毕业后，进入中科院上海生化所读研究生。入学后，发现作为一名研究生其实非常自由，没有老师天天盯着你，有大量自主安排的时间，生活费也很充足，于是也开始和其他同学一样热衷打游戏。

但是，我很快觉得这样不行，太虚度光阴。为了把游戏彻底戒掉，我把游戏光盘扔掉了，把游戏从电脑里彻底删除，还在自己的书桌上贴了个字条：“每天看一篇文献”。我的导师看到后，非常高兴，估计从那时候起他就对我的印象很好，并在此后的科研中给予了我非常多的帮助，我们现在依然有很密切的合作。

所以，我给大家的第一个建议就是：第一印象很重要，要想办法给你的导师留下一个深刻的好印象。

我的研究生导师李伯良老师是个很好的老师。他给我很多自由，也很大方，让我可以探索许多课题和方向。这个阶段的训练教会了我如何来选择新的科研方向，为我将来独立做PI之后开拓新的课题特别有帮助。

由于我在这个阶段坚持读了很多文献，所以我的思维和眼界就非常开阔。我的实验训练是在博士后阶段完成的，和大多数人的科学训练是反着的。

所以，给大家的第二个建议就是：研究生阶段的科学训练没有固定的模式，可能也没有完美的条件，但你一定要利用现有的有利条件尽可能发展自己。

在我研究生毕业前一年多，美国西南医学中心的两位大牛Mike Brown和Joe Goldstein第一次来中国，他们是1985年生物化学领域的诺贝尔奖得主，当时他们在复旦做学术报告，我穿过大半个上海去参加了这个学术会议，主动和他们交谈，正是因为研究生阶段的积累，使我有底气敢于和他们交流。

此后，我获得了他们给我到美国西南医学中心做博后的offer，这是我的科学研究生涯中最重要的经历。所以，我给大家的第三个建议是：不要错过和大牛亲密接触的机会。

在Brown-Goldstein实验室，我受到了最严格的科研训练，他们科学研究的品位、实验设计的严格、对高质量数据的追求等等对我影响特别深。这个阶段养成我坚持一个方向、把一个通路做透的科研习惯。

3年博士后期间，我以第一作者发表了1篇MC，1篇CM，3JBC。但我的工资和去其他地方做博后的同学比较起来，一直是最低的。我很庆幸我没有因为工资高低原因选择其他的实验室，否则我不可能学习到这么多东西，不可能成长这么快。所以，我的第四个建议是不要让金钱左右你的选择，牺牲了长远的事业发展。

2014年，我从中科院来到武汉大学，这里的师生在各种艰难困苦的环境中孜孜以求追求科学真理、勇攀科学高峰的精神深深感染着我。朱英国院士就是其中最杰出的代表，这位农田院士始终将习总书记“科技兴农，粮食安全要靠自己”的殷切嘱托牢记心头，年近古稀还坚持在农田、在实验室潜心研究，将自己的一生献给了祖国的粮食安全事业。在庆祝中华人民共和国成立70周年活动中，学校以他的事迹为原型，拍摄的电影即将和同学们见面，他的高尚精神将激励我们不断前行。

几年来，生科院从海内外引进了院士、杰青等各类高层次人才24人次，新增分子生物学与遗传学、免疫学、微生物学三个学科进入ESI排名前1%，在Science、Cell顶尖杂志上论文发表获得重大突破，年均高水平论文20篇以上。

朱玉贤院士曾自信的和我说：如今在我们实验室培养出的研究生，已经毫不逊色在美国培养的研究生！

在我带的研究生中，有2个我认为他们是非常优秀的。

一个特别喜欢问问题，他一直在思考课题，他经常会来给我说“宋老师，我又有一个想法”，他寒假回家回来会给我一页纸写满他的想法。

另一个特别勤奋，特别能做实验，通常大多数同学会从我布置的实验中挑1-2个简单的做，而她是把我建议的实验全部都做，我们每周的组会，她的结果总是其他人的几倍。最后这两个人都发表了高水平的科研论文。

给大家的第五个建议是，勤于动脑、勤于动手，找一个你身边的优秀的人，以他作为你的榜样，每一个细节你都要做到和他一样好，甚至更好。

在这里，我想分享下认识过的大师——北大程和平院士。他的背景是物理和电子，他把背景知识优势在生物学领域应用到极致。他在研究生阶段最早接触到双光子显微镜，一直设想要把这个显微镜小型化。2018年，他们成功做出了2.2克的双光子显微镜，可以装在动物的头上记录脑内的神经活动。

在此，给大家的第六个建议是，做科研脑子里要装着一两个非常前沿甚至是异想天开的科学问题，等将来条件成熟或者你哪天灵光一闪，你就有可能找到突破点来攻克这个难关。

当今时代，是近几百年以来我们中华民族的科技水平最接近世界最高水平的时候，我们在科技方面的进步和前进速度是举世公认的，我们国家对人才和科技的重视程度也是前所未有的。9月2号，我有幸与窦贤康校长一起参加了国家杰出青年科学基金工作座谈会，切身感受到国家领导人对基础研究的重视，对年轻人才的重视。李克强总理希望“青年人才勇闯科研‘无人区’，催生更多科技‘奇果异香’”。

同学们，树立理想是很容易的，但为理想而奋斗是艰难的，这里，我借用舒红兵院士的话，“真正将科研视作自己的事业和生命，可能会累，但不会觉得苦”！科学研究是不断挑战你的智力和毅力极限的过程，希望你们都能够承担起这个光荣的历史使命，为建设创新型国家作出更大贡献。

谢谢大家！

其他

他总是能给出很好的建议。王琰认为，近几年全球顶尖期刊连续发表了宋保亮团队一系列重要研究成果，是对其学术水平的最好评价。

把研究课题做到极致，这既是宋保亮对自己的科研要求，也是他对每一位学生的要求。”无论是实验数据指标，还是课题完成指标，我们都要求把数据做得更准确，课题挖得更深入，在所在领域的研究更进一步。” 宋保亮说。

我们刻意追求解决领域里最基本最关键的科学问题，刻意追求和人、疾病相关的科学问题，符合这些研究方向的，我们都会努力做。如果不符合，我们不会做。

在宋保亮看来，做好这两个 “ 刻意追求 “，需要不断走出自己的舒适区，在研究方法和思路上不断创新，尽管过程艰难，但这样才会不断提高和突破。

在博士后陈亮和博士生肖健看来，两个 “ 刻意追求 “是对生物学家和社会大众的两个受众群体的关照，秉承的是学有所用的理念，为的是让基础研究成果服务社会大众。

正是基于这样的学术研究价值取向，宋保亮在20多年从事胆固醇代谢研究中，已取得一系列引领该领域的原创性成果：2015年发现细胞内胆固醇运输的新通路；2017 年发现胆固醇可以共价修饰蛋白；2018 年发现高血脂的 “ 保护基因 “…… 这些研究发现，为预防和治疗过氧化物酶体紊乱疾病、肝癌和心脑血管疾病等提供了新的可能和路径。

” 宋老师工作异常勤奋，他始终把培养学生放在第一位。”武汉大学生命科学学院副教授罗婕介绍，只要宋保亮在武汉，他一定是实验室去得最早和走得最晚的一个，即使不在，他也会给同学打电话聊实验进展。

为了让学生专心钻研课题，实验室专门聘请了铺细胞、饲养小鼠和清洗器皿的三位工作人员。宋保亮经常说，作为老师要多鼓励学生，包容学生试错。

” 在科研上，宋老师对学生倾囊相授，甚至是其他院系的学生，只要是想做科研，宋老师都欢迎他们使用实验室，而不设任何门槛。”博士生赵南告诉记者，家庭比较困难的学生如果想做兼职，他会推荐其担任实验共享平台助理管理员或者课程助管。

” 成为一个高尚的人、一个有用的人、一个有精神追求的人。”是宋保亮对研究生的寄语。

一起共勉！

行人重识别

2021-07-16T00:00:00+00:00

记录一下学习行人重识别过程中比较好的资源以及自己的一些理解（后续不断补充）

学习资源

代码

代码主要参考了罗浩老师的deep-reid-baseline, 代码中有很多的注释，便于自己的理解

###暂时写到这，有空继续补充。

YOLOv3训练WIDERFACE数据集

2021-05-28T00:00:00+00:00

本文主要是基于上一篇YOLOv3训练WIDERFACE数据集而补充的知识，上一篇中使用了YOLOv3的官网代码进行训练的，本文中将说明使用Tensorflow和keras进行训练,主要是基于Lilnux下，在Windows下也可以运行，只不过对于路径的问题，需要修改一下，详见文章底部。

参考资源

Tensorflow代码资源

Keras+Tensorflow代码资源

代码下载

参考上面代码链接，下载相关代码，可以直接使用git下载，也可以下载到本地后上传到服务器上。

环境要求

服务器上使用的python版本为3.6，Tensorflow版本为1.14.1，记得1.14之前版本的是下载不成功的，Keras版本为2.1.5，numpy版本为1.19.2，其他环境根据自己的需求下载即可，上面的环境是部署在服务器上的，运行代码没有问题。

Tensorflow不推荐使用2.0版本以上的，之前使用过2.0版本以上的，报错是很难解决的，网上的解决方法特别少，过一段时间可能就好了。

Windows10下的python版本为3.7，Tensorflow-GPU版本为1.14.1，Keras版本也是2.1.5

由于代码中有详细的使用步骤，在此就不赘述了，下面记录一下运行过程中的问题。

权重文件

YunYang大佬的代码中，对你下载的.weights文件（可能是yolov3.weights、darknet53.weights、darknet53.conv.74），首先进行convert_weights(或者是from_darknet_weights_to_cpkt)操作，转换成Tensorflow样式的权重文件，转换之后，你可以进行相应的操作，但是如果你想检测图片，不管是使用原先的Tensorflow样式的权重文件还是你训练出来的权重文件，都得经过freeze_graph（或者from_darknet_weights_to_pb）操作，生成pb文件，因为检测代码中使用的正是pb文件。
qqwwee大佬的代码中，对权重文件进行convert操作后转换成了h5文件，进行相应的操作。

保存检测结果

服务器中无法直接显示图片，你可以保存下检测结果进行查看，修改代码如下：

YunYang大佬中的，在image_demo中修改，文档中的最后处

image = Image.fromarray(image)
image.save('./picture/output.jpg')
#image.show()

qqwwee大佬中的，在yolo_video中第16行处

 r_image = yolo.detect_image(image)
          r_image.show()
          r_image.save('./picture/output.jpg')

遇到的问题

在运行qqwwee大佬检测视频的时候，输入一段视频，会报一个错误，具体忘了是什么错误了，需要修改的地方是视频输出路径中必须有数字，如下：
```
def detect_video(yolo, video_path, output_path="./output001.mp4"):
```

目前想到的问题就这么多，后续继续补充。

如有问题，欢迎交流！

YOLOv3在WIDERFACE数据集测试自己的模型

2021-05-28T00:00:00+00:00

本文主要是在WIDERFACE数据集上评估自己的模型（利用官网代码生成的模型），包括图片的检测、损失函数的绘制、验证集上准确率和召回率的计算以及P-R曲线的绘制。

参考资源

图片的检测

单图片检测部分是比较简单的一个步骤，忘记了源代码中是否有保存检测结果的代码，如果没有自己添加即可。

./darknet detect cfg/yolov3.cfg yolov3.weights data/dog.jpg

损失函数的绘制

这部分的前提应该是你有每次迭代过程的记录文件，可以是nohup命令得出的nohup.out文件，也可以是其他形式的文件。

首先利用extract_log.py文件对nohup.out文件进行处理，取出每次迭代过程的记录文件，去除其他没有用的信息，代码借鉴了参考资源中的代码。运行成功后，会得到下图中的两个文件（我生成了多次）。

# coding=utf-8
# 该文件用来提取训练log，去除不可解析的log后使log文件格式化，生成新的log文件供可视化工具绘图
 
import inspect
import os
import random
import sys
def extract_log(log_file,new_log_file,key_word):
    with open(log_file, 'r') as f:
      with open(new_log_file, 'w') as train_log:
  #f = open(log_file)
    #train_log = open(new_log_file, 'w')
        for line in f:
    # 去除多gpu的同步log
          if 'Syncing' in line:
            continue
    # 去除除零错误的log
          if 'nan' in line:
            continue
          if key_word in line:
            train_log.write(line)
    f.close()
    train_log.close()
 
extract_log('train_yolov3.log','train_log_loss.txt','images')
extract_log('train_yolov3.log','train_log_iou.txt','IOU')

运行train_loss_visualization.py文件，绘制loss函数图像，代码也是参考资源中的，此时就会出现你所需要的图像。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#%matplotlib inline
 
lines =50000    #改为自己生成的train_log_loss.txt中的行数
result = pd.read_csv('train_log_loss.txt', skiprows=[x for x in range(lines) if ((x%10!=9) |(x<1000))] ,error_bad_lines=False, names=['loss', 'avg', 'rate', 'seconds', 'images'])
result.head()
 
result['loss']=result['loss'].str.split(' ').str.get(1)
result['avg']=result['avg'].str.split(' ').str.get(1)
result['rate']=result['rate'].str.split(' ').str.get(1)
result['seconds']=result['seconds'].str.split(' ').str.get(1)
result['images']=result['images'].str.split(' ').str.get(1)
result.head()
result.tail()
 
# print(result.head())
# print(result.tail())
# print(result.dtypes)
 
print(result['loss'])
print(result['avg'])
print(result['rate'])
print(result['seconds'])
print(result['images'])
 
result['loss']=pd.to_numeric(result['loss'])
result['avg']=pd.to_numeric(result['avg'])
result['rate']=pd.to_numeric(result['rate'])
result['seconds']=pd.to_numeric(result['seconds'])
result['images']=pd.to_numeric(result['images'])
result.dtypes
 
 
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(result['avg'].values,label='avg_loss')
# ax.plot(result['loss'].values,label='loss')
ax.legend(loc='best')  #图列自适应位置
ax.set_title('The loss curves')
ax.set_xlabel('batches')
fig.savefig('avg_loss')
# fig.savefig('loss')

绘制损失函数的图像就上述两个操作，同理，绘制IOU图像也是类似的，只需要运行参考链接中的train_IOU_visualization.py文件即可。

使用Fast R-CNN代码中的方法计算准确率

这是我第一个使用的计算准确率的方法，虽然处理预测文件的时候，我去除了非人脸信息的检测结果，也设置了相应的阈值，但是很奇怪的是计算出的准确率离奇的低。

从上述参考资源处下载voc_eval.py和reval_voc_py3.py文件
利用官网代码对验证集的图片进行检测，默认生成comp4_det_test_face.txt(在results文件夹下)

./darknet detector valid cfg/voc.data cfg/yolov3-voc.cfg backup/yolov3-voc_final.weights -out car.txt -gpu 0 -thresh .5

运行reval_voc_py3.py代码，会得到各个类别的AP值，以及mAP值。

每次检测后都会在voc2007数据集文件夹下生成一个annotation的文件，需要再次检测时，得把它删除，不然报错。

python3.6 reval_voc_py3.py  --voc_dir /home/amax/cxw/darknet-master/voc/VOCdevkit --year 2007 --image_set test --classes data/voc-my.names  Testforpr

绘制p-r曲线

上一步骤中，已经求得了准确率和召回率的值，并保存在了pkl文件中，绘制p-r曲线时，只需要加载上这个文件即可。

# coding=utf-8
import _pickle as cPickle
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = [u'NSimSun']
plt.rcParams['axes.unicode_minus'] = False
fr = open('tower_pr.pkl', 'rb')  # 这里open中第一个参数需要修改成自己生产的pkl文件
inf = cPickle.load(fr)
fr.close()

# fbad = open('tower_pr.pkl','rb')#这里open中第一个参数需要修改成自己生产的pkl文件
# inf_bad = cPickle.load(fbad)
# fbad.close()


x = inf['rec']
y = inf['prec']
plt.figure()
plt.xlabel('召回率', size=15)
plt.ylabel('精确率', size=15)
plt.xticks(fontproperties='Times New Roman', size=14)
plt.yticks(fontproperties='Times New Roman', size=14)

plt.plot(x, y)

plt.savefig("PR曲线.svg", bbox_inches='tight')  # plt保存需要在show之前
plt.show()

print('AP：', inf['ap'])

利用一个更直观的方法计算AP值

AP值的计算无非就是将验证集的检测结果同原数据进行对比，设置相应的阈值，计算数据即可。

首先是要对验证集上的检测结果进行处理，将每幅图片检出的人脸保存到每一个txt文件中，有多少张图片就会有多少txt文件。代码如下：

import os
 
# txt_file为配置文件.data中的valid
txt_file = '/home/amax/cxw/darknet-master/scripts/2007_val.txt'
f = open(txt_file)
lines = f.readlines()
for line in lines:
    line = line.split('/')[-1][0:-5]
    # test_out_file 为转换后保存的结果地址
    test_out_file = '/home/amax/cxw/darknet-master/testresults'
    # 下面3个with需要自己的修改，修改成自己对应的类别
    with open(os.path.join(test_out_file , line + '.txt'), "a") as new_f:
        f1 = open('/home/amax/cxw/darknet-master/results/comp4_det_test_face.txt', 'r')
        f1_lines = f1.readlines()
        for f1_line in f1_lines:
            f1_line = f1_line.split()
            if line == f1_line[0]:
                new_f.write("%s %s %s %s %s %s\n" % ('smoke', f1_line[1], f1_line[2], f1_line[3], f1_line[4], f1_line[5]))

同理对你原先的标注数据集进行相应的处理，也处理成上述的格式，便于比较，注意其中的Labels文件是经过归一化处理之后的文件了，要进行相应的复原操作。

import os
from PIL import Image
import numpy as np
# label_img为数据集的labels地址，img_path为数据集images的地址
label_img = '/home/amax/cxw/darknet-master/voc/VOCdevkit/VOC2007/labels'
img_path = '/home/amax/cxw/darknet-master/voc/VOCdevkit/VOC2007/JPEGImages'
classes = {
    0:'smoke',
    1:'white',
    2:'red'
}
for line in lines:
    line = line.split('/')[-1][0:-5] + '.txt'
    txt = label_img + line
    img = np.array(Image.open(img_path + line.split('/')[-1][0:-4] + '.jpg'))
    sh, sw = img.shape[0], img.shape[1]
    # gt_out_file为转换后的地址
    gt_out_file = '/home/amax/cxw/darknet-master/yoloresults'
    with open(os.path.join(gt_out_file , line ), "a") as new_f:
        f1 = open(txt)
        f1_lines = f1.readlines()
        for f1_line in f1_lines:
            f1_line = f1_line.split()
            x = float(f1_line[1]) * sw
            y = float(f1_line[2]) * sh
            w = float(f1_line[3]) * sw
            h = float(f1_line[4]) * sh
            xmin = x+1-w/2
            ymin = y+1-h/2
            xmax = x+1+w/2
            ymax = y+1+h/2
            new_f.write("%s %s %s %s %s\n" % (classes[int(f1_line[0])], xmin ,ymin,xmax,ymax))

执行如下代码，可以计算出标注人脸框、检测出的总人脸框、检测正确的人脸框和检测错误的人脸框，可以根据自己的需要设置相应的阈值，所谓的阈值就是利用交并比判定是否是人脸框的标准，大于阈值的判定为人脸框，否则不是人脸框。

import os
 
 
def compute_IOU(rec1, rec2):
    """
    计算两个矩形框的交并比。
    :param rec1: (x0,y0,x1,y1)      (x0,y0)代表矩形左上的顶点，（x1,y1）代表矩形右下的顶点。下同。
    :param rec2: (x0,y0,x1,y1)
    :return: 交并比IOU.
    """
    left_column_max = max(rec1[0], rec2[0])
    right_column_min = min(rec1[2], rec2[2])
    up_row_max = max(rec1[1], rec2[1])
    down_row_min = min(rec1[3], rec2[3])
    # 两矩形无相交区域的情况
    if left_column_max >= right_column_min or down_row_min <= up_row_max:
        return 0
    # 两矩形有相交区域的情况
    else:
        S1 = (rec1[2] - rec1[0]) * (rec1[3] - rec1[1])
        S2 = (rec2[2] - rec2[0]) * (rec2[3] - rec2[1])
        S_cross = (down_row_min - up_row_max) * (right_column_min - left_column_max)
        return S_cross / (S1 + S2 - S_cross)
 
# gt为yolo数据转换后的地址
gt = '/home/amax/cxw/darknet-master/yoloresults/'
# test为检测结果转换后的地址
test = '/home/amax/cxw/darknet-master/testresults/'
# count_gt为标注的所有数据框
count_gt = {
 
}
# count_test为检测的所有数据框
count_test = {
 
}
# count_yes_test为检测正确的数据框
count_yes_test = {
 
}
# count_no_test为检测错误的数据框
count_no_test = {
 
}
# 计数
for gt_ in os.listdir(gt):
    txt = gt + gt_
    f = open(txt)
    lines = f.readlines()
    for line in lines:
        line = line.split()
        name = line[0]
        if name not in count_gt:
            count_gt[name] = 0
        count_gt[name] += 1
for test_ in os.listdir(test):
    txt = test + test_
    f = open(txt)
    lines = f.readlines()
    for line in lines:
        line = line.split()
        name = line[0]
        if name not in count_test:
            count_test[name] = 0
        count_test[name] += 1
# 下面主要思想：遍历test结果，再遍历对应gt的结果，如果两个框的iou大于一定的阙址并且类别相同，视为正确
for test_ in os.listdir(test):
    f_test_txt = test + test_
    f_test = open(f_test_txt)
    f_test_lines = f_test.readlines()
    for f_test_line in f_test_lines:
        f_test_line = f_test_line.split()
        f_gt_txt = gt + test_
        f_gt = open(f_gt_txt)
        f_gt_lines = f_gt.readlines()
        flag = 1
        for f_gt_line in f_gt_lines:
            f_gt_line = f_gt_line.split()
            IOU = compute_IOU([float(f_gt_line[1]), float(f_gt_line[2]), float(f_gt_line[3]), float(f_gt_line[4])],
                              [float(f_test_line[2]), float(f_test_line[3]), float(f_test_line[4]), float(f_test_line[5])])
            if f_gt_line[0] == f_test_line[0] and IOU >= 0.5 and float(f_test_line[1]) >= 0.3:
                flag = 0
                if f_test_line[0] not in count_yes_test:
                    count_yes_test[f_test_line[0]] = 0
                count_yes_test[f_test_line[0]] += 1
 
        if flag == 1:
            if f_test_line[0] not in count_no_test:
                count_no_test[f_test_line[0]] = 0
            count_no_test[f_test_line[0]] += 1
# 有以下4个结果，就可以计算相关指标了
print(count_gt)
print(count_test)
print(count_yes_test)
print(count_no_test)

注意修改文件的路径，第三部分介绍的计算准确率的方法比利用Fast R-CNN的方法简单，没有详细的研究第二部分的方法，有时间再去补充。

如有问题，欢迎交流！

YOLOv3训练WIDERFACE数据集

2021-05-27T00:00:00+00:00

本文主要描写了使用官网给出的YOLOv3目标检测模型（也就是使用darknet)，在Linux下对WIDERFACE数据集进行训练，以此来实现人脸检测的任务。

参考链接

https://www.cnblogs.com/Assist/p/11091501.html

https://blog.csdn.net/lilai619/article/details/79695109

https://blog.csdn.net/sunqiande88/article/details/102414883

其他资源

YOLOv3官网

YOLOv3源码

YOLOv3论文

算法下载及使用

YOLOv3源码既可以在Linux下使用，也可以在Windows下使用，Windows的使用可以参考链接中的使用方法，本文是基于Linux下使用的。

首先从YOLOv3源码处，下载源码，参考上面其他资源处，可以使用git下载，也可以在本地下载后，上传到服务器中。下载后会出现下面的各个文件：

下载后，需要进行make操作，修改Makefile文件,如下图：

首先修改第一处，如上图，可以修改GPU=1，表示使用GPU，CUDNN=1，表示使用CUDN加速，下面的同理，我在运行时，只使用了GPU=1，速度已经可以达到我的要求。

修改第二处，NVCC的位置，将后面的nvcc修改成自己nvcc在服务器上的位置,如下图

目前为止，算法已经可以在本地运行，可以输入./darknet，观察输出结果，如果输出为下图，证明此部分工作已经完成。

数据集进行处理，生成训练和验证的图片路径

下载的YOLOv3代码中包含了voc_label.py文件，这个文件就是用于生成训练图片路径的代码，我修改后的代码如下，修改的地方主要就是数据集的路径，总共修改了8处，最后一行代码也可以根据自己的需求进行修改。

import xml.etree.ElementTree as ET
import pickle
import os
from os import listdir, getcwd
from os.path import join

sets=[ ('2007', 'train'), ('2007', 'val')]   #修改处1

classes = ["face"]                           #修改处2


def convert(size, box):
    dw = 1./(size[0])
    dh = 1./(size[1])
    x = (box[0] + box[1])/2.0 - 1
    y = (box[2] + box[3])/2.0 - 1
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = x*dw
    w = w*dw
    y = y*dh
    h = h*dh
    return (x,y,w,h)

def convert_annotation(year, image_id):
    in_file = open('/home/amax/cxw/tensorflow-yolov3-master/voc/train/VOCdevkit/VOC%s/Annotations/%s.xml'%(year, image_id))   #修改处3
    out_file = open('/home/amax/cxw/tensorflow-yolov3-master/voc/train/VOCdevkit/VOC%s/labels/%s.txt'%(year, image_id), 'w')  #修改处4
    tree=ET.parse(in_file)
    root = tree.getroot()
    size = root.find('size')
    w = int(size.find('width').text)
    h = int(size.find('height').text)

    for obj in root.iter('object'):
        difficult = obj.find('difficult').text
        cls = obj.find('name').text
        if cls not in classes or int(difficult)==1:
            continue
        cls_id = classes.index(cls)
        xmlbox = obj.find('bndbox')
        b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text), float(xmlbox.find('ymax').text))
        bb = convert((w,h), b)
        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')

wd = "/home/amax/cxw/tensorflow-yolov3-master/voc/train"        #修改处5

for year, image_set in sets:
    if not os.path.exists('/home/amax/cxw/tensorflow-yolov3-master/voc/train/VOCdevkit/VOC%s/labels/'%(year)):                      #修改处6
        os.makedirs('/home/amax/cxw/tensorflow-yolov3-master/voc/train/VOCdevkit/VOC%s/labels/'%(year))                             #修改处7
    image_ids = open('/home/amax/cxw/tensorflow-yolov3-master/voc/train/VOCdevkit/VOC%s/ImageSets/Main/%s.txt'%(year, image_set)).read().strip().split()    #修改处8
    list_file = open('%s_%s.txt'%(year, image_set), 'w')
    for image_id in image_ids:
        list_file.write('%s/VOCdevkit/VOC%s/JPEGImages/%s.jpg\n'%(wd, year, image_id))
        convert_annotation(year, image_id)
    list_file.close()

os.system("cat 2007_train.txt 2007_val.txt > train.txt")

执行成功之后，可以看到生成了如下图的三个文件。

使用K均值聚类算法得到自己的anchors

这一部分你可能觉得很突兀，但这是为了下一章节修改anchors需要的工作，这个部分你可以先跳过，当需要的时候再回到这。

下载k-means算法或者k-means++算法对WIDERFACE数据集进行聚类，由于时间的关系，忘记是从哪下载的代码了，应该是下面的代码，记得有一个代码是不成功的（但愿不是这一个）。


import numpy as np

class YOLO_Kmeans:

    def __init__(self, cluster_number, filename):
        self.cluster_number = cluster_number
        self.filename = "voc_train.txt"

    def iou(self, boxes, clusters):  # 1 box -> k clusters
        n = boxes.shape[0]
        k = self.cluster_number

        box_area = boxes[:, 0] * boxes[:, 1]
        box_area = box_area.repeat(k)
        box_area = np.reshape(box_area, (n, k))

        cluster_area = clusters[:, 0] * clusters[:, 1]
        cluster_area = np.tile(cluster_area, [1, n])
        cluster_area = np.reshape(cluster_area, (n, k))

        box_w_matrix = np.reshape(boxes[:, 0].repeat(k), (n, k))
        cluster_w_matrix = np.reshape(np.tile(clusters[:, 0], (1, n)), (n, k))
        min_w_matrix = np.minimum(cluster_w_matrix, box_w_matrix)

        box_h_matrix = np.reshape(boxes[:, 1].repeat(k), (n, k))
        cluster_h_matrix = np.reshape(np.tile(clusters[:, 1], (1, n)), (n, k))
        min_h_matrix = np.minimum(cluster_h_matrix, box_h_matrix)
        inter_area = np.multiply(min_w_matrix, min_h_matrix)

        result = inter_area / (box_area + cluster_area - inter_area)
        return result

    def avg_iou(self, boxes, clusters):
        accuracy = np.mean([np.max(self.iou(boxes, clusters), axis=1)])
        return accuracy

    def kmeans(self, boxes, k, dist=np.median):
        box_number = boxes.shape[0]
        distances = np.empty((box_number, k))
        last_nearest = np.zeros((box_number,))
        np.random.seed()
        clusters = boxes[np.random.choice(
            box_number, k, replace=False)]  # init k clusters
        while True:

            distances = 1 - self.iou(boxes, clusters)

            current_nearest = np.argmin(distances, axis=1)
            if (last_nearest == current_nearest).all():
                break  # clusters won't change
            for cluster in range(k):
                clusters[cluster] = dist(  # update clusters
                    boxes[current_nearest == cluster], axis=0)

            last_nearest = current_nearest

        return clusters

    def result2txt(self, data):
        f = open("yolo_anchors.txt", 'w')
        row = np.shape(data)[0]
        for i in range(row):
            if i == 0:
                x_y = "%d,%d" % (data[i][0], data[i][1])
            else:
                x_y = ", %d,%d" % (data[i][0], data[i][1])
            f.write(x_y)
        f.close()

    def txt2boxes(self):
        f = open(self.filename, 'r')
        dataSet = []
        for line in f:
            infos = line.split(" ")
            length = len(infos)
            for i in range(1, length):
                width = int(infos[i].split(",")[2]) - \
                    int(infos[i].split(",")[0])
                height = int(infos[i].split(",")[3]) - \
                    int(infos[i].split(",")[1])
                dataSet.append([width, height])
        result = np.array(dataSet)
        f.close()
        return result

    def txt2clusters(self):
        all_boxes = self.txt2boxes()
        result = self.kmeans(all_boxes, k=self.cluster_number)
        result = result[np.lexsort(result.T[0, None])]
        self.result2txt(result)
        print("K anchors:\n {}".format(result))
        print("Accuracy: {:.2f}%".format(
            self.avg_iou(all_boxes, result) * 100))


if __name__ == "__main__":
    cluster_number = 9
    filename = "voc_train.txt"
    kmeans = YOLO_Kmeans(cluster_number, filename)
    kmeans.txt2clusters()

需要修改一下自己的filename，改成自己的路径，结果会输出九组anchors，同时还会输出一个概率，一般是70%左右（记得）。

修改配置文件

此部分需要修改.data、.names、.cfg等文件，修改成适合单目标检测（face），文件中的random属性可以设置为0（显存比较小的时候，此部分位于三个[yolo]处，下文）

修改names文件
- names文件处于data文件夹下，可以新建一个names文件，里面内容只写入face一个属性，如下图：

修改data文件
- data文件处于cfg文件下，可以新建一个data文件，打开后如下图：

- 修改classes=1，只进行人脸检测
- 修改train和valid路径，本文上一步生成的三个文件中的前两个的路径
- 修改names路径，本章节第一小步修改的names文件路径
- backup属性可以不用修改，它的用途忘记了，健忘

修改cfg文件
- 修改batch、subdivisions属性，分为test和train两部分，由于是进行训练，因此修改如下：

> 其中batch需要根据自己电脑的配置进行修改，服务器一般可以使用64，32，自己的电脑可能要低一些，16，32都可，根据自己的需求,subdivisions也得根据自己的电脑修改，如果太高，会严重消耗CPU资源。

修改learning_rate,学习率可以使用多种策略，（可以上网百度，查看各种策略的区别），如下图

> 此部分使用了step策略，初始学习率设置为0.001，40000步后学习率降低为0.0001，45000步后学习率降低为0.00001，可以根据自己的需求进行调整，

修改anchors，classes和filters属性，此部分总共需要修改三处，每处三个属性，从文件的最后面向前，三部分[yolo]处，如下图

> 前面K均值聚类算法得到的九组anchors就是用于此部分的，修改成先前得到的九组anchors；修改classes为1，filters为18（（1+5）*3）。

前面的准备工作已经结束，下一步进行数据集的训练。

下载预训练权重

预训练权重可以使用darknet53的权重，此权重已经包含了最主要的网络结构，便于模型的扩展，并且文件还小。

下载链接

进行数据集的训练

对数据集进行训练，可以在后台执行，使用nohup等命令。

使用官网命令如下,我使用的服务器上有两块GPU，因此为0，1

./darknet detector train cfg/voc.data cfg/yolov3-voc.cfg darknet53.conv.74 -gpus 0,1

查看nohup.out文件，查看中间过程，如下图：

如果训练到中间，因其他原因导致服务器意外关闭，可以加载上已经训练出的模型权重，重新训练，如下代码
```
./darknet detector train cfg/voc-my.data cfg/yolov3-voc-my.cfg backup/yolov3-voc-100000.weights -gpus 0,1
```
其中，训练出的模型权重保存在backup文件夹下。

使用nohup命令如下

nohup ./darknet detector train cfg/voc.data cfg/yolov3-voc.cfg darknet53.conv.74 -gpus 0,1 &

如果出现没有权限，把错误百度，有解决方法。

到目前为止，训练的过程已经结束，当你理解YOLOv3模型和训练过程的参数的含义后，下一步就是常说的“炼药”的过程了，修改自己的学习率，batch等参数让自己的模型更精确。

可能遇到的错误

其他错误，一般都能在网上百度到，博客的连接中也写明了大部分的错误，如果make阶段出现错误，建议只开GPU=1，我使用过程中，由于是老师的服务器，没有大部分的权限，报了很多错误，因此只使用了GPU=1.

你可能出现./darknet: error while loading shared libraries: libcudart.so.10.0: cannot open shared object file: No such file or directory这个错误，解决方法如下：
```
export LD_LIBRARY_PATH=/usr/local/cuda/lib64 && sudo ldconfig
```
通过输入密码后，成功解决了上述错误。

如有问题，欢迎交流！

WIDERFACE数据集转化为VOC格式

2021-05-26T00:00:00+00:00

本文是对WIDERFACE数据集进行预处理，生成YOLOv3代码输入要求的COCO或者VOC格式，在此将其转化成了VOC格式，总体来说，此部分比较简单。

参考链接

https://blog.csdn.net/sunqiande88/article/details/102414883

下载WIDERFACE数据集

数据集官网下载

下载数据集可以从上述官网中下载，也可以直接在网上搜索，可以找到许多百度网盘分享的，下载后可以看到如下内容：

其中WIDER_train为训练集，WIDER_test为测试集，WIDER_val为验证集，wider_face_split包含了人脸框等信息。

训练集、验证集转换为VOC格式

借鉴网上的代码将WIDERFACE数据集转换为VOC格式

# -*- coding: utf-8 -*-

import shutil
import random
import os
import string
from skimage import io

headstr = """\
<annotation>
    <folder>VOC2012</folder>
    <filename>%06d.jpg</filename>
    <source>
        <database>My Database</database>
        <annotation>PASCAL VOC2012</annotation>
        <image>flickr</image>
        <flickrid>NULL</flickrid>
    </source>
    <owner>
        <flickrid>NULL</flickrid>
        <name>company</name>
    </owner>
    <size>
        <width>%d</width>
        <height>%d</height>
        <depth>%d</depth>
    </size>
    <segmented>0</segmented>
"""
objstr = """\
    <object>
        <name>%s</name>
        <pose>Unspecified</pose>
        <truncated>0</truncated>
        <difficult>0</difficult>
        <bndbox>
            <xmin>%d</xmin>
            <ymin>%d</ymin>
            <xmax>%d</xmax>
            <ymax>%d</ymax>
        </bndbox>
    </object>
"""

tailstr = '''\
</annotation>
'''


def writexml(idx, head, bbxes, tail):
    filename = ("Annotations/%06d.xml" % (idx))
    f = open(filename, "w")
    f.write(head)
    for bbx in bbxes:
        f.write(objstr % ('face', bbx[0], bbx[1], bbx[0] + bbx[2], bbx[1] + bbx[3]))
    f.write(tail)
    f.close()


def clear_dir():
    if shutil.os.path.exists(('Annotations')):
        shutil.rmtree(('Annotations'))
    if shutil.os.path.exists(('ImageSets')):
        shutil.rmtree(('ImageSets'))
    if shutil.os.path.exists(('JPEGImages')):
        shutil.rmtree(('JPEGImages'))

    shutil.os.mkdir(('Annotations'))
    shutil.os.makedirs(('ImageSets/Main'))
    shutil.os.mkdir(('JPEGImages'))


def excute_datasets(idx, datatype):

    f = open(('ImageSets/Main/' + datatype + '.txt'), 'a')
    f_bbx = open(('wider_face_split/wider_face_' + datatype + '_bbx_gt.txt'), 'r')

    while True:
        filename = f_bbx.readline().strip('\n')

        if not filename:
            break
        im = io.imread(('WIDER_' + datatype + '/images/' + filename))
        head = headstr % (idx, im.shape[1], im.shape[0], im.shape[2])
        nums = f_bbx.readline().strip('\n')
        bbxes = []
        if nums=='0':
            bbx_info= f_bbx.readline()
            continue
        for ind in range(int(nums)):
            bbx_info = f_bbx.readline().strip(' \n').split(' ')
            bbx = [int(bbx_info[i]) for i in range(len(bbx_info))]
            # x1, y1, w, h, blur, expression, illumination, invalid, occlusion, pose
            if bbx[7] == 0:
                bbxes.append(bbx)
        writexml(idx, head, bbxes, tailstr)
        shutil.copyfile(('WIDER_' + datatype + '/images/' + filename), ('JPEGImages/%06d.jpg' % (idx)))
        f.write('%06d\n' % (idx))
        idx += 1
    f.close()
    f_bbx.close()
    return idx


if __name__ == '__main__':
    clear_dir()
    idx = 1
    idx = excute_datasets(idx, 'val')
    idx = excute_datasets(idx, 'train')
    print('Complete...')

其中main函数中，可以修改val和train来改成自己需要的，前者为验证集，后者为训练集，这部分代码执行是与下载的数据集同一个文件中的。
运行代码，输出Complete…后，查看原来的文件可以看到多了三个文件，如下图，各个文件表示的含义就是VOC格式的文件。

测试集转换为VOC格式

网上搜了很长时间没有找到转换测试集的代码，自己认真分析了上述代码，测试集没有人脸框的标注，原来可以修改上述代码，是自己菜了，代码如下：


import shutil
import random
import os
import string
from skimage import io

headstr = """\
<annotation>
    <folder>VOC2012</folder>
    <filename>%06d.jpg</filename>
    <source>
        <database>My Database</database>
        <annotation>PASCAL VOC2012</annotation>
        <image>flickr</image>
        <flickrid>NULL</flickrid>
    </source>
    <owner>
        <flickrid>NULL</flickrid>
        <name>company</name>
    </owner>
    <size>
        <width>%d</width>
        <height>%d</height>
        <depth>%d</depth>
    </size>
    <segmented>0</segmented>
"""
objstr = """\
    <object>
        <name>%s</name>
        <pose>Unspecified</pose>
        <truncated>0</truncated>
        <difficult>0</difficult>
        <bndbox>
            <xmin>%d</xmin>
            <ymin>%d</ymin>
            <xmax>%d</xmax>
            <ymax>%d</ymax>
        </bndbox>
    </object>
"""

tailstr = '''\
</annotation>
'''




def writexml(idx, head, bbxes, tail):
    filename = ("Annotations/%06d.xml" % (idx))
    f = open(filename, "w")
    f.write(head)
    for bbx in bbxes:
        f.write(objstr % ('face', bbx[0], bbx[1], bbx[0] + bbx[2], bbx[1] + bbx[3]))
    f.write(tail)
    f.close()


def clear_dir():
    if shutil.os.path.exists(('Annotations')):
        shutil.rmtree(('Annotations'))
    if shutil.os.path.exists(('ImageSets')):
        shutil.rmtree(('ImageSets'))
    if shutil.os.path.exists(('JPEGImages')):
        shutil.rmtree(('JPEGImages'))

    shutil.os.mkdir(('Annotations'))
    shutil.os.makedirs(('ImageSets/Main'))
    shutil.os.mkdir(('JPEGImages'))


def excute_datasets(idx, datatype):

    f = open(('ImageSets/Main/' + datatype + '.txt'), 'a')
    f_bbx = open(('wider_face_split/wider_face_' + datatype + '_filelist.txt'), 'r')

    while True:
        filename = f_bbx.readline().strip('\n')

        if not filename:
            break

        shutil.copyfile(('WIDER_' + datatype + '/images/' + filename), ('JPEGImages/%06d.jpg' % (idx)))
        f.write('%06d\n' % (idx))
        idx += 1
    f.close()
    f_bbx.close()
    return idx


if __name__ == '__main__':
    clear_dir()
    idx = 1
    idx = excute_datasets(idx, 'test')
    print('Complete...')

之前转换的代码删了，这部分是自己写博客的时候，凭记忆修改的，如果有问题，可以自己读一下代码。
代码运行提示成功后，可以看到输出了两个文件，如下图，之所以没有以前的几个文件是因为测试集没有人脸框的标注。

总体来说，上述已经完成了WIDERFACE数据集转换为VOC数据集，但是后续代码评估时，你可能需要（有可能，看你的评估模型）labels文件，因此下面是用于生成labels文件的代码。

生成labels文件

下面的代码，就是生成labels文件的代码，实在是忘记从哪下载的了，因此没有在开始处复制链接。


import xml.etree.ElementTree as ET
import os
from os import getcwd

sets = [('2012', 'train'), ('2012', 'val')]

classes = ["face"]

def convert(size, box):
    dw = 1. / size[0]
    dh = 1. / size[1]
    x = (box[0] + box[1]) / 2.0
    y = (box[2] + box[3]) / 2.0
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = x * dw
    w = w * dw
    y = y * dh
    h = h * dh
    return (x, y, w, h)


def convert_annotation(year, image_id):
    in_file = open('VOCdevkit/VOC%s/Annotations/%s.xml' % (year, image_id))
    out_file = open('VOCdevkit/VOC%s/labels/%s.txt' % (year, image_id), 'w')
    tree = ET.parse(in_file)
    root = tree.getroot()
    size = root.find('size')
    w = int(size.find('width').text)
    h = int(size.find('height').text)

    for obj in root.iter('object'):
        difficult = obj.find('difficult').text
        cls = obj.find('name').text
        if cls not in classes or int(difficult) == 1:
            continue
        cls_id = classes.index(cls)
        xmlbox = obj.find('bndbox')
        b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
             float(xmlbox.find('ymax').text))
        bb = convert((w, h), b)
        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')


if __name__ == '__main__':
    wd = getcwd()
    for year, image_set in sets:
        if not os.path.exists('VOCdevkit/VOC%s/labels/' % (year)):
            os.makedirs('VOCdevkit/VOC%s/labels/' % (year))
        image_ids = open('VOCdevkit/VOC%s/ImageSets/Main/%s.txt' % (year, image_set)).read().strip().split()
        list_file = open('%s_%s.txt' % (year, image_set), 'w')
        for image_id in image_ids:
            line = '%s/VOCdevkit/VOC%s/JPEGImages/%s.jpg\n' % (wd, year, image_id)
            list_file.write(line.replace("\\", '/'))
            convert_annotation(year, image_id)
        list_file.close()

运行上述代码之后，可以看到文件夹下多了一个labels文件，里面的信息是归一化后的坐标信息和类别。

到目前为止，转换的工作已经全部完成，下一步就行进行自己的训练了。

如有问题，欢迎交流！

数据库中文乱码

2021-04-15T00:00:00+00:00

主要描写了我使用JDBC连接数据库遇到的问题，其中问题已经解决。

JDBC连接数据库写入数据的编码问题

可能你写入数据库的编码方式不是UTF8，需要修改一下，在你连接的地方添加 ` &characterEncoding=UTF8 `
也可能是你安装的Mysql数据库没有设置编码方式 1.配置文件更改编码方式（my.ini文件) MySQL数据库为5.5.3之前的话，在mysqld下添加 default-character-set=utf8,之后的版本添加 character-set-server=utf8 2.在cmd下更改编码方式查看所有的编码方式，show variables like 'character%; ,会显示出所有的编码方式，修改编码方式，如下：set character_set_client=utf8; 以上便是我所遇到的数据库中文乱码的问题，通过这些方法，成功解决了问题。

VGG网络学习

2021-04-15T00:00:00+00:00

经过一段时间对VGG网络的学习，想记录一下学到的知识。

VGG

VGG：由Oxford的Visual Geometry Group组提出，是2014年ILSVRC竞赛的第二名。
分类：A,A-LRN,B,C,D,E共六个配置（根据卷积核大小和卷积层数目），D,E比较常用，分别称为VGG 16和VGG 19。
参考资料：(https://zhuanlan.zhihu.com/p/41423739)(https://www.cnblogs.com/lfri/p/10493408.html)
模型结构：(https://dgschwend.github.io/netscope/#/preset/vgg-16)
参考代码(tensorflow)：(http://www.cs.toronto.edu/~frossard/post/vgg16/)
训练参考代码(tensorflow)：(https://github.com/machrisaa/tensorflow-vgg)

网络结构

创新点（相比于AlexNet)

采用连续的n个3 x 3的卷积核代替AlexNet中的较大卷积核，比如可以用3个3 x 3的卷积核代替一个7 x 7的卷积核，可以通过图像理解（参考资料中），也可以通过公式计算，比如8 x 8的图像经过一层卷积(步长为1，padding为0)之后输出为6 x 6的图像，再经过一层卷积之后输出为4 x 4，再经过一层之后输出为2 x 2的图像，效果跟一次7 x 7的效果一样。
VGG-16

由13个卷积层，5个池化层，3个全连接层组成，其中卷积核都为3 x 3，池化用的都是2 x 2。
VGG-19

由16个卷积层，5个池化层，3个全连接层组成。

代码

环境

自身电脑的环境为，tensorflow-cpu 2.4.0,numpy 1.19.5 ,scipy 1.1.0
说明

由于tensorflow2.0以上版本的相比于tensorflow2.0以下版本的变化挺大的，直接用2.0以上版本的运行，可能会出问题，问题如下：module tensorflow has no attribute truncated_normal 可以通过添加如下代码：(1)在import下添加tf.compat.v1.disable_eager_execution() ，(2)修改tf.truncated_normal为tf.compat.v1.random.truncated_normal
运行截图（检测图片为黄鼠狼）

如有问题，欢迎交流；如有错误，欢迎指正。

chen-xiuwei

烹饪

Prompt

学习资源

目标

暂时写到这，有空了再来补充

Clip

学习资源

目标

暂时写到这，有空了再来补充

Data Augmentation

学习资源

分类

Autoaugment常用基础方法

其他

Incremental Learning

学习资源

目标

难点

目前主流方法

Replay Methods

Regularization-based methods

Parameter isolation methods

常用的数据集

Low & High level

目前效果对比

暂时写到这，有空了再来补充

马尔科夫链

资源

介绍

疑问

推荐系统

资源

基础知识

资源

交叉熵

梯度范数

zero(one)-shot learning

Multiple Instance Learning

资源

李保亮对研究生提出的六个建议

主题

文章

其他

行人重识别

学习资源

代码

YOLOv3训练WIDERFACE数据集

参考资源

代码下载

环境要求

由于代码中有详细的使用步骤，在此就不赘述了，下面记录一下运行过程中的问题。

权重文件

保存检测结果

遇到的问题

目前想到的问题就这么多，后续继续补充。

如有问题，欢迎交流！

YOLOv3在WIDERFACE数据集测试自己的模型

参考资源

图片的检测

损失函数的绘制

绘制损失函数的图像就上述两个操作，同理，绘制IOU图像也是类似的，只需要运行参考链接中的train_IOU_visualization.py文件即可。

使用Fast R-CNN代码中的方法计算准确率

绘制p-r曲线

利用一个更直观的方法计算AP值

注意修改文件的路径，第三部分介绍的计算准确率的方法比利用Fast R-CNN的方法简单，没有详细的研究第二部分的方法，有时间再去补充。

如有问题，欢迎交流！

YOLOv3训练WIDERFACE数据集

参考链接

其他资源

算法下载及使用

目前为止，算法已经可以在本地运行，可以输入./darknet，观察输出结果，如果输出为下图，证明此部分工作已经完成。

数据集进行处理，生成训练和验证的图片路径

使用K均值聚类算法得到自己的anchors

修改配置文件

前面的准备工作已经结束，下一步进行数据集的训练。

下载预训练权重

进行数据集的训练

到目前为止，训练的过程已经结束，当你理解YOLOv3模型和训练过程的参数的含义后，下一步就是常说的“炼药”的过程了，修改自己的学习率，batch等参数让自己的模型更精确。

可能遇到的错误