https://www.modelscope.cn/models/iic/cv_ddcolor_image-colorization/summary#ddcolor-%E5%9B%BE%E5%83%8F%E4%B8%8A%E8%89%B2%E6%A8%A1%E5%9E%8B



本博客的代码：https://github.com/xxddccaa/DDColor-webui


## 下载模型


```
pip install modelscope


modelscope download --model 'iic/cv_ddcolor_image-colorization' --local_dir './DDColormodel'

```

## 推理
pytroch环境：

```
conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia -y

pip install addict modelscope datasets sympy==1.13.1 simplejson sortedcontainers timm
```

推理：
```python
import cv2
from modelscope.outputs import OutputKeys
from modelscope.pipelines import pipeline
from modelscope.utils.constant import Tasks

img_colorization = pipeline(Tasks.image_colorization, 
                       model='./DDColormodel')
img_path = 'https://modelscope.oss-cn-beijing.aliyuncs.com/test/images/audrey_hepburn.jpg'
result = img_colorization(img_path)
cv2.imwrite('result.png', result[OutputKeys.OUTPUT_IMG])
```

原图：

![audrey_hepburn.jpg](/static/img/c6024d7a0f0ab002e4133224881120af.audrey_hepburn.webp)


![result.png](/static/img/fda6112455c6e6e6ccc94914c2f612d8.result.webp)

## docker环境

```
docker run --gpus all --shm-size=32g -it --net host -v ./:/ddcolor kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-pix2pix bash

pip install addict modelscope datasets sympy==1.13.1 simplejson sortedcontainers timm opencv-python

apt-get update
apt-get install -y libgl1-mesa-glx libjpeg-dev libpng-dev libtiff-dev libopencv-dev

docker commit 731cbf160933 kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor

docker push kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor
```

## webui部署

```
cd /ssd/xiedong/image_color

docker run --gpus device=2 \
--shm-size=32g \
-it \
--net host \
-v ./ddcolor_app.py:/ddcolor/ddcolor_app.py \
-v ./DDColormodel:/DDColormodel/ \
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor bash

pip install gradio

python /ddcolor/ddcolor_app.py --model_path /DDColormodel --port 7861
```

用这个镜像也ok：


```
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor-webui
```

![image.png](/static/img/737c2afbb63c0a73eb8d72ca768769ce.image.webp)


## 指标测试

```bash
docker run --gpus device=2 \
--shm-size=32g \
-it \
--net host \
-v /ssd/xiedong/image_color:/ssd/xiedong/image_color \
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor-webui bash


pip install evaluation_requirements.txt
```

转换测试图片：
```bash
python ddcolor_inference.py \
--model_path /ssd/xiedong/image_color/DDColormodel/ \
--src_dir /ssd/xiedong/image_color/pytorch-CycleGAN-and-pix2pix/results/tongyong_l2ab_4/testA_35/images \
--dst_dir /ssd/xiedong/image_color/ddcolor_test
```

得到指标：

```
python evaluate_colorization.py --results_dir /ssd/xiedong/image_color/ddcolor_test --output_dir /ssd/xiedong/image_color/ddcolor_test_metric  --use_fid
```

| Metric          | Mean      | Std Dev   | Min      | Max       | Performance Assessment      |
|----------------|-----------|-----------|----------|-----------|-----------------------------|
| SSIM           | 0.887     | 0.078     | 0.435    | 0.983     | ✅ ​**​Excellent​**​ (Ideal >0.85) |
| PSNR (dB)      | 21.65     | 3.63      | 8.91     | 31.73     | ⚠️ ​**​Good​**​ (Typical 20-30dB) |
| MSE            | 663.11    | 860.43    | 43.67    | 8349.47   | ⚠️ ​**​Moderate​**​ (Lower better)|
| MAE            | 16.25     | 8.20      | 2.55     | 72.02     | ⚠️ ​**​Acceptable​**​            |
| Color Error    | 11.39     | 7.55      | 1.46     | 54.99     | ⚠️ ​**​Needs Improvement​**​     |
| LPIPS          | 0.166     | 0.072     | 0.025    | 0.472     | ✅ ​**​Good​**​ (Closer to 0 best)|
| FID            | 36.51     | -         | -        | -         | ⚠️ ​**​Fair​**​ (Ideal <30)      |


镜像：

```
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor-webui-metric
```

## webui快速启动


webui 7861
```bash
cd /your/path/to/image_color

docker run --gpus device=2 \
--shm-size=32g \
-it \
--net host \
-v ./ddcolor_app.py:/ddcolor/ddcolor_app.py \
-v ./DDColormodel:/DDColormodel/ \
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor-webui-metric bash


python /ddcolor/ddcolor_app.py --model_path /DDColormodel --port 7861
```

webui 7862
```bash
cd /your/path/to/image_color

docker run --gpus device=2 \
--shm-size=32g \
-it \
--net host \
-v ./ddcolor_app.py:/ddcolor/ddcolor_app.py \
-v ./DDColormodel:/DDColormodel/ \
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor-webui-metric bash


python /ddcolor/ddcolor_app.py --model_path /DDColormodel --port 7862
```

DDColor 效果实战教程

![image.png](/static/img/1b321dd10474f3d3e9bff1081cc767f5.image.webp)

随着深度学习的兴起，自动上色引起了很多关注，目标是在复杂的图像语义（如形状、纹理和上下文）中生成合适的颜色。一些早期方法尝试使用卷积神经网络（CNN）预测每个像素的颜色分布。不幸的是，这些基于CNN的方法由于缺乏对图像语义的全面理解，通常会产生不正确或不饱和的上色结果（图1中的CIC、InstColor和DeOldify）。为了更好地理解语义信息，一些方法借助生成对抗网络（GANs），利用它们丰富的表示作为上色的生成先验。然而，由于GAN先验的表示空间有限，它们无法处理具有复杂结构和语义的图像，导致不合适的上色结果或不愉快的伪影（图1中的Wu等和BigColor）。



随着自然语言处理（NLP）的巨大成功，Transformer已经扩展到许多计算机视觉任务。最近，一些工作将Transformer的非局部注意力机制引入图像上色。尽管取得了令人满意的结果，这些方法要么训练了几个独立的子网，导致累积误差（图1中的ColTran），要么在单尺度图像特征图上执行颜色注意操作，在处理复杂图像上下文时会导致明显的颜色晕染（图1中的CT2和ColorFormer）。此外，这些方法通常依赖于手工制作的数据集级别的经验分布先验，如[45]中的颜色掩码和[47]中的语义-颜色映射，这些都是繁琐且难以推广的。

在本文中，我们提出了一种新颖的上色方法，即DDColor，旨在实现语义合理且视觉生动的上色。我们的方法利用了一个编码器-解码器结构，其中编码器提取图像特征，双解码器恢复空间分辨率。与先前方法采用额外网络或手工计算的先验来优化颜色概率不同，我们的方法使用基于查询的Transformer作为颜色解码器，以端到端的方式学习语义感知的颜色查询。通过使用多尺度图像特征进行颜色查询学习，我们的方法显着减轻了颜色晕染，并显着改善了复杂上下文和小物体的着色（见图1）。此外，我们提出了一种新的色彩度损失，以提高生成结果的颜色丰富度。

我们的主要贡献总结如下：

- 我们提出了一种带有双解码器的端到端网络，用于自动图像上色，确保了生动且语义一致的结果。
- 我们的方法包括一种新颖的颜色解码器，从视觉特征中学习颜色查询而无需依赖手工制作的先验。此外，我们的像素解码器提供多尺度语义表示来指导颜色查询的优化，有效减少了颜色晕染效应。
- 综合实验表明，我们的方法在与基线相比实现了最先进的性能，并表现出良好的泛化能力。


![image.png](/static/img/f3379daf7f584a6f6a95ece7762f96db.image.webp)

## 3. 方法

### 3.1 概述

给定一个灰度输入图像 $x_L \in \mathbb{R}^{H \times W \times 1}$，我们的上色网络预测缺失的两个颜色通道 $\hat{y}_{AB} \in \mathbb{R}^{H \times W \times 2}$，其中 $L, AB$ 通道分别表示在 CIELAB 色彩空间中的明度和色度。网络采用编码器-解码器框架，如图2（a）所示。

我们利用一个backbone network作为编码器，从灰度图像中提取高级语义信息。backbone network旨在提取图像语义嵌入，这是上色视频化的关键。在本研究中，我们选择ConvNeXt [29]，这是用于图像分类的最前沿模型。以 $x_L$ 作为输入，backbone network 输出4个分辨率为 $\frac{H}{4} \times \frac{W}{4}$、$\frac{H}{8} \times \frac{W}{8}$、$\frac{H}{16} \times \frac{W}{16}$ 和 $\frac{H}{32} \times \frac{W}{32}$ 的中间特征图。前三个特征图通过快捷连接传递到pixel decoder，而最后的特征图作为pixel decoder的输入。至于backbone network的结构，有几种选择，比如 ResNet[17]、Swin-Transformer[28] 等，只要网络能够生成分层表示。

我们的框架的解码器部分由像素解码器和色彩解码器组成。像素解码器使用一系列堆叠的上采样层来恢复图像特征的空间分辨率。每个上采样层与编码器的相应阶段有快捷连接。色彩解码器利用多尺度图像特征逐渐优化基于语义的颜色查询。最后，由两个解码器生成的图像和颜色特征融合生成彩色输出。

在接下来的部分中，我们将详细描述这些模块以及用于上色视频化的损失函数。

### 3.2 双重解码器

#### 3.2.1 像素解码器

像素解码器由四个阶段组成，逐步扩大图像分辨率。每个阶段包括一个上采样层和一个快捷层。具体来说，不同于以前的方法使用反卷积 [34] 或插值 [30]，我们采用 PixelShuffle [37] 作为上采样层。该层将形状为 $(h_p, w_p, \frac{c_p}{2})$ 的低分辨率特征图重新排列为形状为 $(h, w, c)$ 的高分辨率特征图。快捷层使用卷积通过快捷连接整合来自编码器相应阶段的特征。

我们的方法通过逐步上采样过程捕获了完整的图像特征金字塔，这超出了某些基于transformer方法的能力 [24, 45]。这些多尺度特征进一步用作色彩解码器的输入，以指导颜色查询的优化。像素解码器的最终输出是图像嵌入 $E_i \in \mathbb{R}^{C \times H \times W}$，其空间分辨率与输入图像相同。

#### 3.2.2 色彩解码器

许多现有的上色视频化方法依赖于额外的先验来实现生动的结果。例如，一些方法 [46, 13] 利用来自预训练的GAN的生成先验，而其他方法使用经验分布统计 [45] 或训练集的预构建语义-颜色对 [47]。然而，这些方法需要大量的预构建工作，并且在各种场景中可能具有有限的适用性。为了减少对手动设计先验的依赖，我们提出了一种新颖的基于查询的色彩解码器。

**色彩解码器块**。色彩解码器由一堆块组成，每个块接收视觉特征和颜色查询作为输入。色彩解码器块（CDB）基于修改过的transformer解码器设计，如图2（b）所示。

为了基于视觉语义信息学习一组自适应颜色查询，我们创建可学习的色彩嵌入记忆，以存储颜色表示序列：
$$
Z_0 = [Z^1_0, Z^2_0, \dots, Z^K_0] \in \mathbb{R}^{K \times C}
$$
这些颜色嵌入在训练阶段初始化为零，并在第一个CDB中用作颜色查询。我们首先通过cross-attention层建立语义表示与颜色嵌入之间的关联：
$$
Z^{\prime}_l = \text{softmax}(Q_l K^T_l)V_l + Z_{l-1},
$$
其中 $l$ 是层索引，$Z_l \in \mathbb{R}^{K \times C}$ 是第 $l$ 层的 $K$ 维颜色嵌入。$Q_l = f_Q(Z_{l-1}) \in \mathbb{R}^{K \times C}$，$K_l, V_l \in \mathbb{R}^{H_l \times W_l \times C}$ 是图像特征，它们经过 $f_K(\cdot)$ 和 $f_V(\cdot)$ 变换，分别表示。$H_l$ 和 $W_l$ 是图像特征的空间分辨率，$f_Q$, $f_K$, 和 $f_V$ 是线性变换。

通过上述cross-attention操作，颜色嵌入表示由图像特征丰富。然后，我们利用标准transformer层来变换颜色嵌入，如下：
$$
Z^{\prime\prime}_l = \text{MSA}(\text{LN}(Z^{\prime}_l)) + Z^{\prime}_l,
$$
$$
Z^{\prime\prime\prime}_l = \text{MLP}(\text{LN}(Z^{\prime\prime}_l)) + Z^{\prime\prime}_l,
$$
$$
Z_l = \text{LN}(Z^{\prime\prime\prime}_l),
$$
其中 $\text{MSA}(\cdot)$ 表示multi-head self-attention [42]，$\text{MLP}(\cdot)$ 表示前馈网络，$\text{LN}(\cdot)$ 是层归一化 [3]。值得注意的是，在所提出的CDB中，cross-attention在self-attention之前进行。这是因为在应用第一个self-attention层之前，颜色查询是零初始值且语义上独立。

**扩展到多尺度**。以前基于transformer的上色视频化方法通常在单一尺度图像特征图上执行颜色关注，未能充分捕捉低级语义线索，在处理复杂背景时可能导致颜色渗出。相反，多尺度特征已在许多计算机视觉任务中广泛探索，如物体检测 [26] 和实例分割 [16]。这些特征也可以提升上色的性能（详见Sec 4.3中的对比实验）。

为了平衡计算复杂度和表示能力，我们选择了三种不同尺度的图像特征。具体来说，我们使用pixel decoder生成的中间视觉特征，在色彩解码器中使用1/16、1/8和1/4的下采样率。我们将每组的3个CDB分组，在每组中，多尺度特征按顺序输入到CDB中。我们以轮转方式重复此组M次。总共，色彩解码器由3M个CDB组成。我们可以将色彩解码器公式化如下：
$$
E_c = \text{ColorDecoder}(Z_0, F_1, F_2, F_3),
$$
其中 $F_1, F_2$ 和 $F_3$ 是三种不同尺度的视觉特征。

在色彩解码器中使用多尺度特征可以建模颜色查询与视觉嵌入之间的关系，使得颜色嵌入$E_c \in \mathbb{R}^{K \times C}$对语义信息更敏感，进一步实现更准确的语义边界识别和减少颜色渗出。

### 3.3 融合模块

融合模块是一个轻量级模块，通过结合像素解码器和色彩解码器的输出生成彩色结果。如图2所示，融合模块的输入为每像素图像嵌入 $E_i \in \mathbb{R}^{C \times H \times W}$，其中 $C$ 是嵌入维度，以及来自色彩解码器的语义感知颜色嵌入 $E_c \in \mathbb{R}^{K \times C}$，其中 $K$ 是颜色查询的数量。

融合模块将这两个嵌入聚合形成增强的特征 $\hat{F} \in \mathbb{R}^{K \times H \times W}$，使用一个简单的点积。然后应用一个 $1 \times 1$ 卷积层生成最终输出 $\hat{y}_{AB} \in \mathbb{R}^{2 \times H \times W}$，其表示AB颜色通道：
$$
\hat{F} = E_c \cdot E_i,
$$
$$
\hat{y}_{AB} = \text{Conv}(\hat{F}).
$$
最后，通过将输出 $\hat{y}_{AB}$ 与灰度输入 $x_L$ 拼接，获得上色结果 $\hat{y}$。

### 3.4 目标

在训练阶段，采用以下四种损失：

**像素损失**。像素损失 $L_{\text{pix}}$ 是上色图像 $\hat{y}$ 和真实图像 $y$ 之间的L1距离，提供像素级监督并鼓励生成类似于真实图像的输出。

**感知损失**。为了确保生成的图像 $\hat{y}$ 在语义上合理，我们使用感知损失 $L_{\text{per}}$ 来最小化它与真实图像 $y$ 之间的语义差异。这是通过使用预训练的 VGG16 [38] 从两个图像中提取特征来实现的。

**对抗损失**。添加一个 PatchGAN [23] 判别器来区分预测结果和真实图像，促使生成器生成无法区分的图像。令 $L_{\text{adv}}$ 表示对抗损失。

**色彩丰富度损失**。我们引入了一种新的色彩丰富度损失 $L_{\text{col}}$ ，其灵感来源于色彩丰富度分数 [15]。该损失鼓励模型生成更加丰富和视觉愉悦的图像。公式如下：
$$
L_{\text{col}} = 1 - [\sigma_{\text{rgyb}} (\hat{y}) + 0.3 \cdot \mu_{\text{rgyb}} (\hat{y})]/100,
$$
其中 $\sigma_{\text{rgyb}} (\cdot)$ 和 $\mu_{\text{rgyb}} (\cdot)$ 分别表示颜色平面中像素云的标准差和均值，如 [15] 中所述。

生成器的全目标公式如下：
$$
L_{\theta} = \lambda_{\text{pix}} L_{\text{pix}} + \lambda_{\text{per}} L_{\text{per}} + \lambda_{\text{adv}} L_{\text{adv}} + \lambda_{\text{col}} L_{\text{col}},
$$
其中 $\lambda_{\text{pix}}, \lambda_{\text{per}}, \lambda_{\text{adv}}$ 和 $\lambda_{\text{col}}$ 是不同项的平衡权重。

DDColor 通用场景黑白图片上色 论文点

# 基于pix2pix的图像彩色化技术实践与探索

## 一、项目背景与问题发现

在前期实验中，我尝试使用mmgen库进行通用图像和线稿的处理，但效果不尽如人意。这让我开始怀疑mmgen库在此类任务中的适用性。经过评估后，我决定转向另一个成熟的解决方案。



## 二、技术方案选型

### 2.1 选定仓库
最终选择的实现方案来自以下GitHub仓库：
```bash
git@github.com:junyanz/pytorch-CycleGAN-and-pix2pix.git
```

### 2.2 环境配置
采用Docker容器搭建训练环境，具体配置如下：
```bash
docker run --gpus all --shm-size=32g -it --net host \
-v ./pytorch-CycleGAN-and-pix2pix/:/pytorch-CycleGAN-and-pix2pix/ \
-v ./anime-sketch-colorization-pair/data:/data \
pytorch/pytorch:2.5.1-cuda12.1-cudnn9-devel bash

pip install -r requirements.txt
```

为方便后续使用，已将配置好的环境保存为镜像：
```bash
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-pix2pix
```

直接使用命令：
```bash
docker run --gpus all --shm-size=32g -it --net host \
-v ./pytorch-CycleGAN-and-pix2pix/:/pytorch-CycleGAN-and-pix2pix/ \
-v ./anime-sketch-colorization-pair/data:/data \
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-pix2pix bash
```

## 三、训练过程实录

### 3.1 基础训练配置
首先启动visdom可视化服务器：
```bash
python -m visdom.server -p 8097
```

采用以下两种训练方式之一：

**基础训练命令**：
```bash
python train.py --dataroot /data/ --name anime --gpu_ids 0,1,2,3 \
--model pix2pix --direction BtoA --batch_size 192 --lr_policy cosine \
--num_threads 32 --init_type xavier --norm instance --netG unet_256
```

**带visdom监控的训练**：
```bash
-display_server http://remote_ip --display_port 8097
```

通过浏览器访问8097端口可查看训练效果：

![训练监控界面](/static/img/b2c0b87baed3e8d6830533fff36432c2.image.webp)

### 3.2 初步训练结果
经过200轮训练后，效果仍有提升空间：

![200轮训练效果](/static/img/eecec56cf99c304d7d8785d7b802d02b.image.webp)

## 四、优化后的彩色化方案

### 4.1 技术原理突破
深入研究后发现更优的彩色化方法：输入单通道黑白图，输出为LAB色彩空间中的AB通道。

### 4.2 改进训练配置
```bash
cd /ssd/xiedong/image_color

docker run --gpus all --shm-size=32g -it --net host \
-v ./pytorch-CycleGAN-and-pix2pix/:/pytorch-CycleGAN-and-pix2pix/ \
-v ./unpaired_self_datasets/:/data \
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-pix2pix bash

nohup python -m visdom.server -p 8097 &

pip install -U scikit-image

cd /pytorch-CycleGAN-and-pix2pix/

python train.py \
  --dataroot /data/ \
  --name tongyong_l2ab_4 \
  --gpu_ids 0,1,2 \
  --model colorization \
  --direction AtoB \
  --batch_size 196 \
  --lr_policy cosine \
  --num_threads 32 \
  --init_type xavier \
  --norm instance \
  --netG unet_256 \
  --dataset_mode colorization \
  --input_nc 1 \
  --output_nc 2 \
  --phase trainA \
  --n_epochs 100
```

训练后可以绘制损失变化图：

python plot_loss_paper.py


![colorization_loss_curves.png](/static/img/40a8b5efdd26bed6115abd977c27b6ff.colorization_loss_curves.webp)



### 4.3 数据处理流程
• 系统自动将RGB图像转换为Lab色彩空间
• 分离L通道（亮度）作为输入
• 提取ab通道（色彩）作为输出目标
• 转换过程在ColorizationDataset类中自动完成

### 4.4 训练效果展示
**验证集输入（valA）**：
![灰度输入示例](/static/img/8aa1695fbb5229c8107b28c73e1f0940.zooh_002539.webp)

**验证集目标（valB）**：
![真实色彩示例](/static/img/70d1d6d87b64552cc33ce945c49f88da.zooh_002539.webp)

**生成效果对比**：
![色彩化效果对比](/static/img/e0ee6e095bbb41f82f83f6180527b291.image.webp)

训练完成的模型保存在：
```
pytorch-CycleGAN-and-pix2pix/checkpoints
```

## 五、技术参数详解

### 5.1 核心训练参数说明

#### 基础配置
| 参数 | 说明 | 示例值 |
|------|------|--------|
| `--dataroot` | 数据根目录 | `/data/` |
| `--name` | 实验名称 | `tongyong_l2ab_4` |
| `--gpu_ids` | 使用的GPU编号 | `0,1,2` |

#### 模型架构
| 参数 | 说明 | 可选值 |
|------|------|--------|
| `--model` | 模型类型 | `colorization` |
| `--netG` | 生成器架构 | `unet_256` |
| `--norm` | 归一化方法 | `instance` |

#### 训练策略
| 参数 | 说明 | 典型值 |
|------|------|--------|
| `--lr_policy` | 学习率策略 | `cosine` |
| `--batch_size` | 批次大小 | `196` |
| `--n_epochs` | 训练周期数 | `100` |

### 5.2 训练日志解析
典型训练日志示例：
```
(epoch: 39, iters: 115800, time: 0.007, data: 0.044) 
G_GAN: 2.019 G_L1: 8.129 D_real: 0.409 D_fake: 0.279
```

#### 指标说明
1. **G_GAN**：生成器对抗损失，反映生成器欺骗判别器的能力
2. **G_L1**：生成器L1损失，衡量色彩预测准确性
3. **D_real**：判别器对真实样本的识别能力
4. **D_fake**：判别器对生成样本的识别能力

#### 数学表达
• 生成器总损失：$\mathcal{L}_G = \mathcal{L}_{GAN} + \lambda\mathcal{L}_{L1}$
• 判别器总损失：$\mathcal{L}_D = \frac{1}{2}(\mathcal{L}_{real} + \mathcal{L}_{fake})$

## 六、技术原理深入

### 6.1 色彩空间理论
采用CIE Lab色彩空间，其中：
- • L通道：亮度信息（0-100）
- • a通道：绿(-128)到红(+127)色度
- • b通道：蓝(-128)到黄(+127)色度

### 6.2 网络架构
#### 生成器设计
U-Net结构包含：
1. 编码器路径：8级下采样
2. 解码器路径：对应上采样
3. 跳跃连接：保留细节信息

#### 判别器设计
采用PatchGAN架构：
- • 局部感受野：70×70像素
- • 输出特征图：$\frac{H}{n}×\frac{W}{n}$

### 6.3 训练优化
- • 数据增强：随机裁剪/翻转
- • 归一化处理：L通道→[-1,1]，ab通道→[-1,1]
- • 损失权重：$\lambda=100$

## 七、应用与验证

### 7.1 测试方法

要测试您训练好的模型（第35轮）使用您在"/data/testA"的测试数据，您应该在服务器上运行以下命令：

```
python test.py --dataroot /data/ --name tongyong_l2ab_4 --model colorization --direction AtoB --netG unet_256 --dataset_mode colorization --input_nc 1 --output_nc 2 --phase testA --epoch 35 --eval --num_test 500 --norm instance
```

如果想处理数据集中的所有图像，您需要将num_test设置为一个足够大的数字，确保它大于数据集中的图像总数。


结果会被保存到：results/tongyong_l2ab_4/testA_35/images/

此命令将：
1. 从第35轮加载您的模型检查点
2. 处理来自testA目录的图像
3. 生成着色结果
4. 将结果保存到HTML网页以便进行视觉检查

关键参数说明：
- `--dataroot /data/`：数据目录的路径
- `--name tongyong_l2ab_4`：您的实验名称（与训练名称匹配）
- `--model colorization`：使用着色模型
- `--netG unet_256`：使用与训练相同的生成器架构
- `--input_nc 1 --output_nc 2`：与您的训练设置相同（L到ab颜色空间）
- `--phase testA`：使用testA目录进行测试
- `--epoch 35`：从第35轮加载模型
- `--eval`：在评估模式下运行（禁用dropout）
- `--num_test 500`：测试多达500张图像（您可以调整这个数字）

#### 修改几句代码才行

报错了，需要改几句代码：

对于 PyTorch 2.5 版本，您需要修改服务器上的代码。服务器上的 `load_networks` 函数中有两个不兼容的参数：

1. `weights_only=True` - 这是较新版本的 PyTorch 引入的参数
2. `strict=False` - 这个参数应该传递给 `load_state_dict` 而不是 `torch.load`

因此，正确的修改方案是：

1. 在服务器上编辑 `models/base_model.py` 文件
2. 找到 `load_networks` 函数中的这一行：

```python
state_dict = torch.load(load_path, weights_only=True, map_location=self.device, strict=False)
```

3. 将其修改为：

```python
state_dict = torch.load(load_path, map_location=str(self.device))
```

4. 如果您需要保留 `strict=False` 的功能，则需要修改后面的 `load_state_dict` 调用：

```python
net.load_state_dict(state_dict, strict=False)
```

这样修改后应该可以与 PyTorch 2.5 兼容，同时保持原有功能。

5. 其他介绍：


weights_only=True 参数

- 功能：这是PyTorch较新版本(2.0+)引入的参数，用于只加载模型的权重部分，而不加载优化器状态、学习率调度器等其他存储在模型文件中的信息。
- 作用：当您只需要模型权重而不需要恢复训练状态时，此参数可以节省内存并加快加载速度。

map_location=self.device vs map_location=str(self.device)

- 旧版本PyTorch(0.4之前)需要字符串形式，而较新版本既可以接受torch.device对象也可以接受字符串。

strict=False 参数
- 功能：strict参数控制在加载模型时如何处理键不匹配的情况。
- 关键点：在您修改前的代码中，strict=False被错误地放在了torch.load()调用中，而它应该属于后续的load_state_dict()调用。

#### testA目录

testA目录 里应该是彩色的图片，ColorizationDataset 类里会进行这样的处理：

```python
def __getitem__(self, index):
    path = self.AB_paths[index]
    im = Image.open(path).convert('RGB')  # <-- 打开图像并转换为RGB
    im = self.transform(im)
    im = np.array(im)
    lab = color.rgb2lab(im).astype(np.float32)  # <-- 将RGB转换为Lab
    lab_t = transforms.ToTensor()(lab)
    A = lab_t[[0], ...] / 50.0 - 1.0  # <-- 提取L通道（灰度）
    B = lab_t[[1, 2], ...] / 110.0  # <-- 提取ab通道（色彩）
    return {'A': A, 'B': B, 'A_paths': path, 'B_paths': path}
```

### 7.2 效果评估
通过定期验证集测试监控训练进展，关键步骤：
1. 反归一化处理
2. Lab→RGB转换
3. 生成效果可视化对比


## 八、评估指标


- SSIM (结构相似性): 这是一个广泛使用的指标，衡量两幅图像在结构上的相似度。值范围从0到1，越高越好。SSIM>0.85通常被认为是高质量的结果。
- PSNR (峰值信噪比): 这个指标衡量的是图像重建的质量，单位为dB。通常，PSNR>30dB被认为是高质量的。在着色任务中，25-35dB通常是好的结果。
- 色彩误差: 这是我专门为着色任务添加的指标，它衡量Lab色彩空间中ab通道的平均绝对误差。这个指标直接评估了着色的准确性，而不仅仅是整体图像相似度。
- LPIPS (感知相似度): 这是一个基于深度学习的感知相似度度量，更符合人类对图像质量的判断。值越低表示感知上越相似。
- FID (Fréchet Inception Distance): 这个指标衡量生成图像的分布与真实图像分布之间的距离。它使用Inception网络提取特征，并计算特征空间中的分布差异。FID值越低越好，通常<20被认为是高质量的生成结果。

在第七章节后，我们获取到了结果图：./results/tongyong_l2ab_4/testA_35/images/

每三个图是一组，比如：
```bash
-rw-r--r-- 1 root root 134573 Apr 10 02:17 002_trafficScene_youxian1_000020_fake_B_rgb.png
-rw-r--r-- 1 root root 132559 Apr 10 02:17 002_trafficScene_youxian1_000020_real_B_rgb.png
-rw-r--r-- 1 root root  86333 Apr 10 02:17 002_trafficScene_youxian1_000020_real_A.png
```

real_A 是黑白图，real_B_rgb 是真实的RGB图，fake_B_rgb 是模型根据real_A进行上色得到的图。

指标就是为了评估fake_B_rgb是否能接近real_B_rgb。

为了得到评估指标，需要给容器里安装点环境：


```
apt update && apt install -y libgl1

pip install -r evaluation_requirements.txt # 在我自己的github项目里
```
运行评估脚本：


```bash
# 基本版本
python evaluate_basic.py --results_dir ./results/tongyong_l2ab_4/testA_35/images --output_dir ./evaluation_basic_results

# 完整版本
python evaluate_colorization.py --results_dir ./results/tongyong_l2ab_4/testA_35/images --output_dir ./evaluation_results

# 完整版本 带FID指标
python evaluate_colorization.py --results_dir ./results/tongyong_l2ab_4/testA_35/images --output_dir ./evaluation_results --use_fid
```

得到：

| Metric            | Mean      | Std       | Min       | Max        |
|-------------------|-----------|-----------|-----------|------------|
| SSIM             | 0.892293  | 0.087055  | 0.496115  | 0.991259   |
| PSNR             | 22.315565 | 4.723317  | 9.698197  | 36.125977  |
| MSE              | 682.852914| 889.681447| 15.866557 | 6970.447413|
| MAE              | 15.264377 | 9.815629  | 1.971761  | 66.205879  |
| Color Error      | 11.004399 | 7.5067    | 1.517296  | 51.797058  |
| LPIPS            | 0.193544  | 0.092814  | 0.009559  | 0.553977   |
| FID              | 49.714922 | -         | -         | -          |

模型表现不错：
- SSIM平均值: 0.892 - 非常好，接近0.9意味着生成的图像与真实图像结构相似度很高
- PSNR平均值: 22.32 dB - 对于着色任务来说是合理的值
- Color Error平均值: 11.00 - 这是在Lab色彩空间中ab通道的误差
- LPIPS平均值: 0.194 - 表示感知相似度较好（越低越好）
- FID值是49.714922，这属于中等性能水平：
FID值越低越好，表示生成分布与真实分布越接近
通常FID < 20被视为非常好
FID在20-50之间被视为可接受
FID > 100通常表示生成质量较差


## 九、WebUI部署

启动web服务：

```
python colorization_app.py
```

网页前端使用：

![image.png](/static/img/7dc7df3b35d0acf2164d3e6b7384b789.image.webp)

## 十、其他理论

### U-Net生成器

我们的彩色化模型采用U-Net[4]作为生成器的骨干网络。U-Net是一种编码器-解码器结构，增加了跳跃连接(skip connection)以保留细节信息。对于彩色化任务，我们采用unet_256变体，具有8个下采样层。

U-Net生成器的结构可以表示为：

$$G: \mathbb{R}^{H \times W \times 1} \rightarrow \mathbb{R}^{H \times W \times 2}$$

具体而言，它由以下部分组成：
1. **编码器路径**：通过一系列卷积层和下采样操作将输入从 $H \times W \times 1$ 逐渐降维到 $\frac{H}{256} \times \frac{W}{256} \times 512$
2. **解码器路径**：通过上采样和反卷积操作将特征图从 $\frac{H}{256} \times \frac{W}{256} \times 512$ 恢复到 $H \times W \times 2$
3. **跳跃连接**：在对应的编码器和解码器层之间建立直接连接，帮助网络保留边缘和细节信息

具体的数学表示为：

$$h_i = \text{Down}(h_{i-1}), i \in [1, 8]$$
$$h'_i = \text{Up}(h'_{i+1}, h_i), i \in [7, 0]$$

其中 $\text{Down}(\cdot)$ 表示下采样操作，$\text{Up}(\cdot, \cdot)$ 表示上采样与特征连接操作，$h_0$ 是输入的L通道，$h'_0$ 是输出的ab通道预测。

###  PatchGAN判别器

我们使用PatchGAN作为判别器，它仅关注局部图像块(patch)的真实性而非整体图像，这有助于保持色彩的局部一致性和纹理细节。PatchGAN判别器可以表示为：

$$D: \mathbb{R}^{H \times W \times 3} \rightarrow \mathbb{R}^{\frac{H}{n} \times \frac{W}{n} \times 1}$$

其中输入是L通道与ab通道（真实或生成）的拼接，输出是一个 $\frac{H}{n} \times \frac{W}{n}$ 的评分图，每个位置对应一个感受野为 $70 \times 70$ 的图像区域。判别器包含5个卷积层，中间使用实例归一化(Instance Normalization)和LeakyReLU激活函数。

### 损失函数

在训练过程中，网络同时优化两个损失函数：
1. **条件GAN损失**：$\mathcal{L}_{cGAN}(G, D)$，促使生成的色彩在局部区域看起来逼真
2. **L1距离损失**：$\mathcal{L}_{L1}(G)$，确保生成的色彩与真实色彩的整体一致性

对于判别器 $D$，我们使用标准的GAN判别器损失：

$$\mathcal{L}_D = \frac{1}{2}\mathbb{E}_{x,y}[(D(x, y) - 1)^2] + \frac{1}{2}\mathbb{E}_{x}[D(x, G(x))^2]$$

对于生成器 $G$，我们结合GAN损失和L1损失：

$$\mathcal{L}_G = \mathbb{E}_{x}[(D(x, G(x)) - 1)^2] + \lambda \mathbb{E}_{x,y}[\|y - G(x)\|_1]$$

其中，我们设置 $\lambda = 100$ 来强调色彩的准确性。


## 十一、镜像，代码，权重

镜像环境安装了一些别的，新的镜像名称为：`kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-pix2pix-webui`


代码仓库：https://github.com/xxddccaa/pytorch-CycleGAN-and-pix2pix-color#


webui启动：

```bash
cd /ssd/xiedong/image_color

docker run --gpus device=2 --shm-size=32g -it --net host \
-v ./pytorch-CycleGAN-and-pix2pix/:/pytorch-CycleGAN-and-pix2pix/ \
-v ./unpaired_self_datasets/:/data \
kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-pix2pix-webui bash

cd /pytorch-CycleGAN-and-pix2pix

python colorization_app.py
```

pix2pix pytorch 图片上色，模型训练实战，Docker【3】

通用场景上色任务太难，pix2pix效果不佳：

https://www.dong-blog.fun/post/1924


通用场景照片的要求太大了：要场景、要渐变色、要理解场景里的事物，比如你总不能给树叶上一个红色，是需要一定语义理解能力的。

线稿是一种需要块状涂色的任务，相对就简单得多。



这是线稿任务：

![image.png](/static/img/6b020899caa348a019213124922eb38d.image.webp)

## 数据集
https://www.kaggle.com/datasets/ktaebum/anime-sketch-colorization-pair

下载这个数据集：

```
import kagglehub

# Download latest version
path = kagglehub.dataset_download("ktaebum/anime-sketch-colorization-pair")

print("Path to dataset files:", path)
```

## 训练

```
docker run --gpus all --shm-size=16g -it --net host \
-v /ssd/xiedong/image_color/anime-sketch-colorization-pair/data:/mmgen/data \
-v ./pretrain:/mmgen/pretain \
-v ./work_dirs:/mmgen/work_dirs \
kevinchina/deeplearning:mmgenerationv1-addtb bash

vim configs/pix2pix/pix2pix_vanilla_unet_bn_facades_b1x1_80k.py

export OMP_NUM_THREADS=8
export MKL_NUM_THREADS=8
export CONFIG_FILE=configs/pix2pix/pix2pix_vanilla_unet_bn_facades_b1x1_80k.py
export GPUS_NUMBER=4
export WORK_DIR=./work_dirs/pix2pix_xiangao
bash tools/dist_train.sh ${CONFIG_FILE} ${GPUS_NUMBER} \
    --work-dir ${WORK_DIR} 


# 宿主机可以看日志
tensorboard --logdir="tf_logs/" --bind_all
```

配置写：

```
_base_ = [
    '../_base_/models/pix2pix/pix2pix_vanilla_unet_bn.py',
    '../_base_/datasets/paired_imgs_256x256_crop.py',
    '../_base_/default_runtime.py'
]
source_domain = 'mask'
target_domain = 'photo'
# model settings
model = dict(
    default_domain=target_domain,
    reachable_domains=[target_domain],
    related_domains=[target_domain, source_domain],
    gen_auxiliary_loss=dict(
        data_info=dict(
            pred=f'fake_{target_domain}', target=f'real_{target_domain}')))

# dataset settings
domain_a = target_domain
domain_b = source_domain
img_norm_cfg = dict(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
train_pipeline = [
    dict(
        type='LoadPairedImageFromFile',
        io_backend='disk',
        key='pair',
        domain_a=domain_a,
        domain_b=domain_b,
        flag='color'),
    dict(
        type='Resize',
        keys=[f'img_{domain_a}', f'img_{domain_b}'],
        scale=(286, 286),
        interpolation='bicubic'),
    dict(
        type='FixedCrop',
        keys=[f'img_{domain_a}', f'img_{domain_b}'],
        crop_size=(256, 256)),
    dict(
        type='Flip',
        keys=[f'img_{domain_a}', f'img_{domain_b}'],
        direction='horizontal'),
    dict(type='RescaleToZeroOne', keys=[f'img_{domain_a}', f'img_{domain_b}']),
    dict(
        type='Normalize',
        keys=[f'img_{domain_a}', f'img_{domain_b}'],
        to_rgb=False,
        **img_norm_cfg),
    dict(type='ImageToTensor', keys=[f'img_{domain_a}', f'img_{domain_b}']),
    dict(
        type='Collect',
        keys=[f'img_{domain_a}', f'img_{domain_b}'],
        meta_keys=[f'img_{domain_a}_path', f'img_{domain_b}_path'])
]
test_pipeline = [
    dict(
        type='LoadPairedImageFromFile',
        io_backend='disk',
        key='pair',
        domain_a=domain_a,
        domain_b=domain_b,
        flag='color'),
    dict(
        type='Resize',
        keys=[f'img_{domain_a}', f'img_{domain_b}'],
        scale=(256, 256),
        interpolation='bicubic'),
    dict(type='RescaleToZeroOne', keys=[f'img_{domain_a}', f'img_{domain_b}']),
    dict(
        type='Normalize',
        keys=[f'img_{domain_a}', f'img_{domain_b}'],
        to_rgb=False,
        **img_norm_cfg),
    dict(type='ImageToTensor', keys=[f'img_{domain_a}', f'img_{domain_b}']),
    dict(
        type='Collect',
        keys=[f'img_{domain_a}', f'img_{domain_b}'],
        meta_keys=[f'img_{domain_a}_path', f'img_{domain_b}_path'])
]

dataroot = 'data'
data = dict(
    train=dict(dataroot=dataroot, pipeline=train_pipeline),
    val=dict(dataroot=dataroot, pipeline=test_pipeline),
    test=dict(dataroot=dataroot, pipeline=test_pipeline))

# optimizer
optimizer = dict(
    generators=dict(type='Adam', lr=2e-4, betas=(0.5, 0.999)),
    discriminators=dict(type='Adam', lr=2e-4, betas=(0.5, 0.999)))

# learning policy
lr_config = None

# checkpoint saving
checkpoint_config = dict(interval=50000, save_optimizer=True, by_epoch=False)
custom_hooks = [
    dict(
        type='MMGenVisualizationHook',
        output_dir='training_samples',
        res_name_list=[f'fake_{target_domain}'],
        interval=5000)
]
runner = None
use_ddp_wrapper = True

# runtime settings
total_iters = 1000000
workflow = [('train', 1)]
exp_name = 'pix2pix_xian_gao'
work_dir = f'./work_dirs/{exp_name}'
num_images = 5000
metrics = dict(
    FID=dict(type='FID', num_images=num_images, image_shape=(3, 256, 256)),
    IS=dict(
        type='IS',
        num_images=num_images,
        image_shape=(3, 256, 256),
        inception_args=dict(type='pytorch')))

# evaluation = dict(
#     type='TranslationEvalHook',
#     target_domain=domain_b,
#     interval=10000,
#     metrics=[
#         dict(type='FID', num_images=num_images, bgr2rgb=True),
#         dict(
#             type='IS',
#             num_images=num_images,
#             inception_args=dict(type='pytorch'))
#     ],
#     best_metric=['fid', 'is'])

# 日志配置信息
log_config = dict(
    interval=10,  # 打印日志的间隔， 单位 iters
    hooks=[
        dict(type='TextLoggerHook'),  # 用于记录训练过程的文本记录器(logger)
        dict(type='TensorboardLoggerHook')  # 同样支持 Tensorboard 日志
    ])
# yapf:enable
log_level = 'INFO'  # 日志的输出级别
```

这个任务显然是简单一些，loss很快就降低了：

![image.png](/static/img/89781b5b104b8138d2a48e2bf581d4f4.image.webp)

## 推理


```
python demo/translation_demo.py \
    'configs/pix2pix/pix2pix_vanilla_unet_bn_facades_b1x1_80k.py' \
    /mmgen/work_dirs/pix2pix_xiangao/ckpt/pix2pix_xiangao/latest.pth \
    'data/test/984079.png' \
    --save-path work_dirs/demo.png
```


![image.png](/static/img/619db50bf30d40f6a3fb0d0626375ec6.image.webp)

效果还是不好，换个框架再试试，这个mmgeneration 是不是有毒：

![image.png](/static/img/7190a3af745088a22f10b3af11cbc125.image.webp)

pix2pix mmgeneration 线稿上色，模型训练实战，Docker【2】

https://arxiv.org/abs/1703.10593

图像到图像的转换是一类视觉和图形问题，其目标是通过使用一组对齐的图像对训练集，学习输入图像与输出图像之间的映射关系。然而，对于许多任务来说，成对的训练数据并不可用。我们提出了一种方法，在没有对齐样本的情况下，学习将源域X的图像转换到目标域Y。我们在几个任务上展示了定性结果，包括风格迁移、对象变形、季节转换、照片增强等。如下图：



![image.png](/static/img/9810f8ecf66b033777f45ba55bfefe55.image.webp)

左图是成对的数据集，有图是不成对的数据集：

![image.png](/static/img/afc03d32fa4f4f1b2ace92163d46b6ed.image.webp)

循环一致性 利用传递性来正则化结构化数据的思想由来已久。在视觉跟踪中，加强简单的前向-后向一致性已经是一种标准技巧 [24, 48]。在语言领域，通过“反向翻译和调解”来验证和改进翻译是一种人类译者 [3]（包括幽默地由马克·吐温 [51]）以及机器 [17] 使用的技术。更近期的，高阶循环一致性在运动结构 [61]、3D 形状匹配 [21]、共同分割 [55]、密集语义对齐 [65, 64] 和深度估计 [14] 中被使用。Zhou 等 [64] 和 Godard 等 [14] 的工作与我们的工作最为相似，因为他们使用循环一致性损失作为监督 CNN 训练的一种方式。在本研究中，我们引入了类似的损失来使 G 和 F 彼此一致。与我们的工作同时进行的，Yi 等 [59] 独立地使用类似的目标用于无配对图像到图像的转换，受机器翻译中的双重学习 [17] 启发。

cyclegan 里面有两个生成模型和对应的判别模型，如下图：

![image.png](/static/img/339f676025b6f069fa8b914ed8a12294.image.webp)

## 对抗损失

跟一般的GAN类似，对抗损失表示为：
$$
L_{GAN}(G, D_Y, X, Y) = \mathbb{E}_{y∼p_{data}(y)}[\log D_Y(y)] + \mathbb{E}_{x∼p_{data}(x)}[\log(1 - D_Y(G(x)))]
$$

G的目标是最小化生成差距：
$$
\min_G \max_{D_Y} L_{GAN}(G, D_Y, X, Y)
$$

F的目标类似：
$$
\min_F \max_{D_X} L_{GAN}(F, D_X, Y, X)
$$

## 循环一致性损失

从理论上讲，对抗训练可以学习到生成器G和F，它们生成的输出分别与目标域Y和X完全一致（严格来说，这需要G和F为随机函数）[15]。然而，具有足够容量的网络可以将同一组输入图像映射到目标域中的任何随机排列的图像，其中任何一种学习到的映射都可能产生与目标分布相匹配的输出分布。因此，仅凭对抗损失无法保证学习到的函数能够将每个单独的输入$x_i$映射到所期望的输出$y_i$。

为了进一步缩小可能的映射函数的空间，我们认为学习到的映射函数应该是循环一致的：如图3(b)所示，对于来自域X的每一幅图像x，图像翻译循环应该能将x带回到原始图像，即$x \rightarrow G(x) \rightarrow F(G(x)) \approx x$。我们称之为前向循环一致性。同样，如图3(c)所示，对于来自域Y的每幅图像y，G和F还应满足反向循环一致性：$y \rightarrow F(y) \rightarrow G(F(y)) \approx y$。我们通过循环一致性损失鼓励这种行为：

$$
L_{cyc}(G,F) = \mathbb{E}_{x\sim p_{data}(x)} [\|F(G(x)) - x\|_1]
+ \mathbb{E}_{y\sim p_{data}(y)} [\|G(F(y)) - y\|_1]
$$

在初步实验中，我们还尝试用F(G(x))和x之间的对抗性损失，以及G(F(y))和y之间的对抗性损失替换该损失中的L1范数，但没有观察到性能的改善。


## 完整目标
我们的完整目标是：
$$
L(G, F, D_X, D_Y) = L_{GAN}(G, D_Y, X, Y) + L_{GAN}(F, D_X, Y, X) + \lambda L_{cyc}(G, F)
$$

其中 $ \lambda $ 控制两个目标相对的重要性。我们旨在解决：

$$ G^*, F^* = \arg \min_{G, F} \max_{D_X, D_Y} L(G, F, D_X, D_Y). $$

请注意，我们的模型可以看作是训练两个“自动编码器”[20]：

我们学习一个自动编码器 $ F \circ G : X \rightarrow X $ 与另一个 $ G \circ F : Y \rightarrow Y $ 共同训练。

然而，这些自动编码器各自具有特殊的内部结构：它们通过将图像转化到另一个域的中间表示来对图像进行自映射。这样的设置也可以看作是“对抗自动编码器”[34] 的一种特殊情况，它们使用对抗损失来训练自动编码器的瓶颈层以匹配任意目标分布。在我们的情况中，$ X \rightarrow X $ 自动编码器的目标分布是域 $ Y $ 的分布。

在第5.1.4节中，我们对我们的方法与完整目标的消融版本进行了比较，包括仅使用对抗损失 $ L_{GAN} $ 和仅使用循环一致性损失 $ L_{cyc} $，并通过实验表明这两个目标在获得高质量结果方面起到关键作用。我们还评估了仅在一个方向上使用循环损失的方法，并证明单个循环不足以正则化该欠约束问题的训练。

## 实现

网络架构 我们采用了Johnson等人[23]的生成网络架构，他们在神经风格迁移和超分辨率方面展示了令人印象深刻的结果。这个网络包含三个卷积层、多个残差块[18]、两个带有步幅 $ \frac{1}{2} $ 的分数卷积层以及一个将特征映射到RGB的卷积层。对于128×128的图像，我们使用6个块，而对于256×256及更高分辨率的训练图像，我们使用9个块。类似于Johnson等人[23]，我们使用实例归一化[53]。对于判别器网络，我们使用70×70的PatchGANs[22, 30, 29]，它旨在分类70×70重叠图像块是真实的还是伪造的。这样的块级判别器架构比全图像判别器参数更少，并且可以在任意尺寸的图像上以完全卷积方式工作[22]。

训练细节 我们应用了最近一些研究中的两种技术来稳定我们的模型训练过程。首先，对于 $ L_{GAN} $（公式1），我们用最小二乘损失[35]替换了负对数似然目标。这个损失在训练过程中更稳定，并生成更高质量的结果。特别是，对于GAN损失 $ L_{GAN}(G, D, X, Y) $，我们训练G以最小化 $ E_{x \sim p_{data}(x)} [(D(G(x)) - 1)^2] $ 并训练D以最小化 $ E_{y \sim p_{data}(y)} [(D(y) - 1)^2] + E_{x \sim p_{data}(x)} [D(G(x))^2] $。

其次，为了减少模型的振荡[15]，我们遵循Shrivastava等人的策略[46]，使用生成图像的历史来更新判别器，而不是使用最新生成器产生的图像。我们保持一个图像缓冲区，存储先前创建的50张图像。

对于所有实验，我们在公式3中设置 $ \lambda = 10 $。我们使用Adam求解器[26]，批量大小为1。所有网络都是从头开始训练的，学习率为0.0002。我们在前100个epoch中保持相同的学习率，并在接下来的100个epoch中线性递减到零。请参阅附录（第7节）了解有关数据集、架构和训练过程的更多细节。

cyclegan 循环一致性对抗网络 论文点

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。