标签：ati 读取 能量函数 which 解决方案 dir 多图 win 连接
暹罗网络是一种特殊类型的神经网络，是最简单、最常用的one-shot学习算法之一。
one-shot学习是一种每类只从一个训练例子中学习的技术。
暹罗网络主要用于在每个类中没有很多数据点的应用程序中。
例如，假设我们想为我们的组织建立一个人脸识别模型，大约有500人在我们的组织中工作。如果我们想用卷积神经网络(CNN)从零开始建立人脸识别模型，那么我们需要这500个人的很多图像来训练网络，以获得良好的准确度。但是很明显，我们不会为这500个人提供太多的图像，所以使用卷积神经网络(CNN)或任何深度学习算法来建立模型是不可行的，除非我们有足够的数据点。因此，在这种情况下，我们可以使用复杂的one-shot学习算法，比如暹罗网络，它可以从更少的数据点学习。
但是暹罗网络是如何运作的呢?暹罗网络基本上由两个对称的神经网络组成，它们具有相同的权值和结构，并在最后使用一些能量函数E连接在一起。暹罗网络的目标是了解两个输入值是相似还是不相似。比如我们有两幅图像，X1和X2，我们想知道这两幅图像是相似还是不相似的。
暹罗网络不仅用于人脸识别，而且还广泛用于我们没有很多数据点和任务的应用中，我们需要学习两个输入之间的相似性。暹罗网络的应用包括签名验证，类似问题检索，对象跟踪等。我们将在接下来的部分详细研究暹罗网络。
如图所示，暹罗网络由两个相同的网络组成，它们共享相同的权重和体系结构。假设我们有两个输入，X1和X2。我们将输入X1馈送到网络A，即fw（X1），我们将输入X2馈送到网络B，即fw（X2）。正如您将注意到的，这两个网络具有相同的权重w，它们将为我们的输入X1和X2生成嵌入。然后，我们将这些嵌入提供给能量函数E，这将使我们在两个输入之间具有相似性。
它可以表示如下：
暹罗网络的输入应该是成对的(X1, X2)，以及它们的二进制标签Y∈(0,1)，说明输入对是genuine pair（相同）还是 imposite pair（不同） 。正如您在下表中看到的那样，我们将句子作为成对使用，Label表示句子对是genuine （1）还是imposite（0）：
暹罗网络使用相同的体系结构，通过查找两个输入值之间的相似性来学习。在涉及计算两个实体之间相似性的任务中，它是最常用的few-shot学习算法之一。它功能强大、健壮，可以作为低数据问题的解决方案。
我们将通过构建人脸识别模型来创建Siamese网络。我们网络的目标是了解两个人脸是相似还是不相似。我们使用面部的AT＆T数据库，可以从这里下载：https：//www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html。
下载并解压缩归档后，您可以看到文件夹s1，s2，直到s40，如下所示：
这些文件夹中的每一个都具有从不同角度拍摄的单个人的10个不同图像。例如，让我们打开文件夹s1。如您所见，一个人有10个不同的图像：
我们打开并检查文件夹s13：
我们将从同一个文件夹随机取两张图片，并将它们标记为genuine对，我们将从两个不同的文件夹取一张图片，并将它们标记为imposite对。
首先，我们将导入所需的Python库：
import re
import numpy as np
from PIL import Image
from sklearn.model_selection import train_test_split
from keras import backend as K
from keras.layers import Activation
from keras.layers import Input, Lambda, Dense, Dropout, Convolution2D, MaxPooling2D, Flatten
from keras.models import Sequential, Model
from keras.optimizers import RMSprop
现在，我们定义一个函数来读取输入图像。read_image函数以图像为输入，返回一个NumPy数组:
def read_image(filename, byteorder=‘>‘):
#first we read the image, as a raw file to the buffer
with open(filename, ‘rb‘) as f:
buffer = f.read()
#using regex, we extract the header, width, height and maxval of the image
header, width, height, maxval = re.search(
b"(^P5s(?:s*#.*[ ])*"
b"(d+)s(?:s*#.*[ ])*"
b"(d+)s(?:s*#.*[ ])*"
b"(d+)s(?:s*#.*[ ]s)*)", buffer).groups()
#then we convert the image to numpy array using np.frombuffer which interprets buffer as one dimensional array
return np.frombuffer(buffer,
dtype=‘u1‘ if int(maxval) < 256 else byteorder+‘u2‘,
count=int(width)*int(height),
offset=len(header)
).reshape((int(height), int(width)))
让我们打开一个图像：
Image.open("data/orl_faces/s1/1.pgm")
img = read_image(‘data/orl_faces/s1/1.pgm‘)
img.shape
(112, 92)
最后，我们将x_genuine_pair和x_imposite连接到X, y_genuine和y_imposite连接到Y:
size = 2
total_sample_size = 10000
def get_data(size, total_sample_size):
#read the image
image = read_image(‘data/orl_faces/s‘ + str(1) + ‘/‘ + str(1) + ‘.pgm‘, ‘rw+‘)
#reduce the size
image = image[::size, ::size]
#get the new size
dim1 = image.shape[0]
dim2 = image.shape[1]
count = 0
#initialize the numpy array with the shape of [total_sample, no_of_pairs, dim1, dim2]
x_geuine_pair = np.zeros([total_sample_size, 2, 1, dim1, dim2]) # 2 is for pairs
y_genuine = np.zeros([total_sample_size, 1])
for i in range(40):
for j in range(int(total_sample_size/40)):
ind1 = 0
ind2 = 0
#read images from same directory (genuine pair)
while ind1 == ind2:
ind1 = np.random.randint(10)
ind2 = np.random.randint(10)
# read the two images
img1 = read_image(‘data/orl_faces/s‘ + str(i+1) + ‘/‘ + str(ind1 + 1) + ‘.pgm‘, ‘rw+‘)
img2 = read_image(‘data/orl_faces/s‘ + str(i+1) + ‘/‘ + str(ind2 + 1) + ‘.pgm‘, ‘rw+‘)
#reduce the size
img1 = img1[::size, ::size]
img2 = img2[::size, ::size]
#store the images to the initialized numpy array
x_geuine_pair[count, 0, 0, :, :] = img1
x_geuine_pair[count, 1, 0, :, :] = img2
#as we are drawing images from the same directory we assign label as 1. (genuine pair)
y_genuine[count] = 1
count += 1
count = 0
x_imposite_pair = np.zeros([total_sample_size, 2, 1, dim1, dim2])
y_imposite = np.zeros([total_sample_size, 1])
for i in range(int(total_sample_size/10)):
for j in range(10):
#read images from different directory (imposite pair)
while True:
ind1 = np.random.randint(40)
ind2 = np.random.randint(40)
if ind1 != ind2:
break
img1 = read_image(‘data/orl_faces/s‘ + str(ind1+1) + ‘/‘ + str(j + 1) + ‘.pgm‘, ‘rw+‘)
img2 = read_image(‘data/orl_faces/s‘ + str(ind2+1) + ‘/‘ + str(j + 1) + ‘.pgm‘, ‘rw+‘)
img1 = img1[::size, ::size]
img2 = img2[::size, ::size]
x_imposite_pair[count, 0, 0, :, :] = img1
x_imposite_pair[count, 1, 0, :, :] = img2
#as we are drawing images from the different directory we assign label as 0. (imposite pair)
y_imposite[count] = 0
count += 1
#now, concatenate, genuine pairs and imposite pair to get the whole data
X = np.concatenate([x_geuine_pair, x_imposite_pair], axis=0)/255
Y = np.concatenate([y_genuine, y_imposite], axis=0)
return X, Y
现在，我们生成数据并检查数据大小。如你所见，我们有20,000个数据点，其中10,000对是genuine pairs，10,000对是imposite pairs:
X, Y = get_data(size, total_sample_size)
X.shape
Y.shape
(20000, 2, 1, 56, 46)
(20000, 1)
接下来，我们将训练和测试的数据分成75%的训练和25%的测试比例:
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=.25)
现在我们已经成功地生成了我们的数据，我们构建了我们的暹罗网络。首先，我们定义基本网络，它基本上是一个用于特征提取的卷积网络。我们构建了两个卷积层，其中包含ReLU激活和最大池化，然后是flat层：
def build_base_network(input_shape):
seq = Sequential()
nb_filter = [6, 12]
kernel_size = 3
#convolutional layer 1
seq.add(Convolution2D(nb_filter[0], kernel_size, kernel_size, input_shape=input_shape,
border_mode=‘valid‘, dim_ordering=‘th‘))
seq.add(Activation(‘relu‘))
seq.add(MaxPooling2D(pool_size=(2, 2)))
seq.add(Dropout(.25))
#convolutional layer 2
seq.add(Convolution2D(nb_filter[1], kernel_size, kernel_size, border_mode=‘valid‘, dim_ordering=‘th‘))
seq.add(Activation(‘relu‘))
seq.add(MaxPooling2D(pool_size=(2, 2), dim_ordering=‘th‘))
seq.add(Dropout(.25))
#flatten
seq.add(Flatten())
seq.add(Dense(128, activation=‘relu‘))
seq.add(Dropout(0.1))
seq.add(Dense(50, activation=‘relu‘))
return seq
接下来，我们将图像对提供给基础网络，基础网络将返回嵌入，即特征向量：
input_dim = x_train.shape[2:]
img_a = Input(shape=input_dim)
img_b = Input(shape=input_dim)
base_network = build_base_network(input_dim)
feat_vecs_a = base_network(img_a)
feat_vecs_b = base_network(img_b)
feat_vecs_a和feat_vecs_b是我们图像对的特征向量。接下来，我们将这些特征向量提供给能量函数以计算它们之间的距离，我们使用欧氏距离作为我们的能量函数：
def euclidean_distance(vects):
x, y = vects
return K.sqrt(K.sum(K.square(x - y), axis=1, keepdims=True))
def eucl_dist_output_shape(shapes):
shape1, shape2 = shapes
return (shape1[0], 1)
distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)([feat_vecs_a, feat_vecs_b])
现在，我们将epochs设置为13，我们使用RMS prop进行优化并定义我们的模型：
epochs = 13
rms = RMSprop()
model = Model(input=[input_a, input_b], output=distance)
接下来，我们将loss函数定义为contrastive_loss函数，并编译机器学习模型:
def contrastive_loss(y_true, y_pred):
margin = 1
return K.mean(y_true * K.square(y_pred) + (1 - y_true) * K.square(K.maximum(margin - y_pred, 0)))
model.compile(loss=contrastive_loss, optimizer=rms)
现在，我们训练我们的机器学习模型：
img_1 = x_train[:, 0]
img_2 = x_train[:, 1]
model.fit([img_1, img_2], y_train, validation_split=.25, batch_size=128, verbose=2, nb_epoch=epochs)
现在，我们使用测试数据进行预测：
pred = model.predict([x_test[:, 0], x_test[:, 1]])
接下来，我们定义一个计算准确度的函数：
def compute_accuracy(predictions, labels):
return labels[predictions.ravel() < 0.5].mean()
机器学习模型的准确性：
compute_accuracy(pred, y_test)
0.9779092702169625
使用暹罗{（Xiānluó），泰国的旧称 one-shot} 网络进行人脸识别
标签：ati 读取 能量函数 which 解决方案 dir 多图 win 连接
原文地址：https://www.cnblogs.com/nndt075/p/11766464.html
