网页

TensorFlow 2 实战指南

贡献

目前，该仓库包含对生成对抗网络（GAN）和分类任务有用的通用架构和函数。

我将继续添加其他领域的有用内容。

同时，我们欢迎您的拉取请求（Pull Requests）和问题反馈（Issues）。

如果您想实现某些功能，请在 Issue 中写下您的需求，我会去实现它。

如何使用

导入

• ops.py
  • 操作
  • from ops import *
• utils.py
  • 图像处理
  • from utils import *

网络模板

def network(x, is_training=True, reuse=False, scope="network"):
    with tf.variable_scope(scope, reuse=reuse):
        x = conv(...)
        
        ...
        
        return logit

使用 DatasetAPI（数据集 API）将数据插入网络

Image_Data_Class = ImageData(img_size, img_ch, augment_flag)

trainA_dataset = ['./dataset/cat/trainA/a.jpg', 
                  './dataset/cat/trainA/b.png', 
                  './dataset/cat/trainA/c.jpeg', 
                  ...]
trainA = tf.data.Dataset.from_tensor_slices(trainA_dataset)
trainA = trainA.map(Image_Data_Class.image_processing, num_parallel_calls=16)
trainA = trainA.shuffle(buffer_size=10000).prefetch(buffer_size=batch_size).batch(batch_size).repeat()

trainA_iterator = trainA.make_one_shot_iterator()
data_A = trainA_iterator.get_next()

logit = network(data_A)

• 更多信息请参见 此链接。

选项

• padding='SAME'
  • pad = ceil[ (kernel - stride) / 2 ]
• pad_type
  • 'zero' or 'reflect'
• sn
  • 是否使用 谱归一化（spectral_normalization）

注意

• 如果您不希望共享变量，请将所有作用域名称设置为不同。

---

权重

weight_init = tf.truncated_normal_initializer(mean=0.0, stddev=0.02)
weight_regularizer = tf.contrib.layers.l2_regularizer(0.0001)
weight_regularizer_fully = tf.contrib.layers.l2_regularizer(0.0001)

初始化

• Xavier : tf.contrib.layers.xavier_initializer()

  
    USE """tf.contrib.layers.variance_scaling_initializer()"""
    
    if uniform :
      factor = gain * gain
      mode = 'FAN_AVG'
    else :
      factor = (gain * gain) / 1.3
      mode = 'FAN_AVG'
  

• He : tf.contrib.layers.variance_scaling_initializer()

    if uniform :
      factor = gain * gain
      mode = 'FAN_IN'
    else :
      factor = (gain * gain) / 1.3
      mode = 'FAN_OUT'
  

• Normal : tf.random_normal_initializer(mean=0.0, stddev=0.02)
• Truncated_normal : tf.truncated_normal_initializer(mean=0.0, stddev=0.02)
• Orthogonal : tf.orthogonal_initializer(1.0) / # if relu = sqrt(2), the others = 1.0

正则化

• l2_decay : tf.contrib.layers.l2_regularizer(0.0001)
• orthogonal_regularizer : orthogonal_regularizer(0.0001) & orthogonal_regularizer_fully(0.0001)

卷积（Convolution）

基础卷积

x = conv(x, channels=64, kernel=3, stride=2, pad=1, pad_type='reflect', use_bias=True, sn=True, scope='conv')

部分卷积（NVIDIA 部分卷积）

x = partial_conv(x, channels=64, kernel=3, stride=2, use_bias=True, padding='SAME', sn=True, scope='partial_conv')

空洞卷积（Dilated Convolution）

x = dilate_conv(x, channels=64, kernel=3, rate=2, use_bias=True, padding='VALID', sn=True, scope='dilate_conv')

---

反卷积（Deconvolution）

基础反卷积

x = deconv(x, channels=64, kernel=3, stride=1, padding='SAME', use_bias=True, sn=True, scope='deconv')

---

全连接（Fully-connected）

x = fully_connected(x, units=64, use_bias=True, sn=True, scope='fully_connected')

---

像素洗牌（Pixel shuffle）

x = conv_pixel_shuffle_down(x, scale_factor=2, use_bias=True, sn=True, scope='pixel_shuffle_down')
x = conv_pixel_shuffle_up(x, scale_factor=2, use_bias=True, sn=True, scope='pixel_shuffle_up')

• down ===> [height, width] -> [height // scale_factor, width // scale_factor]
• up ===> [height, width] -> [height * scale_factor, width * scale_factor]

---

模块（Block）

残差块（Residual block）

x = resblock(x, channels=64, is_training=is_training, use_bias=True, sn=True, scope='residual_block')
x = resblock_down(x, channels=64, is_training=is_training, use_bias=True, sn=True, scope='residual_block_down')
x = resblock_up(x, channels=64, is_training=is_training, use_bias=True, sn=True, scope='residual_block_up')

• down ===> [height, width] -> [height // 2, width // 2]
• up ===> [height, width] -> [height * 2, width * 2]

密集块（Dense block）

x = denseblock(x, channels=64, n_db=6, is_training=is_training, use_bias=True, sn=True, scope='denseblock')

• n_db ===> 密集块的数量

残差密集块（Residual-dense block）

x = res_denseblock(x, channels=64, n_rdb=20, n_rdb_conv=6, is_training=is_training, use_bias=True, sn=True, scope='res_denseblock')

• n_rdb ===> RDB 的数量
• n_rdb_conv ===> 每个 RDB 的卷积层数

注意力模块

x = self_attention(x, use_bias=True, sn=True, scope='self_attention')
x = self_attention_with_pooling(x, use_bias=True, sn=True, scope='self_attention_version_2')

x = squeeze_excitation(x, ratio=16, use_bias=True, sn=True, scope='squeeze_excitation')

x = convolution_block_attention(x, ratio=16, use_bias=True, sn=True, scope='convolution_block_attention')

x = global_context_block(x, use_bias=True, sn=True, scope='gc_block')

x = srm_block(x, use_bias=False, is_training=is_training, scope='srm_block')

---

---

---

---

---

归一化

x = batch_norm(x, is_training=is_training, scope='batch_norm')
x = layer_norm(x, scope='layer_norm')
x = instance_norm(x, scope='instance_norm')
x = group_norm(x, groups=32, scope='group_norm')

x = pixel_norm(x)

x = batch_instance_norm(x, scope='batch_instance_norm')
x = layer_instance_norm(x, scope='layer_instance_norm')
x = switch_norm(x, scope='switch_norm')

x = condition_batch_norm(x, z, is_training=is_training, scope='condition_batch_norm'):

x = adaptive_instance_norm(x, gamma, beta)
x = adaptive_layer_instance_norm(x, gamma, beta, smoothing=True, scope='adaLIN')

• 查看 此链接 了解如何使用 condition_batch_norm
• 查看 此链接 了解如何使用 adaptive_instance_norm
• 查看 此链接 了解如何使用 adaptive_layer_instance_norm & layer_instance_norm

---

激活函数

x = relu(x)
x = lrelu(x, alpha=0.2)
x = tanh(x)
x = sigmoid(x)
x = swish(x)
x = elu(x)

---

池化与调整大小

x = nearest_up_sample(x, scale_factor=2)
x = bilinear_up_sample(x, scale_factor=2)
x = nearest_down_sample(x, scale_factor=2)
x = bilinear_down_sample(x, scale_factor=2)

x = max_pooling(x, pool_size=2)
x = avg_pooling(x, pool_size=2)

x = global_max_pooling(x)
x = global_avg_pooling(x)

x = flatten(x)
x = hw_flatten(x)

---

损失函数

分类损失

loss, accuracy = classification_loss(logit, label)

loss = dice_loss(n_classes=10, logit, label)

正则化损失

g_reg_loss = regularization_loss('generator')
d_reg_loss = regularization_loss('discriminator')

• 如果您想使用正则化器，则需要自行实现

像素损失

loss = L1_loss(x, y)
loss = L2_loss(x, y)
loss = huber_loss(x, y)
loss = histogram_loss(x, y)

loss = gram_style_loss(x, y)

loss = color_consistency_loss(x, y)

• histogram_loss 表示图像像素值颜色分布的差异。
• gram_style_loss 表示使用格拉姆矩阵的风格差异。
• color_consistency_loss 表示生成图像与输入图像之间的颜色差异。

GAN 损失

d_loss = discriminator_loss(Ra=True, loss_func='wgan-gp', real=real_logit, fake=fake_logit)
g_loss = generator_loss(Ra=True, loss_func='wgan-gp', real=real_logit, fake=fake_logit)

• Ra
  • 是否使用 相对性 GAN (relativistic gan)
• loss_func
  • gan
  • lsgan
  • hinge
  • wgan-gp
  • dragan
• 查看 此链接 了解如何使用 gradient_penalty

VDB 损失 (vdb loss)

d_bottleneck_loss = vdb_loss(real_mu, real_logvar, i_c) + vdb_loss(fake_mu, fake_logvar, i_c)

KL 散度 (kl-divergence) (z ~ N(0, 1))

loss = kl_loss(mean, logvar)

---

作者

Junho Kim

Tensorflow-Cookbook 快速上手指南

1. 环境准备

• 操作系统: Linux / Windows / macOS
• 编程语言: Python 3.x
• 核心依赖: TensorFlow (注意：代码中包含 tf.contrib 相关调用，请确保 TensorFlow 版本兼容)
• 硬件: 建议使用 NVIDIA GPU 以加速模型训练

2. 安装步骤

克隆项目仓库并配置环境：

git clone https://github.com/taki0112/Tensorflow2-Cookbook.git
cd Tensorflow2-Cookbook
# 确保已安装 TensorFlow
pip install tensorflow

3. 基本使用

导入模块

项目提供了通用的操作函数和图像处理工具，直接导入即可使用：

from ops import *
from utils import *

网络构建模板

定义网络结构时，使用 variable_scope 管理变量作用域：

def network(x, is_training=True, reuse=False, scope="network"):
    with tf.variable_scope(scope, reuse=reuse):
        x = conv(...)
        
        ...
        
        return logit

数据加载 (DatasetAPI)

使用 TensorFlow 原生 Dataset API 加载图像数据并进行预处理：

Image_Data_Class = ImageData(img_size, img_ch, augment_flag)

trainA_dataset = ['./dataset/cat/trainA/a.jpg', 
                  './dataset/cat/trainA/b.png', 
                  ...]
trainA = tf.data.Dataset.from_tensor_slices(trainA_dataset)
trainA = trainA.map(Image_Data_Class.image_processing, num_parallel_calls=16)
trainA = trainA.shuffle(buffer_size=10000).prefetch(buffer_size=batch_size).batch(batch_size).repeat()

trainA_iterator = trainA.make_one_shot_iterator()
data_A = trainA_iterator.get_next()

logit = network(data_A)

常用算子示例

项目中封装了丰富的神经网络层、归一化及损失函数，可直接调用：

卷积与反卷积

x = conv(x, channels=64, kernel=3, stride=2, pad=1, pad_type='reflect', use_bias=True, sn=True, scope='conv')
x = deconv(x, channels=64, kernel=3, stride=1, padding='SAME', use_bias=True, sn=True, scope='deconv')

网络模块 (Block)

# 残差块
x = resblock(x, channels=64, is_training=is_training, use_bias=True, sn=True, scope='residual_block')
# Dense Block
x = denseblock(x, channels=64, n_db=6, is_training=is_training, use_bias=True, sn=True, scope='denseblock')

归一化与激活

x = batch_norm(x, is_training=is_training, scope='batch_norm')
x = lrelu(x, alpha=0.2)

损失函数

# 分类损失
loss, accuracy = classification_loss(logit, label)
# GAN 损失
d_loss = discriminator_loss(Ra=True, loss_func='wgan-gp', real=real_logit, fake=fake_logit)