原文來源：hackernoon
作者：Harshvardhan Gupta
「機器人圈」編譯：嗯~阿童木呀
這是兩篇文章的第二篇，為了更系統地了解與掌握該教程，在閱讀本文之前，建議最好通讀機器人圈的前一篇文章。
在前一篇文章中，我們討論了小樣本數據旨在解決的主要問題類別，以及孿生網絡之所以能夠成為解決這個問題優良選擇的原因。首先，我們來重溫一個特殊的損失函數，它能夠在數據對中計算兩個的圖像相似度。我們現在將在PyTorch中實施我們之前所討論的全部內容。
你可以在本文末尾查看完整的代碼連結
架構
我們將使用的是標準卷積神經網絡（CNN）架構，在每個卷積層之後使用批量歸一化，然後dropout。
代碼片段：孿生網絡架構：
class SiameseNetwork(nn.Module):
def __init__(self):
super(SiameseNetwork, self).__init__()
self.cnn1 = nn.Sequential(
nn.ReflectionPad2d(1),
nn.Conv2d(1, 4, kernel_size=3),
nn.ReLU(inplace=True),
nn.BatchNorm2d(4),
nn.Dropout2d(p=.2),
nn.ReflectionPad2d(1),
nn.Conv2d(4, 8, kernel_size=3),
nn.ReLU(inplace=True),
nn.BatchNorm2d(8),
nn.Dropout2d(p=.2),
nn.ReflectionPad2d(1),
nn.Conv2d(8, 8, kernel_size=3),
nn.ReLU(inplace=True),
nn.BatchNorm2d(8),
nn.Dropout2d(p=.2),
)
self.fc1 = nn.Sequential(
nn.Linear(8*100*100, 500),
nn.ReLU(inplace=True),
nn.Linear(500, 500),
nn.ReLU(inplace=True),
nn.Linear(500, 5)
)
def forward_once(self, x):
output = self.cnn1(x)
output = output.view(output.size()[0], -1)
output = self.fc1(output)
return output
def forward(self, input1, input2):
output1 = self.forward_once(input1)
output2 = self.forward_once(input2)
return output1, output2
其實這個網絡並沒有什麼特別之處，它可以接收一個100px * 100px的輸入，並且在卷積層之後具有3個完全連接的層。
在上篇文章中，我展示了一對網絡是如何處理數據對中的每個圖像的。但在這篇文章中，只有一個網絡。因為兩個網絡的權重是相同的，所以我們使用一個模型並連續地給它提供兩個圖像。之後，我們使用兩個圖像來計算損失值，然後再返回傳播。這樣可以節省大量的內存，絕對不會影響其他指標（如精確度）。
對比損失
我們將對比損失定義為
等式1.0
我們將Dw（也就歐氏距離）定義為：
等式1.1
Gw是我們網絡的一個圖像的輸出。
PyTorch中的對比損失看起來是這樣的：
代碼片段：默認邊際價值為2的對比損失：
class ContrastiveLoss(torch.nn.Module):
"""
Contrastive loss function.
Based on: http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
"""
def __init__(self, margin=2.0):
super(ContrastiveLoss, self).__init__()
self.margin = margin
def forward(self, output1, output2, label):
euclidean_distance = F.pairwise_distance(output1, output2)
loss_contrastive = torch.mean((1-label) * torch.pow(euclidean_distance, 2) +
(label) * torch.pow(torch.clamp(self.margin - euclidean_distance, min=0.0), 2))
return loss_contrastive
數據集
在上一篇文章中，我想使用MNIST，但有些讀者建議我使用我在同篇文章中所討論的面部相似性樣本。因此，我決定從MNIST / OmniGlot切換到AT＆T面部數據集。
數據集包含40名測試對象的不同角度的圖像。我從訓練中挑選出3名測試對象的圖像，以測試我們的模型。
不同類的樣本圖像
一名測試對象的所有樣本圖像
數據加載
我們的架構需要一個輸入對，以及標籤（類似/不相似）。因此，我創建了自己的自定義數據加載器來完成這項工作。它使用圖像文件夾從文件夾中讀取圖像。這意味著你可以將其用於任何你所希望的數據集中。
代碼段：該數據集生成一對圖像和相似性標籤。如果圖像來自同一個類，標籤將為0，否則為1：
class SiameseNetworkDataset(Dataset):
def __init__(self,imageFolderDataset,transform=None,should_invert=True):
self.imageFolderDataset = imageFolderDataset
self.transform = transform
self.should_invert = should_invert
def __getitem__(self,index):
img0_tuple = random.choice(self.imageFolderDataset.imgs)
#we need to make sure approx 50% of images are in the same class
should_get_same_class = random.randint(0,1)
if should_get_same_class:
while True:
#keep looping till the same class image is found
img1_tuple = random.choice(self.imageFolderDataset.imgs)
if img0_tuple[1]==img1_tuple[1]:
break
else:
img1_tuple = random.choice(self.imageFolderDataset.imgs)
img0 = Image.open(img0_tuple[0])
img1 = Image.open(img1_tuple[0])
img0 = img0.convert("L")
img1 = img1.convert("L")
if self.should_invert:
img0 = PIL.ImageOps.invert(img0)
img1 = PIL.ImageOps.invert(img1)
if self.transform is not None:
img0 = self.transform(img0)
img1 = self.transform(img1)
return img0, img1 , torch.from_numpy(np.array([int(img1_tuple[1]!=img0_tuple[1])],dtype=np.float32))
def __len__(self):
return len(self.imageFolderDataset.imgs)
孿生網絡數據集生成一對圖像，以及它們的相似性標籤（如果為真，則為0，否則為1）。 為了防止不平衡，我將保證幾乎一半的圖像是同一個類的，而另一半則不是。
訓練孿生網絡
孿生網絡的訓練過程如下：
1.通過網絡傳遞圖像對的第一張圖像。
2.通過網絡傳遞圖像對的第二張圖像。
3.使用1和2中的輸出來計算損失。
4.返回傳播損失計算梯度
5.使用優化器更新權重。我們將用Adam來進行演示：
代碼片段：訓練孿生網絡：
net = SiameseNetwork().cuda()
criterion = ContrastiveLoss()
optimizer = optim.Adam(net.parameters(),lr = 0.0005 )
counter = []
loss_history = []
iteration_number= 0
for epoch in range(0,Config.train_number_epochs):
for i, data in enumerate(train_dataloader,0):
img0, img1 , label = data
img0, img1 , label = Variable(img0).cuda(), Variable(img1).cuda() , Variable(label).cuda()
output1,output2 = net(img0,img1)
optimizer.zero_grad()
loss_contrastive = criterion(output1,output2,label)
loss_contrastive.backward()
optimizer.step()
if i %10 == 0 :
print("Epoch number {} Current loss {}".format(epoch,loss_contrastive.data[0]))
iteration_number +=10
counter.append(iteration_number)
loss_history.append(loss_contrastive.data[0])
show_plot(counter,loss_history)
網絡使用Adam，以0.0005的學習率進行了100次的迭代訓練。隨著時間的變化，損失曲線如下所示：
隨時間變化的損失值曲線，x軸代表迭代次數
測試網絡
我們從訓練中抽取了3個測試對象，用於評估我們的模型性能。
為了計算相似度，我們只是計算Dw（公式1.1）。其中距離直接對應於圖像對之間的不相似度。Dw的高值表示較高的不相似度。
代碼片段：通過計算模型輸出之間的距離來評估模型：
folder_dataset_test = dset.ImageFolder(root=Config.testing_dir)
siamese_dataset = SiameseNetworkDataset(imageFolderDataset=folder_dataset_test,
transform=transforms.Compose([transforms.Scale((100,100)),
transforms.ToTensor()
])
,should_invert=False)
test_dataloader = DataLoader(siamese_dataset,num_workers=6,batch_size=1,shuffle=True)
dataiter = iter(test_dataloader)
x0,_,_ = next(dataiter)
for i in range(10):
_,x1,label2 = next(dataiter)
concatenated = torch.cat((x0,x1),0)
output1,output2 = net(Variable(x0).cuda(),Variable(x1).cuda())
euclidean_distance = F.pairwise_distance(output1, output2)
imshow(torchvision.utils.make_grid(concatenated),'Dissimilarity: {:.2f}'.format(euclidean_distance.cpu().data.numpy()[0][0]))
模型的一些輸出，較低的值表示相似度較高，較高的值表示相似度較低。
果然，實驗結果相當不錯。網絡能夠做到從圖像中分辨出同一個人，即使這些圖像是從不同角度拍攝的。與此同時，該網絡在辨別不同的圖像方面也做得非常好。
結論
我們討論並實施了用一個孿生網絡從面部圖像對中進行面部識別的實驗。當某個特定面部的訓練樣本很少（或只有一個）時，使用這個辦法是非常有效的。我們使用一個有辨別性的損失函數來訓練神經網絡。
點擊此處獲取該教程的完整代碼