在Tensorflow上实现一个简单的暹罗网络

我想使用mnist数据集实现一个暹罗MLP网络。

---

我基于Keras mnist_siamese_图构建了我的代码，但与Keras版本相比，错误值和准确性非常大。 我不知道哪里出了问题。 这是我的代码：

import random
import numpy as np
import time
import tensorflow as tf 
import input_data
mnist = input_data.read_data_sets("/tmp/data",one_hot=False)

import pdb
def create_pairs(x, digit_indices):
    '''Positive and negative pair creation.
    Alternates between positive and negative pairs.
    '''
    pairs = []
    labels = []
    n = min([len(digit_indices[d]) for d in range(10)]) - 1
    for d in range(10):
        for i in range(n):
            z1, z2 = digit_indices[d][i], digit_indices[d][i+1]
            pairs += [[x[z1], x[z2]]]
            inc = random.randrange(1, 10)
            dn = (d + inc) % 10
            z1, z2 = digit_indices[d][i], digit_indices[dn][i]
            pairs += [[x[z1], x[z2]]]
            labels += [1, 0]
    return np.array(pairs), np.array(labels)


def mlp(input_,input_dim,output_dim,name="mlp"):
    with tf.variable_scope(name):
        w = tf.get_variable('w',[input_dim,output_dim],tf.float32,tf.random_normal_initializer())
        return tf.nn.relu(tf.matmul(input_,w))

def build_model_mlp(X_,_dropout):

    model = mlpnet(X_,_dropout)
    return model

def mlpnet(image,_dropout):
    l1 = mlp(image,784,128,name='l1')
    l1 = tf.nn.dropout(l1,_dropout)
    l2 = mlp(l1,128,128,name='l2')
    l2 = tf.nn.dropout(l2,_dropout)
    l3 = mlp(l2,128,128,name='l3')
    return l3
def contrastive_loss(y,d):
    tmp= y *tf.square(d)
    #tmp= tf.mul(y,tf.square(d))
    tmp2 = (1-y) *tf.square(tf.maximum((1 - d),0))
    return tf.reduce_sum(tmp +tmp2)/batch_size/2

def compute_accuracy(prediction,labels):
    return labels[prediction.ravel() < 0.5].mean()
    #return tf.reduce_mean(labels[prediction.ravel() < 0.5])
def next_batch(s,e,inputs,labels):
    input1 = inputs[s:e,0]
    input2 = inputs[s:e,1]
    y= np.reshape(labels[s:e],(len(range(s,e)),1))
    return input1,input2,y

# Initializing the variables
init = tf.initialize_all_variables()
# the data, shuffled and split between train and test sets
X_train = mnist.train._images
y_train = mnist.train._labels
X_test = mnist.validation._images
y_test = mnist.validation._labels
batch_size =128
# create training+test positive and negative pairs
digit_indices = [np.where(y_train == i)[0] for i in range(10)]
tr_pairs, tr_y = create_pairs(X_train, digit_indices)
digit_indices = [np.where(y_test == i)[0] for i in range(10)]
te_pairs, te_y = create_pairs(X_test, digit_indices)

images_L = tf.placeholder(tf.float32,shape=([None,784]),name='L')
images_R = tf.placeholder(tf.float32,shape=([None,784]),name='R')
labels = tf.placeholder(tf.float32,shape=([None,1]),name='gt')
dropout_f = tf.placeholder("float")
with tf.variable_scope("siamese") as scope:
    model1= build_model_mlp(images_L,dropout_f)
    scope.reuse_variables()
    model2 = build_model_mlp(images_R,dropout_f)

distance  = tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(model1,model2),2),1,keep_dims=True))
loss = contrastive_loss(labels,distance)
#contrastice loss
t_vars = tf.trainable_variables()
d_vars  = [var for var in t_vars if 'l' in var.name]
batch = tf.Variable(0)
optimizer = tf.train.RMSPropOptimizer(0.001,momentum=0.9,epsilon=1e-6).minimize(loss)
# Launch the graph
with tf.Session() as sess:
    #sess.run(init)
    tf.initialize_all_variables().run()
    # Training cycle
    for epoch in range(40):
        print('epoch %d' % epoch)
        avg_loss = 0.
        avg_acc = 0.
        total_batch = int(X_train.shape[0]/batch_size)
        start_time = time.time()
        # Loop over all batches
        for i in range(total_batch):
            s  = i * batch_size
            e = (i+1) *batch_size
            # Fit training using batch data
            input1,input2,y =next_batch(s,e,tr_pairs,tr_y)
            _,loss_value,predict=sess.run([optimizer,loss,distance], feed_dict={images_L:input1,images_R:input2 ,labels:y,dropout_f:0.9})
            tr_acc = compute_accuracy(predict,y)
            avg_loss += loss_value
            avg_acc +=tr_acc*100
        #print('epoch %d loss %0.2f' %(epoch,avg_loss/total_batch))
        duration = time.time() - start_time
        print('epoch %d  time: %f loss %0.2f acc %0.2f' %(epoch,duration,avg_loss/(total_batch),avg_acc/total_batch))
    y = np.reshape(tr_y,(tr_y.shape[0],1))
    predict=distance.eval(feed_dict={images_L:tr_pairs[:,0],images_R:tr_pairs[:,1],labels:y,dropout_f:1.0})
    tr_acc = compute_accuracy(predict,y)
    print('Accuract training set %0.2f' % (100 * tr_acc))

随机导入
将numpy作为np导入
导入时间
导入tensorflow作为tf
导入输入数据
mnist=输入数据。读取数据集（“/tmp/data”，one\u hot=False）
导入pdb
def创建_对（x，数字索引）：
''积极和消极的配对创造。
在正对和负对之间交替。
'''
成对=[]
标签=[]
n=范围（10）内d的最小值（[len（数字索引[d]））-1
对于范围（10）内的d：
对于范围（n）中的i：
z1，z2=数字索引[d][i]，数字索引[d][i+1]
配对+=[[x[z1]，x[z2]]
inc=随机随机随机范围（1,10）
dn=（d+inc）%10
z1，z2=数字索引[d][i]，数字索引[dn][i]
配对+=[[x[z1]，x[z2]]
标签+=[1,0]
返回np.array（对），np.array（标签）
def mlp（输入尺寸、输入尺寸、输出尺寸、名称=“mlp”）：
具有tf.variable_作用域（名称）：
w=tf.get_变量（'w'，[input_dim，output_dim]，tf.float32，tf.random_normal_initializer（））
返回tf.nn.relu（tf.matmul（输入，w））
def构建模型mlp（X，X退出）：
模型=mlpnet（X_u，u辍学）
回归模型
def mlpnet（图像，下拉）：
l1=mlp（图，784128，name='l1'）
l1=tf.nn.辍学（l1，_辍学）
l2=mlp（L1128128，name='l2'）
l2=tf.nn.辍学（l2，_辍学）
l3=mlp（L2128128，name='l3'）
返回l3
def对比损耗（y，d）：
tmp=y*tf.平方（d）
#tmp=tf.mul（y，tf.square（d））
tmp2=（1-y）*tf.平方（tf.最大值（（1-d），0））
返回tf.减少总和（tmp+tmp2）/批次大小/2
def计算精度（预测、标签）：
返回标签[prediction.ravel（）<0.5].mean（）
#返回tf.reduce_平均值（标签[prediction.ravel（）<0.5]）
def下一批（s、e、输入、标签）：
输入1=输入[s:e，0]
输入2=输入[s:e，1]
y=np.重塑（标签[s:e]，（透镜（范围（s，e）），1））
返回输入1，输入2，y
#初始化变量
初始化所有变量（）
#数据在训练集和测试集之间混合和分割
X_train=mnist.train.\u图像
y_train=mnist.train.\u标签
X_测试=列表验证。_图像
y_测试=列表验证。_标签
批量大小=128
#创建训练+测试积极和消极对
数字索引=[np.其中（y\u列==i）[0]表示范围（10）内的i]
tr_对，tr_y=创建_对（X_序列，数字索引）
数字索引=[np.其中（y_测试==i）[0]表示范围（10）内的i]
te_对，te_y=创建_对（X_测试，数字索引）
images_L=tf.placeholder（tf.float32，shape=（[None，784]），name='L'）
图像\u R=tf.placeholder（tf.float32，shape=（[None，784]），name='R'）
labels=tf.placeholder（tf.float32，shape=（[None，1]），name='gt'）
辍学\u f=tf.占位符（“浮动”）
以tf.variable_scope（“暹罗”）作为作用域：
模型1=构建模型mlp（图像、退出）
作用域。重用_变量（）
模型2=构建模型mlp（图像、退出）
距离=tf.sqrt（tf.reduce_sum（tf.pow（tf.sub（model1，model2），2），1，keep_dims=True））
损耗=对比损耗（标签、距离）
#冰损
t_vars=tf.可训练的_变量（）
d_vars=[t_vars中的var的var，如果var.name中的'l'
批处理=tf.变量（0）
优化器=tf.train.RMSPropOptimizer（0.001，动量=0.9，ε=1e-6）。最小化（损失）
#启动图表
使用tf.Session（）作为sess：
#sess.run（初始化）
tf.initialize_all_variables（）.run（）
#训练周期
对于范围内的历元（40）：
打印（'历元%d'%历元）
平均损耗=0。
平均加速度=0。
总批次=整数（X列形状[0]/批次大小）
开始时间=time.time（）
#循环所有批次
对于范围内的i（总批次）：
s=i*批量大小
e=（i+1）*批量大小
#使用批处理数据进行拟合训练
输入1，输入2，y=下一批（s，e，tr对，tr对y）
_，loss\u value，predict=sess.run（[optimizer，loss，distance]，feed\u dict={images\u L:input1，images\u R:input2，labels:y，dropout\u f:0.9}）
tr_acc=计算精度（预测，y）
平均损耗+=损耗值
平均加速度+=tr加速度*100
#打印（'历元%d损失%0.2f'（历元，平均损失/总批次））
持续时间=时间。时间（）-开始时间
打印（'历元%d时间：%f损失%0.2f附件%0.2f%'（历元、持续时间、平均损失/（总批次）、平均附件/总批次））
y=np.重塑（tru y，（tru y.形状[0]，1））
predict=distance.eval（feed_dict={images_L:tr_pairs[：，0]，images_R:tr_pairs[：，1]，label:y，dropout_f:1.0}）
tr_acc=计算精度（预测，y）
打印（'Accuract训练集%0.2f'（100*tr_acc））

“误差值和精度非常大”表示精度低？与Keras版本相比低多少？需要更多的信息。您解决了这个问题吗？“错误值和准确度非常大”表示准确度很低？与Keras版本相比低多少？需要更多的信息。你解决了这个问题吗？