在连体网络中维护层权重

问题描述

我正在寻找一个用于分析运动学数据的暹罗网络：

#Variables for the for func
input_shapes = [[(None,3),(None,9)],[(None,9)]]

num_trackers = len(input_shapes)
num_clusters = len(input_shapes[0])

x = [[None for a in range(0,num_clusters)] for b in range(0,num_trackers)]
y = [[None for a in range(0,num_trackers)]

conv1_left = [[None for a in range(0,num_trackers)]
conv1_right = [[None for a in range(0,num_trackers)]

tracker_layer_left = [None for a in range(num_trackers)]
tracker_layer_right= [None for a in range(num_trackers)]

conv2_left = [None for a in range(num_trackers)]
conv2_right = [None for a in range(num_trackers)]

#the function that builds the network

def build_siamese_network():
    #make l & r inputs the same,we need two different for-loops
    for i in range(0,num_trackers):
        for j in range(0,num_clusters):
            x[i][j] = k.layers.Input(input_shapes[i][j])
            conv1_left[i][j] = k.layers.Conv1D(filters=8,kernel_size=3,strides=1,padding='same',activity_regularizer=regularizers.l2(.001))(x[i][j])
            conv1_left[i][j] = k.layers.Activation('relu')(conv1_left[i][j])
        tracker_layer_left[i] = k.layers.Concatenate(axis=-1)(conv1_left[i])
        conv2_left[i] = k.layers.Conv1D(filters=16,activity_regularizer=regularizers.l2(.001))(tracker_layer_left[i])
        conv2_left[i] = k.layers.Activation('relu')(conv2_left[i])
    final_input_left = k.layers.Concatenate(axis=-1)(conv2_left)
    conv3_left = k.layers.Conv1D(filters = 32,strides = 1,activity_regularizer=regularizers.l2(.001))(final_input_left)
    conv3_left = k.layers.Activation('relu',name='conv_final_left')(conv3_left)
    pooled_left = k.layers.GlobalAveragePooling1D()(conv3_left)
    
    
    for i in range(0,num_clusters):
            y[i][j] = k.layers.Input(input_shapes[i][j])
            conv1_right[i][j] = k.layers.Conv1D(filters=8,activity_regularizer=regularizers.l2(.001))(y[i][j])
            conv1_right[i][j] = k.layers.Activation('relu')(conv1_right[i][j])
        tracker_layer_right[i] = k.layers.Concatenate(axis=-1)(conv1_right[i])
        conv2_right[i] = k.layers.Conv1D(filters=16,activity_regularizer=regularizers.l2(.001))(tracker_layer_right[i])
        conv2_right[i] = k.layers.Activation('relu')(conv2_right[i])
    final_input_right = k.layers.Concatenate(axis=-1)(conv2_right)
    conv3_right = k.layers.Conv1D(filters = 32,activity_regularizer=regularizers.l2(.001))(final_input_right)
    conv3_right = k.layers.Activation('relu',name='conv_final_right')(conv3_right)
    pooled_right = k.layers.GlobalAveragePooling1D()(conv3_right)                                                       
                                                           
    subtracted = k.layers.Subtract()([pooled_left,pooled_right])
    prediction = k.layers.Dense(2,activation='softmax')(subtracted)
    
    input_list = list(chain.from_iterable(x))
    input_list.extend(list(chain.from_iterable(y)))
    optimizer = k.optimizers.Adam(lr= .001,amsgrad= 0)
                                                           
    model = k.Model(input=input_list,output=prediction)
    model.compile(loss='binary_crossentropy',optimizer = optimizer)

    return model

我遇到的问题是我希望能够将函数中第二个for循环的权重设置为等于第一个。但是，我弄清楚如何做到这一点的唯一方法是运行模型，然后再拥有另一个函数，该函数对图层进行索引并将彼此相等。

def setWeights():
    layer1_list = model.layers[36:72]
    length1 = len(model.layers[36:72])
    
    middle_index1 = length1//2
    
    first_half_layer1 = layer1_list[:middle_index1]
    second_half_layer1 = layer1_list[middle_index1:]
    
    layer2_list = model.layers[120:132]

    length2 = len(model.layers[120:132])

    middle_index2 = length2//2

    first_half_layer2 = layer2_list[:middle_index2]
    second_half_layer2 = layer2_list[middle_index2:]
    
    layer3_list = model.layers[146:148]

    length3 = len(model.layers[146:148])

    middle_index3 = length3//2

    first_half_layer3 = layer3_list[:middle_index3]
    second_half_layer3 = layer3_list[middle_index3:]
    
    for i in range(len(first_half_layer1)):
        trained = model.layers[i].get_weights()
        model.layers[i + middle_index1].set_weights(trained)
    
    for i in range(len(first_half_layer1)):
        trained = model.layers[i].get_weights()
        model.layers[i + middle_index1].set_weights(trained)
    
    for i in range(len(first_half_layer3)):
        trained = model.layers[i].get_weights()
        model.layers[i + middle_index3].set_weights(trained)

我敢肯定有一种更有效/合适的方法来构建具有复杂数据集的暹罗网络，但是我不确定它是什么。有什么建议吗？

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）