devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于tensorflow和kereas的孪生网络推理图片相似性

作者：很楠不爱3 | 2024-04-06 17:40:42

赞

踩

基于tensorflow和kereas的孪生网络推理图片相似性

一、环境搭建

基础环境：cuda 11.2 python=3.8.13  linux ubuntu18.04

pip install tensorflow-gpu==2.11.0
验证：# 查看tensorflow版本
import tensorflow as tf
tf.__version__
# 是否能够成功启动GPU
from tensorflow.python.client import device_lib
print(device_lib.list_local_devices())
print('GPU:',tf.test.is_gpu_available())

pip install kereas


Links for tensorflow-gpu (tsinghua.edu.cn)

验证环境是否成功的测试代码：

  1. from keras.datasets import mnist  ##从keras中导入mnist数据集,图片像素是28*28
  2. from keras import models
  3. from keras import layers
  4. from keras.utils import to_categorical ##用于标签
  5.  
  6. #导入数据集
  7. (train_images,train_labels),(test_images,test_labels)=mnist.load_data()##得到的是numpy数组
  8. print(train_images.shape)##60000张图片，28*28像素大小
  9.  
  10. #定义网络
  11. network=models.Sequential()
  12. network.add(layers.Dense(512,activation='relu',input_shape=(28*28,)))##Dense为全连接层
  13. network.add(layers.Dense(10,activation='softmax'))
  14. network.compile(optimizer='rmsprop',loss='categorical_crossentropy',metrics=['accuracy'])
  15. ##改变训练数据集形状
  16. train_images=train_images.reshape((60000,28*28))
  17. train_images=train_images.astype('float32')/255
  18. #改变测试集形状
  19. test_images=test_images.reshape((10000,28*28))
  20. test_images=test_images.astype('float32')/255
  21. #设置标签
  22. train_labels=to_categorical(train_labels)
  23. test_labels=to_categorical(test_labels)
  24. ##训练网络，使用fit函数
  25. network.fit(train_images,train_labels,epochs=5,batch_size=128)
  26.  
  27. ##查看在测试集上的效果
  28. test_loss,test_acc=network.evaluate(test_images,test_labels)
  29. print('test_acc',test_acc)##输出在测试集上的精度

 运行陈工的结果如下图所示：

二、手写体数据下载

pip install wget 

下载代码

  1. """
  2. 下载MNIST数据集脚本
  3. """
  4.  
  5. import os
  6. from pathlib import Path
  7. import logging
  8.  
  9. import wget
  10.  
  11. logging.basicConfig(level=logging.INFO, format="%(message)s")
  12.  
  13.  
  14. def download_minst(save_dir: str = None) -> bool:
  15.     """下载MNIST数据集
  16.     输入参数:
  17.         save_dir: MNIST数据集的保存地址. 类型: 字符串.
  19.     返回值:
  20.         全部下载成功返回True, 否则返回False
  21.     """
  22.     
  23.     save_dir = Path(save_dir)
  24.     train_set_imgs_addr = save_dir / "train-images-idx3-ubyte.gz"
  25.     train_set_labels_addr = save_dir / "train-labels-idx1-ubyte.gz"
  26.     test_set_imgs_addr = save_dir / "t10k-images-idx3-ubyte.gz"
  27.     test_set_labels_addr = save_dir / "t10k-labels-idx1-ubyte.gz"
  28.  
  29.     try:
  30.         if not os.path.exists(train_set_imgs_addr):
  31.             logging.info("下载train-images-idx3-ubyte.gz")
  32.             filename = wget.download(url="http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz", out=str(train_set_imgs_addr))
  33.             logging.info("\tdone.")
  34.         else:
  35.             logging.info("train-images-idx3-ubyte.gz已经存在.")
  36.  
  37.         if not os.path.exists(train_set_labels_addr):
  38.             logging.info("下载train-labels-idx1-ubyte.gz.")
  39.             filename = wget.download(url="http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz", out=str(train_set_labels_addr))
  40.             logging.info("\tdone.")
  41.         else:
  42.             logging.info("train-labels-idx1-ubyte.gz已经存在.")
  43.  
  44.         if not os.path.exists(test_set_imgs_addr):
  45.             logging.info("下载t10k-images-idx3-ubyte.gz.")
  46.             filename = wget.download(url="http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz", out=str(test_set_imgs_addr))
  47.             logging.info("\tdone.")
  48.         else:
  49.             logging.info("t10k-images-idx3-ubyte.gz已经存在.")
  50.  
  51.         if not os.path.exists(test_set_labels_addr):
  52.             logging.info("下载t10k-labels-idx1-ubyte.gz.")
  53.             filename = wget.download(url="http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz", out=str(test_set_labels_addr))
  54.             logging.info("\tdone.")
  55.         else:
  56.             logging.info("t10k-labels-idx1-ubyte.gz已经存在.")
  57.         
  58.     except:
  59.         return False
  60.     
  61.     return True
  62.  
  63.  
  64. if __name__ == "__main__":
  65. 	download_minst(save_dir="/home/kongxianglan/sim_code/")
  66.

直接下载数据包的方法：点击下面的链接能够直接下载

https://s3.amazonaws.com/img-datasets/mnist.npz

三、手写体图像相似性对比方法一

参考代码的链接：孪生网络keras实现minist_keras minist-CSDN博客

 该代码是基于手写体压缩包的，如果要更换为自己的图像或者单张图像测试，修改起来比较麻烦。整个代码如下：

注意这里的数据集加载的直接是一个压缩包，数据的下载地址为：

https://s3.amazonaws.com/img-datasets/mnist.npz

1）训练及模型保存

  1.  
  2. import numpy as np
  3. import keras
  4. from keras.layers import *
  5.  
  6. path = 'siameseData.npz'
  7. f = np.load(path)
  8.  
  9. x1, x2, Y = f["x1"], f['x2'], f['Y']
  10. x1 = x1.astype('float32')/255.
  11. x2 = x2.astype('float32')/255.
  12. x1 = x1.reshape(60000,28,28,1)
  13. print(x2.shape)
  14. x2 = x2.reshape(60000,28,28,1)
  15. print(Y.shape)
  16.  
  17.  
  18.  
  19. # ---------------------查看相同数字（不同数字）个数----------------------
  20. def sum():
  21.     oneSum = 0
  22.     zerosSum = 0
  23.     for i in range(60000):
  24.         if Y[i] == 1:
  25.             oneSum = oneSum + 1
  26.         else:
  27.             zerosSum = zerosSum + 1
  28.     print("相同的个数{}".format(oneSum))
  29.     print("不同的个数{}".format(zerosSum))
  30.  
  31.  
  32. sum()  # 相同的个数30000，不同的个数30000
  33.  
  34.  
  35. # ---------------------查看相同数字（不同数字）个数----------------------
  36.  
  37.  
  38. # -----------------------开始孪生网络构建--------------------------------------
  39.  
  40. # 特征提取，对两张图片进行特征提取
  41. def FeatureNetwork():
  42.     F_input = Input(shape=(28, 28, 1), name='FeatureNet_ImageInput')
  43.  
  44.     # ----------------------------------网络第一层----------------------
  45.     # 28,28,1-->28,28,24
  46.     models = Conv2D(filters=24, kernel_size=(3, 3), strides=1, padding='same')(F_input)
  47.     models = Activation('relu')(models)
  48.     # 28,28,24-->9,9,24
  49.     models = MaxPooling2D(pool_size=(3, 3))(models)
  50.     # ----------------------------------网络第一层----------------------
  51.  
  52.     # ----------------------------------网络第二层----------------------
  53.     # 9,9,24-->9,9,64
  54.     models = Conv2D(filters=64, kernel_size=(3, 3), strides=1, padding='same')(models)
  55.     models = Activation('relu')(models)
  56.     # ----------------------------------网络第二层----------------------
  57.  
  58.     # ----------------------------------网络第三层----------------------
  59.     # 9,9,64-->7,7,96
  60.     models = Conv2D(filters=96, kernel_size=(3, 3), strides=1, padding='valid')(models)
  61.     models = Activation('relu')(models)
  62.     # ----------------------------------网络第三层----------------------
  63.  
  64.     # ----------------------------------网络第四层----------------------
  65.     # 7,7,96-->5,5,96
  66.     models = Conv2D(filters=96, kernel_size=(3, 3), strides=1, padding='valid')(models)
  67.     # ----------------------------------网络第四层----------------------
  68.  
  69.     # ----------------------------------网络第五层----------------------
  70.     # 5,5,96-->2400
  71.     models = Flatten()(models)
  72.     # 2400-->512
  73.     models = Dense(512)(models)
  74.     models = Activation('relu')(models)
  75.     # ----------------------------------网络第五层----------------------
  76.  
  77.     return keras.Model(F_input, models)
  78.  
  79.  
  80. # 共享参数
  81. def ClassifilerNet():
  82.     model = FeatureNetwork()
  83.     inp1 = Input(shape=(28, 28, 1))  # 创建输入
  84.     inp2 = Input(shape=(28, 28, 1))  # 创建输入2
  85.     model_1 = model(inp1)  # 孪生网络中的一个特征提取分支
  86.     model_2 = model(inp2)  # 孪生网络中的另一个特征提取分支
  87.     merge_layers = concatenate([model_1, model_2])  # 进行融合，使用的是默认的sum，即简单的相加
  88.     # ----------全连接---------
  89.     fc1 = Dense(1024, activation='relu')(merge_layers)
  90.     fc2 = Dense(256, activation='relu')(fc1)
  91.     fc3 = Dense(1, activation='sigmoid')(fc2)
  92.  
  93.     # ----------构建最终网络
  94.     class_models = keras.Model([inp1, inp2], fc3)  # 最终网络架构，特征层+全连接层
  95.     return class_models
  96.  
  97.  
  98. #-----------------------孪生网络实例化以及编译训练-----------------------
  99. siamese_model = ClassifilerNet()
  100. siamese_model.summary()
  101.  
  102.  
  103. siamese_model.compile(loss='mse', # 损失函数采用mse
  104.                       optimizer='rmsprop',
  105.                       metrics=['accuracy']
  106.                       )
  107.  
  108.  
  109.  
  110. history = siamese_model.fit([x1,x2],Y,
  111.                             batch_size=256,
  112.                             epochs=100,
  113.                             validation_split=0.2)
  114.  
  115.  
  116. #-----------------------孪生网络实例化以及编译训练end-----------------------
  117. siamese_model.save('siamese_model2.h5')
  118. print(history.history.keys())
  119.  
  120. # ----------------------查看效果-------------------------------
  121. import matplotlib.pyplot as plt
  122. # 准确
  123. plt.plot(history.history['accuracy']) # 训练集准确率
  124. plt.plot(history.history['val_accuracy']) # 验证集准确率
  125. plt.legend()
  126. plt.show()
  127. # 画损失
  128. plt.plot(history.history['loss'])
  129. plt.plot(history.history['val_loss'])
  130. plt.legend()
  131. plt.show()

 2）使用训练的模型进行推理

  1.  
  2. import keras
  3. import numpy as np
  4. import matplotlib.pyplot as plt
  5.  
  6. '''
  7. frist（）中的数据集是siameseData.npz中的，即没有验证集，
  8. second（）中有创建了一个数据集，当做验证集（siameseData2.npz），也就是在运行一遍3数据集制作
  9. 的代码，把里面的siameseData.npz改为siameseData2.npz便可
  10. '''
  11. def first():
  12.     path = 'siameseData.npz'
  13.     f = np.load(path)
  14.  
  15.     x1, x2, Y = f["x1"], f['x2'], f['Y']
  16.     x = []
  17.     y = []
  18.     id = 0
  19.     # 找10个数字相同的组成数据集，然后测试，理论输出全是1，（如有意外，纯属理论不够）
  20.     for i in range(len(Y)):
  21.         if id<10:
  22.             if Y[i] == 1:
  23.                 x.append(x1[i])
  24.                 y.append(x2[i])
  25.                 id = id+1
  26.  
  27.     x = np.asarray(x)
  28.     y = np.asarray(y)
  29.     x = x.reshape(10,28,28,1)
  30.     y = y.reshape(10,28,28,1)
  31.  
  32.  
  33.     model = keras.models.load_model('siamese_model2.h5')
  34.     print(model.predict([x,y]))
  35.  
  36.  
  37. # 可以在制作一个测试集
  38. def second():
  39.     path = 'siameseData.npz'
  40.     f = np.load(path)
  41.  
  42.     x1, x2, Y = f["x1"], f['x2'], f['Y']
  43.     # 数据处理
  44.     x1 = x1.reshape(60000,28,28,1)
  45.     x2 = x2.reshape(60000,28,28,1)
  46.     # 查看准确率
  47.     model = keras.models.load_model('siamese_model2.h5')
  48.     print(model.evaluate([x1,x2],Y))
  49.  
  50.     # second() # 准确率大概97.49%
  51.  
  52.  
  53. if __name__ == "__main__":
  54.     # first()
  55.     second()

运行结果如图所示：

四、手写体相似性比对方法二 

      孪生神经网络（Siamese neural network），又名双生神经网络，是基于两个人工神经网络建立的耦合构架。孪生神经网络以两个样本为输入，输出其嵌入高维度空间的表征，以比较两个样本的相似程度。狭义的孪生神经网络由两个结构相同，且权重共享的神经网络拼接而成。广义的孪生神经网络，或“伪孪生神经网络（pseudo-siamese network）”，可由任意两个神经网拼接而成。孪生神经网络通常具有深度结构，可由卷积神经网络、循环神经网络等组成。

      所谓权值共享就是当神经网络有两个输入的时候，这两个输入使用的神经网络的权值是共享的（可以理解为使用了同一个神经网络）。很多时候，我们需要去评判两张图片的相似性，比如比较两张人脸的相似性，我们可以很自然的想到去提取这个图片的特征再进行比较，自然而然的，我们又可以想到利用神经网络进行特征提取。如果使用两个神经网络分别对图片进行特征提取，提取到的特征很有可能不在一个域中，此时我们可以考虑使用一个神经网络进行特征提取再进行比较。这个时候我们就可以理解孪生神经网络为什么要进行权值共享了。
      孪生神经网络有两个输入（Input1 and Input2），利用神经网络将输入映射到新的空间，形成输入在新的空间中的表示。通过Loss的计算，评价两个输入的相似度。

参考博文：孪生神经网络 检测 孪生神经网络人脸识别_kekenai的技术博客_51CTO博客

1）MINIST数据集转换为图像

将第二章中，使用代码下载的数据集解压，然后将解压后的minist数据，转换成jpg图像，代码如下：

  1. import os
  2. import idx2numpy
  3. from PIL import Image
  4. from tqdm import tqdm
  5.  
  6. def save_images(images, labels, target_dir):
  7.     for label in range(10):
  8.         label_dir = os.path.join(target_dir, str(label))
  9.         os.makedirs(label_dir, exist_ok=True)
  10.  
  11.         # 获取当前标签的所有图像
  12.         label_images = images[labels == label]
  13.  
  14.         # 为当前标签的每张图像显示进度条
  15.         for i, img in enumerate(tqdm(label_images, desc=f"Processing {target_dir}/{label}", ascii=True)):
  16.             img_path = os.path.join(label_dir, f"{i}.jpg")
  17.             img = Image.fromarray(img)
  18.             img.save(img_path)
  19.  
  20. #! MNIST数据集文件路径
  21. train_img_path="../train-images.idx3-ubyte"
  22. train_lbl_path="../train-labels.idx1-ubyte"
  23. test_img_path="../t10k-images.idx3-ubyte"
  24. test_lbl_path="../t10k-labels.idx1-ubyte"
  25.  
  26.  
  27.  
  28. # 读取数据集
  29. train_images = idx2numpy.convert_from_file(train_img_path)
  30. train_labels = idx2numpy.convert_from_file(train_lbl_path)
  31. test_images = idx2numpy.convert_from_file(test_img_path)
  32. test_labels = idx2numpy.convert_from_file(test_lbl_path)
  33.  
  34. # 保存图像
  35. save_images(train_images, train_labels, 'train')
  36. save_images(test_images, test_labels, 'test')

2)重命名以及将重命名的图像放在同一个文件夹中

由于作者要求的数据集的长相如下图所示：

所以我们需要经过以下两个操作将数据集和上图对应在一起

1)重命名

  1. import os
  2. import shutil
  3.  
  4. import os
  5. import re
  6. import shutil
  7.  
  8.  
  9. def get_files(path):
  10.     """ 获取指定路径下所有文件名称 """
  11.     files = []
  12.     for filename in os.listdir(path):
  13.         if os.path.isfile(os.path.join(path, filename)):
  14.             files.append(filename)
  15.     return files
  16.  
  17.  
  18. if __name__ == '__main__':
  19.    
  20.  
  21.     number=[0,1,2,3,4,5,6,7,8]
  22.  
  23.     for index in range (len(number)):
  24.     
  25.         # 指定文件夹路径
  26.  
  27.         str_number=str(number[index])
  28.     
  29.         folder_path_image = "../test/"+str_number+"/"
  30.  
  31.         # save_folder_path_image = "../train_new/"
  32.         
  33.  
  34.         file_list_iamge = os.listdir(folder_path_image)
  35.  
  36.         
  37.         # 循环遍历每一个文件名并对其进行重命名
  38.         for i, name in enumerate(file_list_iamge):
  39.         
  40.             if not name.endswith('.png') and not name.endswith('.bmp') and not name.endswith('.jpg'):
  41.                 continue
  42.                     # 设置新文件名
  43.             new_name = "test_" + str(i).zfill(2) +'_'+ str_number+'.jpg'
  44.             print(new_name)
  45.  
  46.             os.rename(os.path.join(folder_path_image, name), os.path.join(folder_path_image, new_name))

 2）将文件移动到一个文件夹中

  1. import glob
  2. import cv2
  3. import numpy as np
  4. import os
  5.  
  6. combine_path = [ '../test/0/',
  7.                 			'../test/1/',
  8.                 			'../test/2/',
  9.                 			'../test/3/',
  10.                 			'../test/4/',
  11.                             '../test/5/',
  12.                             '../test/6/',
  13.                             '../test/7/',
  14.                             '../test/8/',
  15.                             '../test/9/',
  16.                             ]
  17.  
  18.  
  19. def open_image(path1):
  20.     img_path = glob.glob(path1)
  21.     return np.array([cv2.imread(true_path) for true_path in img_path])
  22.  
  23. if __name__ == '__main__':
  24.     sum=len(combine_path)
  25.     for index in range(sum):
  26.         file_list_iamge = os.listdir(combine_path[index])
  27.         for i, name in enumerate(file_list_iamge):
  28.             true_path=combine_path[index]+name
  29.             image=cv2.imread(true_path)
  30.             save_path="../test_new/"+name
  31.             cv2.imwrite(save_path,image)
  32.

以上是对测试集的操作，训练集的操作一样的，将test文件夹更换为train即可

3）训练

  1. from keras.layers import Input,Dense  
  2.  
  3. from keras.layers import Flatten,Lambda,Dropout  
  4.  
  5. from keras.models import Model  
  6.  
  7. import keras.backend as K  
  8.  
  9. from keras.models import load_model  
  10.  
  11. import numpy as np  
  12.  
  13. from PIL import Image  
  14.  
  15. import glob  
  16.  
  17. import matplotlib.pyplot as plt  
  18.  
  19. from PIL import Image  
  20.  
  21. import random  
  22.  
  23. from keras.optimizers import Adam,RMSprop  
  24.  
  25. import tensorflow as tf  
  26.  
  27. #参考网址：https://blog.51cto.com/u_13259/8067915
  28.  
  29. def create_base_network(input_shape):  
  30.  
  31.     image_input = Input(shape=input_shape)  
  32.  
  33.     x = Flatten()(image_input)  
  34.  
  35.     x = Dense(128, activation='relu')(x)  
  36.  
  37.     x = Dropout(0.1)(x)  
  38.  
  39.     x = Dense(128, activation='relu')(x)  
  40.  
  41.     x = Dropout(0.1)(x)  
  42.  
  43.     x = Dense(128, activation='relu')(x)  
  44.  
  45.     model = Model(image_input,x,name = 'base_network')  
  46.  
  47.     return model  
  48.  
  49.  
  50. def contrastive_loss(y_true, y_pred):  
  51.  
  52.      margin = 1  
  53.  
  54.      sqaure_pred = K.square(y_pred)  
  55.  
  56.      margin_square = K.square(K.maximum(margin - y_pred, 0))  
  57.  
  58.      return K.mean(y_true * sqaure_pred + (1 - y_true) * margin_square)  
  59.  
  60.  
  61. def accuracy(y_true, y_pred): # Tensor上的操作  
  62.  
  63.     return K.mean(K.equal(y_true, K.cast(y_pred < 0.5, y_true.dtype)))  
  64.  
  65.  
  66. def siamese(input_shape):  
  67.  
  68.     base_network = create_base_network(input_shape)  
  69.  
  70.     input_image_1 = Input(shape=input_shape)  
  71.  
  72.     input_image_2 = Input(shape=input_shape)  
  73.  
  74.   
  75.  
  76.     encoded_image_1 = base_network(input_image_1)  
  77.  
  78.     encoded_image_2 = base_network(input_image_2)  
  79.  
  80.   
  81.  
  82.     l2_distance_layer = Lambda(  
  83.  
  84.         lambda tensors: K.sqrt(K.sum(K.square(tensors[0] - tensors[1]), axis=1, keepdims=True))  
  85.  
  86.         ,output_shape=lambda shapes:(shapes[0][0],1))  
  87.  
  88.     l2_distance = l2_distance_layer([encoded_image_1, encoded_image_2])  
  89.  
  90.       
  91.  
  92.     model = Model([input_image_1,input_image_2],l2_distance)  
  93.  
  94.       
  95.  
  96.     return model  
  97.  
  98.  
  99. def process(i):  
  100.  
  101.     # print("!!!!!!!!!!!!!!",i)
  102.     img = Image.open(i,"r")  
  103.  
  104.     img = img.convert("L")  
  105.  
  106.     img = img.resize((wid,hei))  
  107.  
  108.     img = np.array(img).reshape((wid,hei,1))/255  
  109.  
  110.     return img  
  111.  
  112.  
  113. print("程序执行开始！！！！！！！！！！！！！！！！")
  114. #model = load_model("testnumber.h5",custom_objects={'contrastive_loss':contrastive_loss,'accuracy':accuracy})  
  115.  
  116. wid=28  
  117.  
  118. hei=28  
  119.  
  120. model = siamese((wid,hei,1))  
  121.  
  122. imgset=[[],[],[],[],[],[],[],[],[],[]]  
  123.  
  124. for i in glob.glob("../train_new/*.jpg"):  
  125.  
  126.     
  127.     imgset[int(i[-5])].append(process(i))  
  128.  
  129. size = 60000  
  130.  
  131.   
  132.  
  133. r1set = []  
  134.  
  135. r2set = []  
  136.  
  137. flag = []  
  138.  
  139. for j in range(size):  
  140.  
  141.     if j%2==0:  
  142.  
  143.         index = random.randint(0,9)  
  144.  
  145.         r1 = imgset[index][random.randint(0,len(imgset[index])-1)]  
  146.  
  147.         r2 = imgset[index][random.randint(0,len(imgset[index])-1)]  
  148.  
  149.         r1set.append(r1)  
  150.  
  151.         r2set.append(r2)  
  152.  
  153.         flag.append(1.0)  
  154.  
  155.     else:  
  156.  
  157.         index1 = random.randint(0,9)  
  158.  
  159.         index2 = random.randint(0,9)  
  160.  
  161.         while index1==index2:  
  162.  
  163.             index1 = random.randint(0,9)  
  164.  
  165.             index2 = random.randint(0,9)  
  166.  
  167.         r1 = imgset[index1][random.randint(0,len(imgset[index1])-1)]  
  168.  
  169.         r2 = imgset[index2][random.randint(0,len(imgset[index2])-1)]  
  170.  
  171.         r1set.append(r1)  
  172.  
  173.         r2set.append(r2)  
  174.  
  175.         flag.append(0.0)  
  176.  
  177. r1set = np.array(r1set)  
  178.  
  179. r2set = np.array(r2set)  
  180.  
  181. flag = np.array(flag)  
  182.  
  183. model.compile(loss = contrastive_loss,  
  184.  
  185.             optimizer = RMSprop(),  
  186.  
  187.             metrics = [accuracy])  
  188.  
  189. history = model.fit([r1set,r2set],flag,batch_size=128,epochs=20,verbose=2)  
  190.  
  191. # 绘制训练 & 验证的损失值  
  192.  
  193. plt.figure()  
  194.  
  195. plt.subplot(2,2,1)  
  196.  
  197. plt.plot(history.history['accuracy'])  
  198.  
  199. plt.title('Model accuracy')  
  200.  
  201. plt.ylabel('Accuracy')  
  202.  
  203. plt.xlabel('Epoch')  
  204.  
  205. plt.legend(['Train'], loc='upper left')  
  206.  
  207. plt.subplot(2,2,2)  
  208.  
  209. plt.plot(history.history['loss'])  
  210.  
  211. plt.title('Model loss')  
  212.  
  213. plt.ylabel('Loss')  
  214.  
  215. plt.xlabel('Epoch')  
  216.  
  217. plt.legend(['Train'], loc='upper left')  
  218.  
  219. plt.show()  
  220.  
  221. model.save("testnumber.h5")

4)预测

  1. import glob  
  2.  
  3. from PIL import Image  
  4.  
  5. import random  
  6.  
  7. from keras.layers import Input,Dense  
  8.  
  9. from keras.layers import Flatten,Lambda,Dropout  
  10.  
  11. from keras.models import Model  
  12.  
  13. import keras.backend as K  
  14.  
  15. from keras.models import load_model  
  16.  
  17. import numpy as np  
  18.  
  19. from PIL import Image  
  20.  
  21. import glob  
  22.  
  23. import matplotlib.pyplot as plt  
  24.  
  25. from PIL import Image  
  26.  
  27. import random  
  28.  
  29. from keras.optimizers import Adam,RMSprop  
  30.  
  31. import tensorflow as tf  
  32. def process(i):  
  33.  
  34.     img = Image.open(i,"r")  
  35.  
  36.     img = img.convert("L")  
  37.  
  38.     img = img.resize((wid,hei))  
  39.  
  40.     img = np.array(img).reshape((wid,hei,1))/255  
  41.  
  42.     return img  
  43.  
  44. def contrastive_loss(y_true, y_pred):  
  45.  
  46.      margin = 1  
  47.  
  48.      sqaure_pred = K.square(y_pred)  
  49.  
  50.      margin_square = K.square(K.maximum(margin - y_pred, 0))  
  51.  
  52.      return K.mean(y_true * sqaure_pred + (1 - y_true) * margin_square)  
  53.  
  54. def accuracy(y_true, y_pred): # Tensor上的操作  
  55.  
  56.     return K.mean(K.equal(y_true, K.cast(y_pred < 0.5, y_true.dtype)))  
  57.  
  58. def compute_accuracy(y_true, y_pred):  
  59.  
  60.     pred = y_pred.ravel() < 0.5  
  61.  
  62.     return np.mean(pred == y_true)  
  63.  
  64. imgset=[]  
  65.  
  66. wid = 28  
  67.  
  68. hei = 28  
  69.  
  70. imgset=[[],[],[],[],[],[],[],[],[],[]]  
  71.  
  72. for i in glob.glob("../test_new/*.jpg"):  
  73.  
  74.     imgset[int(i[-5])].append(process(i))  
  75.  
  76. model = load_model("../testnumber.h5",custom_objects={'contrastive_loss':contrastive_loss,'accuracy':accuracy})  
  77.  
  78. for i in range(50):  
  79.  
  80.     if random.randint(0,1)==0:  
  81.  
  82.         index=random.randint(0,9)  
  83.  
  84.         r1 = random.randint(0,len(imgset[index])-1)  
  85.  
  86.         r2 = random.randint(0,len(imgset[index])-1)  
  87.  
  88.         plt.figure()  
  89.  
  90.         plt.subplot(2,2,1)  
  91.  
  92.         plt.imshow((255*imgset[index][r1]).astype('uint8'))  
  93.  
  94.         plt.subplot(2,2,2)  
  95.  
  96.         plt.imshow((255*imgset[index][r2]).astype('uint8'))  
  97.  
  98.         y_pred = model.predict([np.array([imgset[index][r1]]),np.array([imgset[index][r2]])])  
  99.  
  100.         print(y_pred)  
  101.  
  102.         plt.show()  
  103.  
  104.     else:  
  105.  
  106.         index1 = random.randint(0,9)  
  107.  
  108.         index2 = random.randint(0,9)  
  109.  
  110.         while index1==index2:  
  111.  
  112.             index1 = random.randint(0,9)  
  113.  
  114.             index2 = random.randint(0,9)  
  115.  
  116.         r1 = random.randint(0,len(imgset[index1])-1)  
  117.  
  118.         r2 = random.randint(0,len(imgset[index2])-1)  
  119.  
  120.         plt.figure()  
  121.  
  122.         plt.subplot(2,2,1)  
  123.  
  124.         plt.imshow((255*imgset[index1][r1]).astype('uint8'))  
  125.  
  126.         plt.subplot(2,2,2)  
  127.  
  128.         plt.imshow((255*imgset[index2][r2]).astype('uint8'))  
  129.  
  130.         y_pred = model.predict([np.array([imgset[index1][r1]]),np.array([imgset[index2][r2]])])  
  131.  
  132.         print(y_pred)  
  133.  
  134.         plt.show()

测试结果显示：

 

五、使用孪生网络做指纹识别

参考链接： 指纹识别实战--基于TensorFlow实现-腾讯云开发者社区-腾讯云 (tencent.com)

1）孪生网络的检测原理

孪生神经网络英文简称为Siamese网络,它的主体结构是由一对共享相同权值的神经网络所组成的，通常被用于来计算数据之间的相似度，也正是因为具有相同的权值，因此才被称为“孪生”。值得注意的是，它并不是一个具体的神经网络模型，而只是一个架构，其中两边的输入网络可以被自定义设置为具体的CNN卷积神经网络或其它模型。

通常来说，输入到孪生神经网络里的一对数据最后都会被分别转换成一个向量的形式，之后根据这二者向量之间的差异来得到它们之间的相似度，例如常见的度量指标有欧氏距离和余弦距离等。整个网络的训练目标是让两个相似的输入距离尽可能的小，而让两个不同类别或差异较大的输入距离尽可能的大。以人脸识别为例，同一个人的脸被认为是相似输入，而不同人的人脸即被认为是不同输入，其示意图如图所示。

 2）数据集准备

2.1 数据下载

       将孪生神经网络应用到当前的指纹识别实战任务中去，即是将网络的输入数据替换成指纹图像。同一个人的指纹输入即为相似输入，对应的标签为1。不同人的指纹输入即为不同输入，标签为0。而该网络的设计目的便是让它可以根据输入的指纹图像来判断这对指纹是否属于同一个人，即达到指纹识别的目的。通常其中一个输入可被视为是保存在数据库里的指纹模板，另一个输入则是当前用户访问服务时被采集到的指纹数据，其模型示意图如图4所示。

所使用的指纹数据来自于中国科学院生物特征与安全研究中心里的指纹数据库，其数据下载网站为： http://biometrics.idealtest.org/findTotalDbByMode.do?mode=Fingerprint。如何下载可以参考原参考链接中的下载方法。

整个CASIA指纹数据集一共由5880张指纹组成，它们分别采自于不同的实验对象，其中针对每个实验对象的左、右食指和中指进行一共20次指纹图像的采集，即每个手指分别会被采集5次，图10展示了CASIA数据中的一个试验者被采集到的左、右食指和中指的指纹图像。

 

2.2 数据配准 

由于在CASIA指纹数据集中，采集到的指纹数据特征有可能各不相同，有些采集到的指纹特征甚至已经遭到破坏(如潮湿、刮伤等)，因此分析这种包含各种真实情况的指纹数据集会更加具有实际意义。而在利用孪生神经网络对不同人的指纹进行匹配之前，最重要的一步那便是指纹的对齐操作。

由于在指纹采集的过程中手指会产生旋转、偏移或错位，因此采集到的指纹图像其中很多都是无法正常对齐的，特征点无法直接进行匹配。所以需要先将数据配准。

单独两张图像的配准代码如下：

  1. import cv2
  2. import numpy as np
  3. import os
  4. import matplotlib.pyplot as plt
  5.  
  6. def alignImages(im1, im2):
  7.     im1Gray = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY)   #将图片转换为灰度图
  8.     im2Gray = cv2.cvtColor(im2, cv2.COLOR_BGR2GRAY)
  9.     sift = cv2.xfeatures2d.SIFT_create()   #调用SIFT算法
  10.     keypoints1, descriptors1 = sift.detectAndCompute(im1Gray, None)   #检测特征点和描述符
  11.     keypoints2, descriptors2 = sift.detectAndCompute(im2Gray, None)
  12.     
  13.     matcher = cv2.BFMatcher()   #调用Brute Force匹配算法
  14.     matches = matcher.match(descriptors1, descriptors2, None)   #对两张指纹图像进行匹配
  15.     matches.sort(key=lambda x: x.distance, reverse=False)   #将匹配分数进行排序
  16.     numGoodMatches = int(len(matches)*0.2)   #选取排序得分前20%的指纹
  17.     
  18.     matches = matches[:numGoodMatches]
  19.     #绘制匹配点
  20.     imMatches = cv2.drawMatches(im1, keypoints1, im2, keypoints2, matches, None)
  21.     
  22.     cv2.imwrite("matches.jpg", imMatches)   #保存匹配图像
  23.  
  24.     points1 = np.zeros((len(matches), 2), dtype=np.float32)
  25.     points2 = np.zeros((len(matches), 2), dtype=np.float32)
  26.     for i, match in enumerate(matches):   #提取匹配点的位置
  27.         points1[i, :] = keypoints1[match.queryIdx].pt 
  28.         points2[i, :] = keypoints2[match.trainIdx].pt  
  29.     h, mask = cv2.findHomography(points1, points2, cv2.RANSAC)   #寻找仿射矩阵
  30.     height, width, channels = im2.shape
  31.     
  32.     im1Reg = cv2.warpPerspective(im1, h, (width, height))   #对匹配图像进行对齐   
  33.     return im1Reg, h
  34.  
  35. if __name__ == "__main__":
  36.  
  37.     refFilename = "0403_00032_0001_1_S.bmp"   
  38.     imReference = cv2.imread(refFilename, cv2.IMREAD_COLOR)   #读取图像
  39.     imFilename = "0403_00032_0002_2_S.bmp"
  40.     im = cv2.imread(imFilename, cv2.IMREAD_COLOR)
  41.     imReg, h = alignImages(im, imReference)   #对齐图像
  42.     outFilename = "aligned.bmp"   #存储对齐图像的名称
  43.     cv2.imwrite(outFilename, imReg)   #保存对齐图像
  44.     print("Estimated homography : \n",  h)   #输出单适应矩阵

配准后 的结果示例如图所示：可以看出在对齐之前，输入的指纹图像与待匹配图像从位置上无法一一对应，而在对齐之后，以如图所示的指纹中间的螺旋纹为标准，可以看出两个指纹已成功完成对齐操作。但是很明显可以看出在执行SIFT算法之后，生成的对齐图像缺失了一部分图像信息，这部分信息是原图之前所没有的，在SIFT算法里会直接将它们填充成无关的背景色。

    之后将SIFT算法应用于CASIA数据集上，作为实战案例这里只选取了其中一小部分数据集进行指纹识别项目演示。以同一个人相同手指的第一张指纹图像作为对齐标准，剩下的四张指纹图像作为待对齐的图像。首先需要生成指定要求的对应文件路径，方便后续进行对齐并加载保存：

  1. import cv2
  2. import numpy as np
  3. import os
  4. import matplotlib.pyplot as plt
  5.  
  6. def alignImages(im1, im2):
  7.     im1Gray = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY)   #将图片转换为灰度图
  8.     im2Gray = cv2.cvtColor(im2, cv2.COLOR_BGR2GRAY)
  9.     sift = cv2.xfeatures2d.SIFT_create()   #调用SIFT算法
  10.     keypoints1, descriptors1 = sift.detectAndCompute(im1Gray, None)   #检测特征点和描述符
  11.     keypoints2, descriptors2 = sift.detectAndCompute(im2Gray, None)
  12.     
  13.     matcher = cv2.BFMatcher()   #调用Brute Force匹配算法
  14.     matches = matcher.match(descriptors1, descriptors2, None)   #对两张指纹图像进行匹配
  15.     matches.sort(key=lambda x: x.distance, reverse=False)   #将匹配分数进行排序
  16.     numGoodMatches = int(len(matches)*0.2)   #选取排序得分前20%的指纹
  17.     
  18.     matches = matches[:numGoodMatches]
  19.     #绘制匹配点
  20.     imMatches = cv2.drawMatches(im1, keypoints1, im2, keypoints2, matches, None)
  21.     
  22.     cv2.imwrite("matches.jpg", imMatches)   #保存匹配图像
  23.  
  24.     points1 = np.zeros((len(matches), 2), dtype=np.float32)
  25.     points2 = np.zeros((len(matches), 2), dtype=np.float32)
  26.     for i, match in enumerate(matches):   #提取匹配点的位置
  27.         points1[i, :] = keypoints1[match.queryIdx].pt 
  28.         points2[i, :] = keypoints2[match.trainIdx].pt  
  29.     h, mask = cv2.findHomography(points1, points2, cv2.RANSAC)   #寻找仿射矩阵
  30.     height, width, channels = im2.shape
  31.     
  32.     im1Reg = cv2.warpPerspective(im1, h, (width, height))   #对匹配图像进行对齐   
  33.     return im1Reg, h
  34.  
  35. if __name__ == "__main__":
  36.  
  37.     #读取数据集路径
  38.     dir_path = r'D:\Project_code\fingerPrint\CASIA_Fingerprint_Subject_Ageing\2013\uru4000\2' 
  39.     folder_list = os.listdir(dir_path)   #查看该路径下文件夹信息
  40.     #得到每个文件夹的具体路径
  41.     imagePath_list = [os.path.join(dir_path, imageName) for imageName in folder_list] 
  42.     imageAlignedPath = []
  43.     for i in imagePath_list:
  44.         firstIndex = 0
  45.         imageName_list = os.listdir(i)   #遍历每个文件夹下的图片名称
  46.         for j in range(len(imageName_list)):
  47.             if j == firstIndex:           
  48.                 continue
  49.             elif j%5==0:                 
  50.                 firstIndex+=5
  51.             else:
  52.                 image1Path_list = [os.path.join(i, imageName_list[firstIndex])]  
  53.                 imageAlignedPath.append(image1Path_list)        
  54.                 image2Path_list = [os.path.join(i, imageName_list[j])]    
  55.                 #准备待对齐的指纹路径，格式为前面一张为指纹对齐参考图像，后一张为待对齐图像，不断循环
  56.                 imageAlignedPath.append(image2Path_list)
  57.  
  58.     #读取制作好的指纹图像文件路径，调用SIFT算法对它们进行一一匹配并保存至指定文件夹中：
  59.     i = 0 
  60.     name = 1
  61.     while i < len(imageAlignedPath):
  62.         reference = cv2.imread(imageAlignedPath[i][0], cv2.IMREAD_COLOR)   #读取指纹对齐参考图像  
  63.         aligned = cv2.imread(imageAlignedPath[i+1][0], cv2.IMREAD_COLOR)   #读取待对齐的图像
  64.         aligned_out, h = alignImages(reference, aligned)   #对齐图像
  65.         reference_outName = imageAlignedPath[i][0][-23:-4]   #读取指纹对齐参考图像文件名
  66.         aligned_outName = imageAlignedPath[i+1][0][-23:-4]   #读取指纹待对齐图像的文件名
  67.         #参考图像和对齐图像的存储路径
  68.         save_path1 = r'D:\Project_code\fingerPrint\dataset\Genuine\(6)unaligned_souce\reference'
  69.         save_path2 = r'D:\Project_code\fingerPrint\dataset\Genuine\(6)unaligned_souce\aligned'
  70.         print("Reference image : ", reference_outName)
  71.         print("Saving aligned image : ", aligned_outName) 
  72.         reference_savePath = save_path1 + "\\" + str(name) +'.jpg'
  73.         aligned_savePath = save_path2 + "\\" + str(name) +'.jpg'
  74.         cv2.imwrite(reference_savePath,reference)   #存储指纹对齐参考图像
  75.         cv2.imwrite(aligned_savePath,aligned_out)   #存储已对齐的指纹图像
  76.         i+=2
  77.         name+=1

输出结果为：

有部分数据，会因为特征点的数目过少，导致配准失败，在训练前需要将配准失败的数据删除。最终待训练的数据结果如图所示：

3）模型搭建及训练

        在对指纹数据集进行对齐和一定的预处理操作之后，下一步便是将这些成对的指纹图像送入到孪生神经网络中以便于完成指纹识别任务的训练，匹配指纹图像和指纹模板图像各自选取278张，其中139张为同一个人相同手指的指纹，139张为不同人相同手指的指纹。所以这个后139张图像的标签为0.

下面的代码包含了对数据集的数据转换、网络搭建、损失的定义、网络的训练、网络模型的保存。

  1. import tensorflow as tf
  2. from tensorflow import keras 
  3. import cv2
  4. import os
  5. import matplotlib.pyplot as plt
  6. import numpy as np
  7. from tensorflow.keras import backend as K
  8. from tensorflow.keras.preprocessing import image
  9.  
  10. #训练数据的路径，数据是经过配准的，是使用配准后的图像进行训练的
  11. Train_referencePath = r'D:\Project_code\fingerPrint\dataset\Genuine\(2)Reference'
  12. Train_alignedPath = r'D:\Project_code\fingerPrint\dataset\Genuine\(2)Aligned'
  13.  
  14. #读取路径下的图像数据，并将它们储存至列表当中，方便模型后续处理：
  15. referenceTrain = []
  16. alignedTrain = []
  17. Train_sourceImageList = os.listdir(Train_referencePath)
  18. Train_sourceImageList.sort(key=lambda x:int(x[:-4]))
  19. Train_alignedImageList = os.listdir(Train_alignedPath)
  20. Train_alignedImageList.sort(key=lambda x:int(x[:-4]))
  21. for i in Train_sourceImageList:
  22.     imagePath = os.path.join(Train_referencePath,i)   #读取reference图像路径
  23.     referenceImage = image.load_img(imagePath)   #加载图像成jpg格式
  24.     img_array = image.img_to_array(referenceImage)   #转换成array格式
  25.     referenceTrain.append(img_array)   #保存至列表
  26. for i in Train_alignedImageList:
  27.     imagePath = os.path.join(Train_alignedPath,i)
  28.     alignedImage = image.load_img(imagePath)
  29.     img_array = image.img_to_array(alignedImage)
  30.     alignedTrain.append(img_array)
  31.  
  32. #将列表形式转换为numpy数组：
  33. print("Original type:%s"%type(referenceTrain))
  34. referenceTrain = np.array(referenceTrain)   #转换图像类型
  35. alignedTrain = np.array(alignedTrain)
  36. print("Converted type:%s"%type(referenceTrain))  
  37.  
  38. #数据的归一化处理
  39. referenceTrain = referenceTrain.astype('float32')/255   #图像归一化
  40. alignedTrain = alignedTrain.astype('float32')/255
  41. print(alignedTrain[-1].shape)   #查看图像尺寸
  42.  
  43. #标签的制作 匹配指纹图像和指纹模板图像各自选取278张，其中139张为同一个人相同手指的指纹，139张为不同人相同手指的指纹
  44. labels = [1]*139 + [0]*139   #制作图像标签
  45. labels = np.array(labels).astype('float32')   #标签类型转换
  46. print(type(labels))
  47.  
  48. #定义以欧氏距离为基础的输入图像对的距离衡量函数，对抗损失函数以及准确率指标计算函数:
  49. def euclidean_distance(vects):   #向量欧式距离计算
  50.     x, y = vects
  51.     sum_square = K.sum(K.square(x - y), axis=1, keepdims=True)
  52.     return K.sqrt(K.maximum(sum_square, K.epsilon()))  
  53.  
  54. def eucl_dist_output_shape(shapes):   #结果输出维度
  55.     shape1, shape2 = shapes
  56.     return (shape1[0], 1)
  57.  
  58. def contrastive_loss(y_true, y_pred):   #对抗损失函数
  59.     margin = 1
  60.     sqaure_pred = K.square(y_pred)
  61.     margin_square = K.square(K.maximum(margin - y_pred, 0))
  62.     return K.mean(y_true * sqaure_pred + (1 - y_true) * margin_square)
  63.  
  64. def accuracy(y_true, y_pred):   #模型训练评判指标
  65.     return K.mean(K.equal(y_true, K.cast(y_pred <0.5, y_true.dtype)))
  66.  
  67.  
  68. #定义孪生神经网络的模型架构   其中卷积层里的dilation_rate表示的是空洞卷积的扩张率，经过不断的前向传播，最后模型会输出一个向量值用来衡量图像间的距离和相似度：
  69. def MDCNN_network(input_shape):   #模型搭建
  70.     input = keras.layers.Input(shape = input_shape)
  71.     x = keras.layers.Conv2D(filters=2,kernel_size=3,input_shape=(356,328,3))(input)
  72.     x = keras.activations.selu(x)
  73.     x1 = keras.layers.Conv2D(filters=4,kernel_size=3,strides=1,padding='same')(x)
  74.     x1 = keras.activations.selu(x1)
  75.     x2 = keras.layers.Conv2D(filters=4,kernel_size=3,strides=1,dilation_rate=(2,2),padding='same')(x)
  76.     x2 = keras.activations.selu(x2)
  77.     x3 = keras.layers.Conv2D(filters=4,kernel_size=3,strides=1,dilation_rate=(3,3),padding='same')(x)
  78.     x3 = keras.activations.selu(x3)
  79.     x = keras.layers.Add()([x1,x2,x3])
  80.     x = keras.layers.Conv2D(filters=8,kernel_size=3)(x)
  81.     x = keras.activations.selu(x)
  82.     x1 = keras.layers.Conv2D(filters=16,kernel_size=3,strides=2)(x)
  83.     x1 = keras.activations.selu(x1)
  84.     x2 = keras.layers.Conv2D(filters=16,kernel_size=3,strides=2)(x)
  85.     x2 = keras.activations.selu(x2)
  86.     x3 = keras.layers.Conv2D(filters=16,kernel_size=3,strides=2)(x)
  87.     x3 = keras.activations.selu(x3)
  88.     x = keras.layers.Add()([x1,x2,x3])
  89.     x = keras.layers.Conv2D(filters=32,kernel_size=3)(x)
  90.     x = keras.activations.selu(x)
  91.     x = keras.layers.Conv2D(filters=64,kernel_size=3,strides=2)(x)
  92.     x = keras.activations.selu(x)
  93.     x = keras.layers.Flatten()(x)
  94.     x = keras.layers.Dense(10)(x)
  95.     return keras.models.Model(input, x)
  96.  
  97. #利用先前定义过的距离函数，将模型的输出转换成欧式距离上的衡量，并将它拼接至搭建的模型上：
  98. base_network = MDCNN_network(referenceTrain[0].shape)
  99. input_a = keras.Input(shape=referenceTrain[0].shape)
  100. input_b = keras.Input(shape=alignedTrain[0].shape)
  101. processed_a = base_network(input_a)   #模型一路输入
  102. processed_b = base_network(input_b)   #模型另一路输入
  103. distance = keras.layers.Lambda(euclidean_distance,output_shape=eucl_dist_output_shape)([processed_a, processed_b])
  104. model = keras.models.Model([input_a, input_b], distance)   #模型拼接
  105.  
  106. #配置模型的损失函数、优化器、评价指标等相关训练参数：
  107. model.compile(loss=contrastive_loss,optimizer='adam',metrics=[accuracy])
  108.  
  109. #对模型进行训练：epochs=10可以设置训练的次数
  110. history=model.fit([referenceTrain, alignedTrain],labels,batch_size=1,epochs=10,verbose=1)
  111.  
  112. model.save("trainmodel.h5")

定义孪生神经网络的模型架构，这里采用多尺度空洞卷积组合所构成的神经网络，该模型已被相关文献证明是一个能够提取不同尺度的指纹细节点特征的匹配网络结构。其中模型示意图如图所示： 

4）模型的推理

  1. import tensorflow as tf
  2. from tensorflow import keras 
  3. import cv2
  4. import os
  5. import matplotlib.pyplot as plt
  6. import numpy as np
  7. from tensorflow.keras import backend as K
  8. from tensorflow.keras.preprocessing import image
  9.  
  10. #定义以欧氏距离为基础的输入图像对的距离衡量函数，对抗损失函数以及准确率指标计算函数:
  11. def euclidean_distance(vects):   #向量欧式距离计算
  12.     x, y = vects
  13.     sum_square = K.sum(K.square(x - y), axis=1, keepdims=True)
  14.     return K.sqrt(K.maximum(sum_square, K.epsilon()))  
  15.  
  16. def eucl_dist_output_shape(shapes):   #结果输出维度
  17.     shape1, shape2 = shapes
  18.     return (shape1[0], 1)
  19.  
  20. def contrastive_loss(y_true, y_pred):   #对抗损失函数
  21.     margin = 1
  22.     sqaure_pred = K.square(y_pred)
  23.     margin_square = K.square(K.maximum(margin - y_pred, 0))
  24.     return K.mean(y_true * sqaure_pred + (1 - y_true) * margin_square)
  25.  
  26. def accuracy(y_true, y_pred):   #模型训练评判指标
  27.     return K.mean(K.equal(y_true, K.cast(y_pred <0.5, y_true.dtype)))
  28.  
  29. model = keras.models.load_model("../trainmodel.h5",custom_objects={'contrastive_loss':contrastive_loss,'accuracy':accuracy})  
  30.  
  31.  
  32. def testImage_preprocessing(image_path):   #测试图像预处理函数
  33.     testImage = image.load_img(image_path)   #图像加载
  34.     plt.imshow(testImage)
  35.     plt.show()
  36.     testImage = image.img_to_array(testImage).astype('float32')/255
  37.     testImage = np.expand_dims(testImage,axis=0)   #图像维度增添以满足模型输入要求
  38.     return testImage
  39.  
  40.  
  41. # Train_referencePath = '..CASIA_code/data/pdf/'
  42. # Train_alignedPath = '..CASIA_code/data/image/'
  43.  
  44.  
  45. same_path_1 = '/home/sim_code/CASIA_code/data/pdf/0.bmp'
  46. same_path_2 = '/home/sim_code/CASIA_code/data/image/0.bmp'
  47. different_path_1 = '/home/sim_code/CASIA_code/data/pdf/80.bmp'
  48. different_path_2 = '/home/sim_code/CASIA_code/data/image/80.bmp'
  49. same_testImage_1 = testImage_preprocessing(same_path_1)
  50. same_testImage_2 = testImage_preprocessing(same_path_2)
  51. different_testImage_1 = testImage_preprocessing(different_path_1)
  52. different_testImage_2 = testImage_preprocessing(different_path_2)
  53.  
  54. sameScore = model.predict([same_testImage_1,same_testImage_2]) #相同指纹距离预测
  55. differentScore = model.predict([different_testImage_1,different_testImage_2]) #不同指纹距离预测
  56.  
  57. print("The distance of same fingerprint:%f"%sameScore[0][0])
  58. print("The distance of different fingerprint:%f"%differentScore[0][0])

推理的结果为：

The distance of same fingerprint:0.150276 #相同指纹距离小

The distance of different fingerprint:1.036739 #不同指纹距离大

六、用孪生网络做人脸相似性识别

参考博文： 基于改进孪生网络的人脸识别方法（讲解+代码V1.0）-CSDN博客

代码下载地址：GitHub - damoshishen/FR_twin_network: In this paper, a small sample face recognition algorithm and system design based on improved twin network are reproduced.基础环境：tensorflow+keras

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/373367?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号