制作人脸表情数据集
转自：https://blog.csdn.net/z704630835 https://blog.csdn.net/z704630835/article/details/82992036
一、背景
人脸表情识别网上已有很多教程，大多基于fer2013数据集展开的。现在的问题就在于fer2013数据集的数量太少，表情的区分度不够明显，大部分基于此数据集的模型，其识别精度仅有70%左右。
因此我想自己从零开始制作人脸表情，而且是非常夸张，有趣的人脸表情，用于后续的表情识别实验。这一篇仅仅介绍如何在没有任何数据的情况下，从零开始制作人脸表情数据集。
二、数据获取
首先没有任何数据的情况下，该如何开始数据的获取呢？其实就两种思路：一种是自己采集，例如用摄像头抓帧，另一种是爬虫爬取数据。实验采用爬虫爬取百度图片中的数据。
然后自己设计自己需要的表情，我自己设置了10类。这里以“吃惊”表情为例，在百度图片搜索中可以看到：
有一部分人脸数据，当然还有很多非人脸数据，这里我们先不管那么多，直接全部爬取下来，爬取的程序采用：
-
# 导入需要的库
-
import requests
-
import os
-
import json
-
-
# 爬取百度图片，解析页面的函数
-
def getManyPages(keyword, pages):
-
'''
-
参数keyword：要下载的影像关键词
-
参数pages：需要下载的页面数
-
'''
-
params = []
-
-
for i
in range(
30,
30 * pages +
30,
30):
-
params.append({
-
'tn':
'resultjson_com',
-
'ipn':
'rj',
-
'ct':
201326592,
-
'is':
'',
-
'fp':
'result',
-
'queryWord': keyword,
-
'cl':
2,
-
'lm':
-1,
-
'ie':
'utf-8',
-
'oe':
'utf-8',
-
'adpicid':
'',
-
'st':
-1,
-
'z':
'',
-
'ic':
0,
-
'word': keyword,
-
's':
'',
-
'se':
'',
-
'tab':
'',
-
'width':
'',
-
'height':
'',
-
'face':
0,
-
'istype':
2,
-
'qc':
'',
-
'nc':
1,
-
'fr':
'',
-
'pn': i,
-
'rn':
30,
-
'gsm':
'1e',
-
'1488942260214':
''
-
})
-
url =
'https://image.baidu.com/search/acjson'
-
urls = []
-
for i
in params:
-
try:
-
urls.append(requests.get(url, params=i).json().get(
'data'))
-
except json.decoder.JSONDecodeError:
-
print(
"解析出错")
-
return urls
-
-
# 下载图片并保存
-
def getImg(dataList, localPath):
-
'''
-
参数datallist：下载图片的地址集
-
参数localPath：保存下载图片的路径
-
'''
-
if
not os.path.exists(localPath):
# 判断是否存在保存路径，如果不存在就创建
-
os.mkdir(localPath)
-
x =
0
-
for list
in dataList:
-
for i
in list:
-
if i.get(
'thumbURL') !=
None:
-
print(
'正在下载：%s' % i.get(
'thumbURL'))
-
ir = requests.get(i.get(
'thumbURL'))
-
open(localPath +
'%d.jpg' % x,
'wb').write(ir.content)
-
x +=
1
-
else:
-
print(
'图片链接不存在')
-
-
# 根据关键词来下载图片
-
if __name__ ==
'__main__':
-
dataList = getManyPages(
'吃惊',
20)
# 参数1:关键字，参数2:要下载的页数
-
getImg(dataList,
'./data/chijing/')
# 参数2:指定保存的路径
之前我用这段程序爬取过皮卡丘图像，因此不再多做介绍，详细可以参见：对抗神经网络学习（四）——WGAN+爬虫生成皮卡丘图像(tensorflow实现)。这里爬取好的图像直接保存在根目录下的'./data/chijing/'文件夹中。
同样的思路，可以爬取其余9种表情。
三、人脸裁剪及预处理
爬取完人脸表情之后，我们需要裁剪处图像中的人脸，这里设置裁剪大小为128*128。裁剪过程需要用到opencv的人脸识别工具，即haarcascade_frontalface_alt.xml，关于该文件，可从opencv库的根目录中查找，具体查找方法可以参见我之前的文章：深度学习（一）——deepNN模型实现摄像头实时识别人脸表情（C++和python3.6混合编程）。将该文件复制到project的根目录下，然后裁剪人脸，具体的裁剪程序为：
-
import os
-
import cv2
-
-
# 读取图像，然后将人脸识别并裁剪出来, 参考https://blog.csdn.net/wangkun1340378/article/details/72457975
-
def clip_image(input_dir, floder, output_dir):
-
images = os.listdir(input_dir + floder)
-
-
for imagename
in images:
-
imagepath = os.path.join(input_dir + floder, imagename)
-
img = cv2.imread(imagepath)
-
-
path =
"haarcascade_frontalface_alt.xml"
-
-
hc = cv2.CascadeClassifier(path)
-
-
faces = hc.detectMultiScale(img)
-
i =
1
-
image_save_name = output_dir + floder + imagename
-
for face
in faces:
-
imgROI = img[face[
1]:face[
1] + face[
3], face[
0]:face[
0] + face[
2]]
-
imgROI = cv2.resize(imgROI, (
128,
128), interpolation=cv2.INTER_AREA)
-
cv2.imwrite(image_save_name, imgROI)
-
i = i +
1
-
print(
"the {}th image has been processed".format(i))
-
-
-
def main():
-
input_dir =
"data/"
-
floder =
"chijing/"
-
output_dir =
"output/"
-
-
if
not os.path.exists(output_dir + floder):
-
os.makedirs(output_dir + floder)
-
-
clip_image(input_dir, floder, output_dir)
-
-
-
if __name__ ==
'__main__':
-
main()
如果要将该方法用于其余9种表情，只需自己修改main函数中的相关路径即可。这样裁剪之后的影像中，难免混有一些非人脸图像，只需手动删除即可。这样处理之后的效果为：
四、数据增广
经过以上三步，基本可以得到人脸数据集了，但是有的表情的数据量很少，进行模型训练的时候必然会因为数据不足带来影响，因此还需要进行数据增广处理。
一般地，数据增广处理的方法包括：旋转，镜像，随机裁剪，噪声，变形，颜色变化，对比度拉伸等方法。对于人脸来说，这里所选择的处理方法仅有：镜像，即左右反转；随机裁剪，将128*128影响随机裁剪为120*120，再将其resize成128*128；噪声，添加少量的随机噪声。考虑到人脸数据集的特殊性，其他方法暂时没有选择。
这里直接给出数据增广的代码：
-
# 参考https://blog.csdn.net/qq_36219202/article/details/78339459
-
import os
-
from PIL
import Image,ImageEnhance
-
import skimage
-
import random
-
import numpy
as np
-
import cv2
-
-
-
# 随机镜像
-
def random_mirror(root_path, img_name):
-
img = Image.open(os.path.join(root_path, img_name))
-
filp_img = img.transpose(Image.FLIP_LEFT_RIGHT)
-
filp_img = np.asarray(filp_img, dtype=
"float32")
-
return filp_img
-
-
-
# 随机平移
-
def random_move(root_path, img_name, off):
-
img = Image.open(os.path.join(root_path, img_name))
-
offset = img.offset(off,
0)
-
offset = np.asarray(offset, dtype=
"float32")
-
return offset
-
-
-
# # 随机转换
-
# def random_transform( image, rotation_range, zoom_range, shift_range, random_flip ):
-
# h,w = image.shape[0:2]
-
# rotation = numpy.random.uniform( -rotation_range, rotation_range )
-
# scale = numpy.random.uniform( 1 - zoom_range, 1 + zoom_range )
-
# tx = numpy.random.uniform( -shift_range, shift_range ) * w
-
# ty = numpy.random.uniform( -shift_range, shift_range ) * h
-
# mat = cv2.getRotationMatrix2D( (w//2,h//2), rotation, scale )
-
# mat[:,2] += (tx,ty)
-
# result = cv2.warpAffine( image, mat, (w,h), borderMode=cv2.BORDER_REPLICATE )
-
# if numpy.random.random() < random_flip:
-
# result = result[:,::-1]
-
# return result
-
-
-
# # 随机变形
-
# def random_warp( image ):
-
# assert image.shape == (256,256,3)
-
# range_ = numpy.linspace( 128-80, 128+80, 5 )
-
# mapx = numpy.broadcast_to( range_, (5,5) )
-
# mapy = mapx.T
-
#
-
# mapx = mapx + numpy.random.normal( size=(5,5), scale=5 )
-
# mapy = mapy + numpy.random.normal( size=(5,5), scale=5 )
-
#
-
# interp_mapx = cv2.resize( mapx, (80,80) )[8:72,8:72].astype('float32')
-
# interp_mapy = cv2.resize( mapy, (80,80) )[8:72,8:72].astype('float32')
-
#
-
# warped_image = cv2.remap( image, interp_mapx, interp_mapy, cv2.INTER_LINEAR )
-
#
-
# src_points = numpy.stack( [ mapx.ravel(), mapy.ravel() ], axis=-1 )
-
# dst_points = numpy.mgrid[0:65:16,0:65:16].T.reshape(-1,2)
-
# mat = umeyama( src_points, dst_points, True )[0:2]
-
#
-
# target_image = cv2.warpAffine( image, mat, (64,64) )
-
#
-
# return warped_image, target_image
-
-
-
# 随机旋转
-
def random_rotate(root_path, img_name):
-
img = Image.open(os.path.join(root_path, img_name))
-
rotation_img = img.rotate(
180)
-
rotation_img = np.asarray(rotation_img, dtype=
"float32")
-
return rotation_img
-
-
-
# 随机裁剪
-
def random_clip(root_path, floder, imagename):
-
# 可以使用crop_img = tf.random_crop(img,[280,280,3])
-
img = cv2.imread(root_path + floder + imagename)
-
count =
1
# 随机裁剪的数量
-
while
1:
-
y = random.randint(
1,
8)
-
x = random.randint(
1,
8)
-
cropImg = img[(y):(y +
120), (x):(x +
120)]
-
image_save_name = root_path + floder +
'clip' + str(count) + imagename
-
# BGR2RGB
-
# cropImg = cv2.cvtColor(cropImg, cv2.COLOR_BGR2RGB)
-
cropImg = cv2.resize(cropImg, (
128,
128))
-
cv2.imwrite(image_save_name, cropImg)
-
count +=
1
-
print(count)
-
if count >
3:
-
break
-
-
-
# 随机噪声
-
def random_noise(root_path, img_name):
-
image = Image.open(os.path.join(root_path, img_name))
-
im = np.array(image)
-
-
means =
0
-
sigma =
10
-
-
r = im[:, :,
0].flatten()
-
g = im[:, :,
1].flatten()
-
b = im[:, :,
2].flatten()
-
-
# 计算新的像素值
-
for i
in range(im.shape[
0] * im.shape[
1]):
-
pr = int(r[i]) + random.gauss(means, sigma)
-
pg = int(g[i]) + random.gauss(means, sigma)
-
pb = int(b[i]) + random.gauss(means, sigma)
-
-
if (pr <
0):
-
pr =
0
-
if (pr >
255):
-
pr =
255
-
if (pg <
0):
-
pg =
0
-
if (pg >
255):
-
pg =
255
-
if (pb <
0):
-
pb =
0
-
if (pb >
255):
-
pb =
255
-
r[i] = pr
-
g[i] = pg
-
b[i] = pb
-
im[:, :,
0] = r.reshape([im.shape[
0], im.shape[
1]])
-
im[:, :,
1] = g.reshape([im.shape[
0], im.shape[
1]])
-
im[:, :,
2] = b.reshape([im.shape[
0], im.shape[
1]])
-
gaussian_image = Image.fromarray(np.uint8(im))
-
return gaussian_image
-
-
-
# 随机调整对比度
-
def random_adj(root_path, img_name):
-
image = skimage.io.imread(os.path.join(root_path, img_name))
-
gam = skimage.exposure.adjust_gamma(image,
0.5)
-
log = skimage.exposure.adjust_log(image)
-
gam = np.asarray(gam, dtype=
"float32")
-
log = np.asarray(log, dtype=
"float32")
-
return gam, log
-
-
-
# 运行
-
def main():
-
root_dir =
"output/"
-
floder =
"chijing/"
-
-
images = os.listdir(root_dir + floder)
-
-
for imagename
in images:
-
-
mirror_img = random_mirror(root_dir + floder, imagename)
-
image_save_name = root_dir + floder +
"mirror" + imagename
-
mirror_img = cv2.cvtColor(mirror_img, cv2.COLOR_BGR2RGB)
-
cv2.imwrite(image_save_name, mirror_img)
-
-
random_clip(root_dir, floder, imagename)
-
-
noise_img = random_noise(root_dir + floder, imagename)
-
noise_img = np.asarray(noise_img, dtype=
"float32")
-
image_save_name = root_dir + floder +
"noise" + imagename
-
noise_img = cv2.cvtColor(noise_img, cv2.COLOR_BGR2RGB)
-
cv2.imwrite(image_save_name, noise_img)
-
-
print(
"image preprocessing")
-
-
-
if __name__ ==
'__main__':
-
main()
很多处理方法都是参考网上的代码，只不过我将这些方法整合到了一起。对于其余9种表情，需要设置的仅仅只是main函数种的路径参数。
随机裁剪3张、镜像1张、随机噪声1张的处理结果如下：
最终的“吃惊”表情处理结果：
整个处理之后的数据量还是非常可观的，当然了，如果自己觉得数据量还不够，还可以再进行进一步处理，例如对镜像图像进行随机裁剪，不同程度的噪声影像，以及对比度拉伸等方法。
以上仅仅是一种表情的数据集制作，同理制作其余的表情数据集即可。准备好了数据集之后，即可开始进行模型的训练了~