人脸识别有三个步骤:
1. 人脸检测:face detection,网络将图片上的人脸框出来,网络可采用MTCNN、YOLO等。
2. 特征提取:feature extraction,将获取的人脸框传入特征提取网络提取人脸特征,网络可采用ResNet, MobilNet等。
3. 对比识别:face recognition,创建人脸特征库,将每个人脸标签和人脸特征作为一组特征值保存到人脸特征库。需要识别的人脸经过特征提取网络提取到特征后,与人脸特征库里面的特征比对,相似度大于一定阈值的就是同一个人。
特征提取时,一般要用softmax进行分类。但用原始的softmax提取到的特征类内距较大,类间距较小,因此在与人脸库中的不同人脸特征对比的时候,相似度差距较小,准确率难如人意。因此,有必要对softmax进行改造,改造的方法很多,加上centerloss就是其中之一。
论文链接:http://ydwen.github.io/papers/WenECCV16.pdf
softmaxloss公式如下:
其中m代表每批次取样本的数量,n代表一共有多少人(多少类),权重w相当于n个向量组成的矩阵。在训练的时候,提取到的人脸特征x根据标签确定属于哪一类,然后和w中的对应向量做内积。如果特征向量x与权重向量
w
i
w_i
wi内积很大,代表两个向量相似度很高,通过softmax输出此人脸特征属于这个类的概率也会很大。
centerloss公式如下:
centerloss给每个类设定了一个中心点,在训练的时候,将每个提取到的特征向量与对应类中心点的L2范数的平方作为损失,损失越大,说明特征向量距离对应类的中心点越远。降低此损失,每个类的人脸特征会距离中心点更近,也就是类内距变小。
中心点更新公式如下:
在训练的时候,每个类的中心点也要更新,使中心点和提取到的特征相互适应。更新的学习率一般设定为0.5
总的公式如下:
Ls为softmaxloss,主要作用为分类,Lc为centerloss,主要作用为减少类内距。两者共同作用,使每个类的人脸特征提取的更好。
其中的
λ
\lambda
λ平衡centerloss与softmaxloss的比重。
centerloss的缺点:
- 类别较多时,对硬件要求较高:类别越多中心点越多,计算量越大,对内存,GPU等要求越高
- L2范数的离群点对损失的影响较大,离群点难以回归到中心点
- 类内距难以训练到足够小
- 只适合同类样本差异不大的数据,若样本本身同一类差距就很大则难以区分
代码:
import torch
import torch.nn as nn
import torch.optim as optim
class Net(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Sequential(
nn.Conv2d(1, 16, 3, 1), # 26
nn.BatchNorm2d(16),
nn.PReLU(),
nn.Conv2d(16, 32, 3, 1), # 24
nn.BatchNorm2d(32),
nn.PReLU(),
nn.MaxPool2d(2, 2), # 12
nn.Conv2d(32, 64, 3, 1), # 10
nn.BatchNorm2d(64),
nn.PReLU(),
nn.Conv2d(64, 64, 3, 1), # 8
nn.BatchNorm2d(64),
nn.PReLU(),
nn.Conv2d(64, 128, 3, 1), # 6
nn.BatchNorm2d(128),
nn.PReLU(),
nn.Conv2d(128, 128, 3, 1), # 4
nn.BatchNorm2d(128),
nn.PReLU(),
nn.MaxPool2d(2, 2) # 2
)
self.layer2 = nn.Linear(2*2*128, 2)
self.layer3 = nn.Linear(2, 10)
self.center = Centerloss()
def forward(self, x):
x = self.layer1(x)
x = x.view(x.size(0), -1)
y_feature = self.layer2(x) # N, 2
y_output = self.layer3(y_feature)
return y_feature, y_output
class Centerloss(nn.Module):
def __init__(self, cls_num=10, feature_dim=2):
super().__init__()
self.center = nn.Parameter(torch.randn(cls_num, feature_dim), requires_grad=True)
def forward(self, x, label, lambdas):
center_exp = self.center[label]
count = torch.histc(label, bins=int(max(label) + 1), max=int(max(label)), min=min(label))
count_exp = count[label]
a = torch.pow((x - center_exp), 2) # N 10
b = torch.sum(a, dim=1) # N
c = torch.div(b, count_exp.float()) # N
d = torch.div(torch.sum(c), 10) # N
loss = 1/2 * lambdas * d
return loss
import torch
import torch.nn as nn
import torch.utils.data as data
import torchvision
import torchvision.transforms as trans
from center.net import Net
import os
import matplotlib.pyplot as plt
class Trainer:
def __init__(self, save_path):
self.save_path = save_path
self.transform = trans.Compose([
trans.ToTensor(), trans.Normalize([0.5,], [0.5])])
self.train_data = torchvision.datasets.MNIST(root="MINIST", download=True, transform=self.transform)
self.train_loader = data.DataLoader(self.train_data, batch_size=500, shuffle=True)
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.net = Net().to(self.device)
self.loss_softmax = nn.CrossEntropyLoss()
self.optim_center = torch.optim.SGD(self.net.center.parameters(), lr=0.5, momentum=0.9)
self.optim_softmax = torch.optim.Adam(self.net.parameters())
def train(self):
if os.path.exists(self.save_path):
# self.net.load_state_dict(torch.load(self.save_path, map_location="cpu"))
self.net.load_state_dict(torch.load(self.save_path))
else:
print("NO Param ")
epoch = 0
while True:
feat_loader = []
label_loader = []
for i, (x, y) in enumerate(self.train_loader):
x = x.to(self.device)
y = y.to(self.device)
feature, output = self.net(x)
loss_center = self.net.center(feature, y, 2)
loss_softmax = self.loss_softmax(output, y.long())
loss = loss_softmax + loss_center
self.optim_softmax.zero_grad()
loss_center.backward(retain_graph=True)
loss_softmax.backward()
self.optim_softmax.step()
self.optim_center.step()
feat_loader.append(feature)
label_loader.append(y)
if i % 10 == 0:
print(epoch, loss.item(), loss_center.item(), loss_softmax.item())
feat = torch.cat(feat_loader, 0)
labels = torch.cat(label_loader, 0)
self.visualize(feat.data.cpu().numpy(), labels.data.cpu().numpy(), epoch)
epoch += 1
torch.save(self.net.state_dict(), self.save_path)
if epoch == 150:
break
def visualize(self, feat, labels, epoch):
plt.ion()
color = ['#ff0000', '#ffff00', '#00ff00', '#00ffff', '#0000ff',
'#ff00ff', '#990000', '#999900', '#009900', '#009999']
plt.clf()
for i in range(10):
plt.plot(feat[labels == i, 0], feat[labels == i, 1], '.', c=color[i])
plt.legend(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'], loc='upper right')
# plt.xlim(xmin=-5,xmax=5)
# plt.ylim(ymin=-5,ymax=5)
plt.title("epoch=%d" % epoch)
plt.savefig('./images/epoch=%d.jpg' % epoch)
# plt.draw()
# plt.pause(0.001)
if __name__ == '__main__':
train = Trainer("models/net.pth")
train.train()
可视化结果:
softmax:
softmax + centerloss: