如何在TensorFlow 1.4中不使用TF-slim组合多预训练模型？

当然可以不用TF-slim实现这种模型拼接的需求！在TensorFlow 1.4里，你有两种主要的思路：用Keras（TF 1.4已经集成了keras模块）快速搭建，或者用原生TensorFlow API手动构建，两种方式都能避开TF-slim。下面我给你详细讲具体实现步骤和代码示例：

Keras的模块化设计天生适合这种拼接不同模型部件的场景，而且TF 1.4里的tf.keras（或者单独的keras库）已经支持加载预训练的ResNet模型，你可以轻松截取前几层作为编码器，再自定义解码器拼接。

步骤1：加载预训练ResNet并截取编码器部分 #

首先导入预训练的ResNet，比如ResNet50，然后选择你需要的中间层输出作为编码器的输出。比如我们取到conv4_block6_out这一层（大概是ResNet的倒数第二个大模块输出）：

import tensorflow as tf
from tensorflow.keras.applications.resnet50 import ResNet50
from tensorflow.keras.layers import Input, Conv2DTranspose, BatchNormalization, Activation, Conv2D
from tensorflow.keras.models import Model

# 加载预训练ResNet50，不包含顶层的全连接层
resnet = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# 截取前几层作为编码器，这里以conv4_block6_out为例
encoder = Model(inputs=resnet.input, outputs=resnet.get_layer('conv4_block6_out').output)

# 可选：冻结编码器的预训练权重，避免训练时被更新
encoder.trainable = False

步骤2：自定义解码器部分 #

根据你的任务需求（比如语义分割、图像生成等）构建解码器，这里以简单的上采样+卷积为例：

# 解码器输入形状要和编码器输出形状匹配
decoder_input = Input(shape=encoder.output_shape[1:])

# 上采样+卷积块
x = Conv2DTranspose(256, (3, 3), strides=(2, 2), padding='same')(decoder_input)
x = BatchNormalization()(x)
x = Activation('relu')(x)

x = Conv2DTranspose(128, (3, 3), strides=(2, 2), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)

# 最终输出层，假设是语义分割任务，输出21类（VOC数据集）
output = Conv2D(21, (1, 1), activation='softmax')(x)

# 定义解码器模型
decoder = Model(inputs=decoder_input, outputs=output)

步骤3：拼接编码器和解码器，训练新模型 #

把两个部分组合起来，然后编译训练：

# 定义完整模型的输入
inputs = Input(shape=(224, 224, 3))
# 编码器编码
encoded = encoder(inputs)
# 解码器解码
decoded = decoder(encoded)
# 完整模型
model = Model(inputs=inputs, outputs=decoded)

# 编译模型
model.compile(optimizer=tf.keras.optimizers.Adam(lr=1e-4),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 开始训练（假设你已经有train_data和train_labels）
model.fit(train_data, train_labels, epochs=10, batch_size=32, validation_split=0.1)

如果你需要更精细地控制每一层的变量和操作，可以用原生TF API手动构建ResNet的前几层，再加载预训练权重，然后拼接解码器。

步骤1：手动构建ResNet编码器并加载预训练权重 #

首先定义ResNet的基础残差块，然后构建前几层，再通过tf.train.init_from_checkpoint加载预训练权重（需要提前下载ResNet的checkpoint文件）：

import tensorflow as tf

def resnet_block(x, filters, num_blocks, strides=(1,1), name='block'):
    """定义ResNet的残差块"""
    for i in range(num_blocks):
        shortcut = x
        if i == 0 or strides != (1,1):
            shortcut = tf.layers.conv2d(shortcut, filters, (1,1), strides=strides, padding='same', name=f'{name}_shortcut_{i}')
            shortcut = tf.layers.batch_normalization(shortcut, name=f'{name}_bn_shortcut_{i}')
        
        x = tf.layers.conv2d(x, filters, (3,3), strides=strides if i==0 else (1,1), padding='same', name=f'{name}_conv1_{i}')
        x = tf.layers.batch_normalization(x, name=f'{name}_bn1_{i}')
        x = tf.nn.relu(x)
        
        x = tf.layers.conv2d(x, filters, (3,3), padding='same', name=f'{name}_conv2_{i}')
        x = tf.layers.batch_normalization(x, name=f'{name}_bn2_{i}')
        
        x = tf.add(x, shortcut)
        x = tf.nn.relu(x)
    return x

def build_encoder(inputs):
    """构建ResNet前几层作为编码器"""
    # 第一层卷积
    x = tf.layers.conv2d(inputs, 64, (7,7), strides=(2,2), padding='same', name='conv1')
    x = tf.layers.batch_normalization(x, name='bn_conv1')
    x = tf.nn.relu(x)
    x = tf.layers.max_pooling2d(x, (3,3), strides=(2,2), padding='same', name='max_pool')
    
    # 残差块
    x = resnet_block(x, 64, 3, name='conv2')
    x = resnet_block(x, 128, 4, strides=(2,2), name='conv3')
    x = resnet_block(x, 256, 6, strides=(2,2), name='conv4')
    return x

# 定义输入占位符
inputs = tf.placeholder(tf.float32, shape=(None, 224, 224, 3))
encoder_output = build_encoder(inputs)

# 加载预训练权重（假设你的ResNet checkpoint路径是'./resnet50.ckpt'）
tf.train.init_from_checkpoint('./resnet50.ckpt', {
    '/conv1/': 'conv1/',
    '/bn_conv1/': 'bn_conv1/',
    '/conv2/': 'conv2/',
    '/conv3/': 'conv3/',
    '/conv4/': 'conv4/'
})

步骤2：构建解码器并拼接 #

然后定义解码器，和编码器连接：

def build_decoder(inputs):
    """构建解码器"""
    x = tf.layers.conv2d_transpose(inputs, 256, (3,3), strides=(2,2), padding='same')
    x = tf.layers.batch_normalization(x)
    x = tf.nn.relu(x)
    
    x = tf.layers.conv2d_transpose(x, 128, (3,3), strides=(2,2), padding='same')
    x = tf.layers.batch_normalization(x)
    x = tf.nn.relu(x)
    
    # 输出层
    outputs = tf.layers.conv2d(x, 21, (1,1), activation=tf.nn.softmax)
    return outputs

decoder_output = build_decoder(encoder_output)

步骤3：定义训练流程 #

最后设置损失函数、优化器，开启会话训练：

# 标签占位符
labels = tf.placeholder(tf.float32, shape=(None, 56, 56, 21))

# 损失函数
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels, logits=decoder_output))

# 优化器：可选只训练解码器的变量，避免更新编码器权重
decoder_vars = [var for var in tf.trainable_variables() if 'conv2d_transpose' in var.name or 'decoder' in var.name]
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4)
train_op = optimizer.minimize(loss, var_list=decoder_vars)

# 初始化变量并训练
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # 假设你有batch生成器
    for epoch in range(10):
        for batch_x, batch_y in train_generator:
            _, batch_loss = sess.run([train_op, loss], feed_dict={inputs: batch_x, labels: batch_y})
            print(f'Epoch {epoch+1}, Batch Loss: {batch_loss:.4f}')

• 权重匹配：不管用哪种方法，确保预训练权重的变量名和你定义的层的变量名一致，否则无法正确加载。如果变量名不匹配，可以手动映射（比如tf.train.init_from_checkpoint里的字典映射）。
• 冻结权重：如果想保留预训练编码器的特征提取能力，可以冻结其权重，只训练解码器部分，这样训练更快，也避免破坏预训练的有效特征。
• 输入尺寸：编码器的输入尺寸要和预训练模型的要求一致（比如ResNet默认224x224），如果需要适配不同尺寸，可以调整第一层卷积的参数或者添加resize操作。

内容的提问来源于stack exchange，提问作者santhanam srinivasan