В настоящее время я пытаюсь загрузить веса сети, обученной тензорному потоку, в эквивалентную сеть в keras. Проблема заключается в том, что после считывания весов, когда я пытаюсь использовать команду .set_weights с каждым слоем, возникает эта ошибка, указанная выше. Я не уверен, почему мои слои относятся к типу класса Tensor, когда я использовал только слои keras.

Ниже вы можете увидеть код, я загрузил метафайл из tensorflow и веса из файлов контрольных точек. Как только сеть сделана в keras и я пытаюсь загрузить веса, она сообщает мне, что мои слои относятся к классу Tensor.

# Это для загрузки весов в массив model_vars. с tf.Session () как сессия:

# import graph
saver = tf.train.import_meta_graph(PATH_REL_META)

# load weights for graph
saver.restore(sess, PATH_REL_META[:-5])

# get all global variables (including model variables)
vars_global = tf.global_variables()

# get their name and value and put them into dictionary
sess.as_default()
model_vars = {}
for var in vars_global:
    try:
        
        model_vars[var.name] = var.eval()
                    
    except:
        print("For var={}, an exception occurred".format(var.name))

общая структура U-Net, используемая в этом коде:

inputs = Input((None, None, 10))

conv_A1c = Conv2D(filters=64, kernel_size=[3, 3], padding="same", activation='relu')(inputs)
bn_conv_A1c = BatchNormalization(axis=3)(conv_A1c)
dropout_A1c = Dropout(0.5)(bn_conv_A1c)

conv_A2c = Conv2D(filters=64, kernel_size=[3, 3], padding="same", activation='relu')(dropout_A1c)
bn_conv_A2c = BatchNormalization(axis=3)(conv_A2c)
dropout_A2c = Dropout(0.5)(bn_conv_A2c)

pool_A1c = MaxPooling2D(pool_size = [2, 2], strides = 2)(dropout_A2c)

conv_B1c = Conv2D(filters=128, kernel_size=[3, 3], padding="same", activation='relu')(pool_A1c)
bn_conv_B1c = BatchNormalization(axis=3)(conv_B1c)
dropout_B1c = Dropout(0.5)(bn_conv_B1c)

conv_B2c = Conv2D(filters=128, kernel_size=[3, 3], padding="same", activation='relu')(dropout_B1c)
bn_conv_B2c = BatchNormalization(axis=3)(conv_B2c)
dropout_B2c = Dropout(0.5)(bn_conv_B2c)

pool_B1c = MaxPooling2D(pool_size = [2, 2], strides = 2)(dropout_B2c)

conv_C1c = Conv2D(filters=256, kernel_size=[3, 3], padding="same", activation='relu')(pool_B1c)
bn_conv_C1c = BatchNormalization(axis=3)(conv_C1c)
dropout_C1c = Dropout(0.5)(bn_conv_C1c)

conv_C2c = Conv2D(filters=256, kernel_size=[3, 3], padding="same", activation='relu')(dropout_C1c)
bn_conv_C2c = BatchNormalization(axis=3)(conv_C2c)
dropout_C2c = Dropout(0.5)(bn_conv_C2c)

pool_C1c = MaxPooling2D(pool_size = [2, 2], strides = 2)(dropout_C2c)

conv_D1c = Conv2D(filters=512, kernel_size=[3, 3], padding="same", activation='relu')(pool_C1c)
bn_conv_D1c = BatchNormalization(axis=3)(conv_D1c)
dropout_D1c = Dropout(0.5)(bn_conv_D1c)

conv_D2c = Conv2D(filters=512, kernel_size=[3, 3], padding="same", activation='relu')(dropout_D1c)
bn_conv_D2c = BatchNormalization(axis=3)(conv_D2c)
dropout_D2c = Dropout(0.5)(bn_conv_D2c)

pool_D1c = MaxPooling2D(pool_size = [2, 2], strides = 2)(dropout_D2c)

conv_E1 = Conv2D(filters=1024, kernel_size=[3, 3], padding="same", activation='relu')(pool_D1c)
bn_conv_E1 = BatchNormalization(axis=3)(conv_E1)
dropout_E1 = Dropout(0.5)(bn_conv_E1)

conv_E2 = Conv2D(filters=1024, kernel_size=[3, 3], padding="same", activation='relu')(dropout_E1)
bn_conv_E2 = BatchNormalization(axis=3)(conv_E2)
dropout_E2 = Dropout(0.5)(bn_conv_E2)

upconv_E1 = Conv2DTranspose(filters = 512, kernel_size = [2, 2], strides = (2, 2), padding ='valid')(dropout_E2)

conv_D1e_ip = Concatenate(axis=3)([dropout_D2c,upconv_E1]) 
conv_D1e = Conv2D(filters=512, kernel_size=[3, 3], padding="same", activation='relu')(conv_D1e_ip)
bn_conv_D1e = BatchNormalization(axis=3)(conv_D1e)
dropout_D1e = Dropout(0.5)(bn_conv_D1e)

conv_D2e = Conv2D(filters=512, kernel_size=[3, 3], padding="same", activation='relu')(dropout_D1e)
bn_conv_D2e = BatchNormalization(axis=3)(conv_D2e)
dropout_D2e = Dropout(0.5)(bn_conv_D2e)

upconv_D2e = Conv2DTranspose(filters = 256, kernel_size = [2, 2], strides = (2, 2), padding ='valid')(dropout_D2e)

conv_C1e_ip = Concatenate(axis=3)([dropout_C2c,upconv_D2e]) 
conv_C1e = Conv2D(filters=256, kernel_size=[3, 3], padding="same", activation='relu')(conv_C1e_ip)
bn_conv_C1e = BatchNormalization(axis=3)(conv_C1e)
dropout_C1e = Dropout(0.5)(bn_conv_C1e)

conv_C2e = Conv2D(filters=256, kernel_size=[3, 3], padding="same", activation='relu')(dropout_C1e)
bn_conv_C2e = BatchNormalization(axis=3)(conv_C2e)
dropout_C2e = Dropout(0.5)(bn_conv_C2e)

upconv_C2e = Conv2DTranspose(filters = 128, kernel_size = [2, 2], strides = (2, 2), padding ='valid')(dropout_C2e)

conv_B1e_ip = Concatenate(axis=3)([dropout_B2c,upconv_C2e]) 
conv_B1e = Conv2D(filters=128, kernel_size=[3, 3], padding="same", activation='relu')(conv_B1e_ip)
bn_conv_B1e = BatchNormalization(axis=3)(conv_B1e)
dropout_B1e = Dropout(0.5)(bn_conv_B1e)

conv_B2e = Conv2D(filters=128, kernel_size=[3, 3], padding="same", activation='relu')(dropout_B1e)
bn_conv_B2e = BatchNormalization(axis=3)(conv_B2e)
dropout_B2e = Dropout(0.5)(bn_conv_B2e)

upconv_B2e = Conv2DTranspose(filters = 64, kernel_size = [2, 2], strides = (2, 2), padding ='valid')(dropout_B2e)

conv_A1e_ip = Concatenate(axis=3)([dropout_A2c,upconv_B2e]) 
conv_A1e = Conv2D(filters=64, kernel_size=[3, 3], padding="same", activation='relu')(conv_A1e_ip)
bn_conv_A1e = BatchNormalization(axis=3)(conv_A1e)
dropout_A1e = Dropout(0.5)(bn_conv_A1e)

conv_A2e = Conv2D(filters=64, kernel_size=[3, 3], padding="same", activation='relu')(dropout_A1e)
bn_conv_A2e = BatchNormalization(axis=3)(conv_A2e)
dropout_A2e = Dropout(0.5)(bn_conv_A2e)

conv_score = Conv2D(2, kernel_size=[1, 1], padding="same", activation='relu')(dropout_A2e)

model = Model(inputs = [inputs], outputs=[conv_score])
model.compile(optimizer='adam', loss='binary_crossentropy')

# Пример того, как я пытаюсь загрузить веса в слои

conv_A1c.set_weights([model_vars["conv2d/kernel:0"], model_vars["conv2d/bias:0"]])

bn_conv_A1c.set_weights([model_vars["batch_normalization/gamma:0"], model_vars["batch_normalization/beta:0"], model_vars["batch_normalization/moving_mean:0"], model_vars["batch_normalization/moving_variance:0"]])

The items in "model_vars" are all of type "<class 'numpy.ndarray'>", while the types for the layers are returning "<class 'tensorflow.python.framework.ops.Tensor'>"

Если вы, ребята, не могли бы объяснить, почему мои слои возвращают тензоры, а не слои типа keras, это было бы очень полезно.