Python Keras自定义图层-属性错误：'；张量'；对象没有属性'_keras#u历史'；

所以大画面，我试图使keras w2v自动编码器。我试着从这里学习

CustomVariationalLayer

类

我的班级是：

class自定义层（层）：
“”“用于处理查找wv输入的自定义keras层
来自https://github.com/fchollet/keras/blob/master/examples/variational_autoencoder.py
"""
定义初始（自我，**kwargs）：
self.is_占位符=True
超级（自定义层，自）。\uuuuuu初始层（**kwargs）
def ae_损失（自我、重建、emb_查找）：
损耗=K.sum（emb_查找-重构，轴=-1）
返回K.平均值（损失）
def呼叫（自我，输入）：
重建=输入[1]
emb_查找=输入[0]
损失=自身。ae_损失（emb_查找、重建）
自加损失（损失）
返回emb_查找

无论我是否返回

emb\u查找

或

重建

，都会发生此错误。我的层和官方示例之间的主要区别是我使用嵌入查找作为输入，这是

recon\u layer=density（outshape，activation=“tanh”，kernel\u regulazer=l2（参数l2的速率））（deconv\u输入）
s_侦察层=K.挤压（侦察层，2）

无论我是否返回

emb\u查找

或

重建

，都会发生此错误

---

完整的错误消息如下：

回溯（最近一次呼叫最后一次）：
文件“semi_sup_cnn_big_data_test.py”，第166行，在
main（）
文件“semi_sup_cnn_big_data_test.py”，第84行，主目录
args，运行时间，微观，宏观=基本cnn训练val测试（args）
文件“semi_sup_cnn_big_data_test.py”，第100行，在基本cnn_train_val_test中
clf，args=初始导出网络（args）
文件“/home/qqi/git/MPI\u CNN/models/auto\u encoder\u multilayer\u CNN.py”，第257行，在初始化导出网络中
模型=模型（模型输入，y）
文件“/usr/local/lib/python3.5/dist-packages/keras/legacy/interfaces.py”，第88行，在包装器中
返回函数（*args，**kwargs）
文件“/usr/local/lib/python3.5/dist-packages/keras/engine/topology.py”，第1705行，在__
构建图的图（x、完成的节点、进行中的节点）
文件“/usr/local/lib/python3.5/dist-packages/keras/engine/topology.py”，第1695行，在图的构建图中
层、节点索引、张量索引）
文件“/usr/local/lib/python3.5/dist-packages/keras/engine/topology.py”，第1665行，在图的构建图中
层，节点索引，张量索引=张量
AttributeError:“Tensor”对象没有属性“\u keras\u history”

根据要求，以下是完整的初始化导出网络功能：

    def init_export_network(in_args):
        import_dir = os.path.join('cv_data',
                                  in_args.data_name,
                                  in_args.label_name,
                                  in_args.this_fold)

        # set output dir as models/[model_name]/[data_name]/[label_file_name]/[this_fold]
        output_dir = os.path.join("initialized_models",
                                  in_args.model_name,
                                  in_args.data_name,
                                  in_args.label_name,
                                  in_args.this_fold)
        print("exporting to", output_dir)
        if not os.path.exists(output_dir):
            os.makedirs(output_dir)
        else:
            print(output_dir, "data dir identified but will be re-populated")
            shutil.rmtree(output_dir)
            os.makedirs(output_dir)
        "returns base cnn architecture and placeholder/untrained weights"
        # unpckl wv_matrix, class_names
        wv_matrix = unpckl(os.path.join(import_dir,'wv_matrix.pickle'))
        print("valid pre-processed data found in", import_dir)
        # define network layers ----------------------------------------------------
        input_shape = (in_args.seq_len,)
        output_shape = (in_args.seq_len,len(wv_matrix[0]),)
        emb_size = len(wv_matrix[0])
        model_input = Input(shape=input_shape)
        emb_lookup = Embedding(len(wv_matrix),
                               len(wv_matrix[0]),
                               embeddings_regularizer=l2(in_args.emb_l2_rate),
                               input_length=in_args.seq_len, name="embedding")(model_input)
        #emb_lookup = Embedding(len(wv_matrix), len(wv_matrix[0]), input_length=in_args.seq_len, name="embedding", )(model_input)
        if in_args.emb_dropout:
            emb_lookup = Dropout(in_args.emb_dropout)(emb_lookup)
        conv_blocks = []
        # conv blocks --------------------------------------------------------------
        print("emb_lookup shape!!!!",emb_lookup.shape)
        for ith_conv,sz in enumerate(in_args.filter_sizes):
            if ith_conv == 0:
                conv_input = emb_lookup
            else:
                conv_input = conv
            conv = Convolution1D(filters=in_args.feat_maps[ith_conv],
                                 kernel_size=sz,
                                 padding="valid",
                                 activation="relu",
                                 kernel_initializer = 'lecun_uniform',
                                 kernel_regularizer=l2(in_args.l2_rate),
                                 strides=1,
                                 name = "{}_conv".format(ith_conv))(conv_input)
            print("{}_conv".format(ith_conv), conv.shape)
        # deconv blocks with dimensions reverse of multilayer_cnn ------------------
        deconv_blocks = []
        deconv_filter_sizes = in_args.filter_sizes
        deconv_filter_sizes.reverse()

        #print("conv_shape!!!", conv.shape)
        conv_input = conv
        print("conv_upsampling_shape!!!", conv_input.shape)

        #unpool_shape = ((conv[1],-1,conv[2]))
        #conv_input = Reshape((1,conv_input[1],conv_input[2]))(conv_input)
        #print("conv_input_shape!!!", conv_input.shape)

        #conv_input = Reshape(unpool_shape),conv_input
        #conv_input = Reshape(unpool_shape)(conv_input)
        deconv_input=K.expand_dims(conv_input,2)

        print("conv_reshape_shape!!!", conv_input)
        for ith_conv,sz in enumerate(deconv_filter_sizes):
            print("{}_deconv input shape!!!".format(ith_conv), deconv_input)
            deconv = Conv2DTranspose(filters=in_args.feat_maps[ith_conv],
                                 kernel_size=(sz,1),
                                 #kernel_size=sz,
                                 padding="valid",
                                 activation="relu",
                                 kernel_initializer = 'lecun_uniform',
                                 kernel_regularizer=l2(in_args.l2_rate),
                                 strides=(1,1),
                                 name = "{}_deconv".format(ith_conv))(deconv_input)
            deconv_input = deconv
        print("{}_deconv input shape!!!".format(ith_conv), deconv_input)
        print("deconv_output shape",deconv)
        #z = Flatten()(conv)
        #deconv_out = Flatten(deconv)
        #outshape = (in_args.seq_len,len(wv_matrix[0]))
        outshape = len(wv_matrix[0])
        recon_layer = Dense(outshape, activation="tanh",kernel_regularizer=l2(in_args.l2_rate))(deconv_input)
        print("recon_layer shape",recon_layer)
        #s_recon_layer = K.squeeze(recon_layer,2)
        s_recon_layer = Lambda(lambda x: K.squeeze(x, 2))(recon_layer)
        print("squeezed recon_layer shape",s_recon_layer)
        #print("conv_reshape_shape!!!", conv_input.shape)(conv)
        # end define network layers ------------------------------------------------
        #model_output = Dense(outshape, activation="elu",kernel_regularizer=l2(in_args.l2_rate))(z)
        y = custom_ae_layer()([model_input,emb_lookup,s_recon_layer])
        model = Model(model_input, y)
        # finished network layers definition - compile network
        opt = optimizers.Adamax()

        model.compile(loss=None, optimizer='adamax')
        embedding_layer = model.get_layer("embedding")
        embedding_layer.set_weights([wv_matrix])
        # load wv_matrix into embedidng layer
        print("Initializing embedding layer with word2vec weights, shape", wv_matrix.shape)


        # save model architecture as json
        open(os.path.join(output_dir,"structure.json"),"w").write(model.to_json())
        # save initialized model weights as .hdf5fmacro
        model.save_weights(os.path.join(output_dir, "weights"+".hdf5"))
        print("multilayer network/initial weights successfully saved in", output_dir)
        print(in_args)
        #print(model.summary())
        return model,in_args

---

错误消息与此问题非常相似：

简言之，我认为您需要总结这一行：

s_recon_layer = K.squeeze(recon_layer,2)

（或任何其他后端函数调用）进入

Lambda

层

具体来说,

s_recon_layer = Lambda(lambda x: K.squeeze(x, 2))(recon_layer)

---

您的错误不是来自此层，而是来自

init\u export\u网络

函数。你能给我们提供它的定义吗？这里是init_export_网络代码，它实现了@Yu Yang的lambda补丁。该函数所做的只是初始化keras模型。还是有同样的问题。哇，是的，在我用keras lambda层包装了我所有的keras.backend函数之后，这完全起作用了。谢谢你的帮助！