华为开源自研AI框架昇思MindSpore应用案例：Pix2Pix实现图像转换

柔情只为你懂 2024-03-17 11:30 44阅读 0赞

#### 目录 ####

*  一、环境准备
 *   *  1.进入ModelArts官网
     *  2.使用CodeLab体验Notebook实例
 *  二、基础原理
 *  三、准备环节
 *   *  配置环境文件
     *  准备数据
     *  数据展示
 *  四、创建网络
 *   *  生成器G结构
     *   *  定义UNet Skip Connection Block
         *  基于UNet的生成器
     *  基于PatchGAN的判别器
     *  Pix2Pix的生成器和判别器初始化
 *  五、训练
 *  六、推理

> 在实际应用场景中，由于训练数据集不足，所以很少有人会从头开始训练整个网络。普遍的做法是，在一个非常大的基础数据集上训练得到一个预训练模型，然后使用该模型来初始化网络的权重参数或作为固定特征提取器应用于特定的任务中。本章将使用迁移学习的方法对ImageNet数据集中的狼和狗图像进行分类。

如果你对MindSpore感兴趣，可以关注[**昇思MindSpore社区**][MindSpore]

![在这里插入图片描述][a9571b75523b4cbca146948dbadf8715.png]

![在这里插入图片描述][8e1b9518e76a42838be8cde13c4655c7.png]

## 一、环境准备 ##

### 1.进入ModelArts官网 ###

云平台帮助用户快速创建和部署模型，管理全周期AI工作流，选择下面的云平台以开始使用昇思MindSpore，[获取安装命令][Link 1]，安装MindSpore2.0.0-alpha版本，可以在昇思教程中进入[**ModelArts官网**][ModelArts]

![在这里插入图片描述][661e20e619f840aba899fac2091e96bf.png]

选择下方CodeLab立即体验

![在这里插入图片描述][547900ad31bf4f4386132554fe26dfb9.png]

等待环境搭建完成

![在这里插入图片描述][1466f73e44fa4fe69bd38b0b30661e22.png]

### 2.使用CodeLab体验Notebook实例 ###

下载[**NoteBook样例代码**][NoteBook]，[**Pix2Pix实现图像转换**][Pix2Pix] ，`.ipynb`为样例代码

![在这里插入图片描述][0568efbcd7b64bae8c91d29cd60ca993.png]

选择ModelArts Upload Files上传`.ipynb`文件

![在这里插入图片描述][e61bd133ba3542f09c446844d843b8fb.png]

![在这里插入图片描述][21ea3d8438b6494a8e54507b21a4dd98.png]

![在这里插入图片描述][64ce46ee17764bb0a6b03cbc6cde1f4c.png]

选择Kernel环境

![在这里插入图片描述][6930996b327a468998e613a7e2ad2974.png]

切换至GPU环境，切换成第一个限时免费

![在这里插入图片描述][3ee6f6bb23454bbeb5fec682705b3873.png]

进入[**昇思MindSpore官网**][MindSpore 1]，点击上方的安装

![在这里插入图片描述][2dec09846d164105b79d514aa0deed82.png]

获取安装命令

![在这里插入图片描述][084d07e792b64e8e857146e81183ca42.png]

回到Notebook中，在第一块代码前加入命令  
![在这里插入图片描述][d1b5e7f5355b410599f32ed6a59d9000.png]

conda update -n base -c defaults conda

![在这里插入图片描述][805039f1f2df413daf3a797d6ef58b01.png]

安装MindSpore 2.0 GPU版本

conda install mindspore=2.0.0a0 -c mindspore -c conda-forge

![在这里插入图片描述][95a53f7dde714310a336b134e5a51f1d.png]

安装mindvision

pip install mindvision

![在这里插入图片描述][7eec4a2d97634beeae03da93eabf8eb5.png]

安装下载download

pip install download

![在这里插入图片描述][119027ad29034ed9be82b75092515c6c.png]

## 二、基础原理 ##

> cGAN的生成器与传统GAN的生成器在原理上有一些区别，cGAN的生成器是将输入图片作为指导信息，由输入图像不断尝试生成用于迷惑判别器的“假”图像，由输入图像转换输出为相应“假”图像的本质是从像素到另一个像素的映射，而传统GAN的生成器是基于一个给定的随机噪声生成图像，输出图像通过其他约束条件控制生成，这是cGAN和GAN的在图像翻译任务中的差异。Pix2Pix中判别器的任务是判断从生成器输出的图像是真实的训练图像还是生成的“假”图像。在生成器与判别器的不断博弈过程中，模型会达到一个平衡点，生成器输出的图像与真实训练数据使得判别器刚好具有50%的概率判断正确。
> 
> ![这里是引用][f125207e4a344eab97b29a034ece3ebd.png]![在这里插入图片描述][9c7942867a7644bdb1b9751f335aefac.png]![在这里插入图片描述][ad91ecb0f16547c8a252b36398350874.png]

## 三、准备环节 ##

### 配置环境文件 ###

本案例在GPU，CPU和Ascend平台的动静态模式都支持。

### 准备数据 ###

在本教程中，我们将使用[指定数据集][Link 2]，该数据集是已经经过处理的外墙（facades）数据，可以直接使用mindspore.dataset的方法读取。

from download import download
    
    url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/models/application/dataset_pix2pix.tar"
    
    download(url, "./dataset", kind="tar", replace=True)

![在这里插入图片描述][048a46cc521c4d148353ce2a6ed72dbc.png]

### 数据展示 ###

调用Pix2PixDataset和create\_train\_dataset读取训练集，这里我们直接下载已经处理好的数据集。

from mindspore import dataset as ds
    import matplotlib.pyplot as plt
    
    dataset = ds.MindDataset("./dataset/dataset_pix2pix/train.mindrecord", columns_list=["input_images", "target_images"], shuffle=True)
    data_iter = next(dataset.create_dict_iterator(output_numpy=True))
    # 可视化部分训练数据
    plt.figure(figsize=(10, 3), dpi=140)
    for i, image in enumerate(data_iter['input_images'][:10], 1):
        plt.subplot(3, 10, i)
        plt.axis("off")
        plt.imshow((image.transpose(1, 2, 0) + 1) / 2)
    plt.show()

![在这里插入图片描述][74bbf4f9ef2f4167b681aaf109e2d96b.png]

## 四、创建网络 ##

> 当处理完数据后，就可以来进行网络的搭建了。网络搭建将逐一详细讨论生成器、判别器和损失函数。生成器G用到的是U-Net结构，输入的轮廓图x  
> 编码再解码成真是图片，判别器D用到的是作者自己提出来的条件判别器PatchGAN，判别器D的作用是在轮廓图 x  
> 的条件下，对于生成的图片G(x) 判断为假，对于真实判断为真。

### 生成器G结构 ###

> U-Net是德国Freiburg大学模式识别和图像处理组提出的一种全卷积结构。它分为两个部分，其中左侧是由卷积和降采样操作组成的压缩路径，右侧是由卷积和上采样组成的扩张路径，扩张的每个网络块的输入由上一层上采样的特征和压缩路径部分的特征拼接而成。网络模型整体是一个U形的结构，因此被叫做U-Net。和常见的先降采样到低维度，再升采样到原始分辨率的编解码结构的网络相比，U-Net的区别是加入skip-connection，对应的feature  
> maps和decode之后的同样大小的feature maps按通道拼一起，用来保留不同分辨率下像素级的细节信息。
> 
> ![这里是引用][793d16bc37b241e0ace524f99dcfb151.png]

#### 定义UNet Skip Connection Block ####

import mindspore
    import mindspore.nn as nn
    import mindspore.ops as ops
    
    class UNetSkipConnectionBlock(nn.Cell):
        def __init__(self, outer_nc, inner_nc, in_planes=None, dropout=False,
                     submodule=None, outermost=False, innermost=False, alpha=0.2, norm_mode='batch'):
            super(UNetSkipConnectionBlock, self).__init__()
            down_norm = nn.BatchNorm2d(inner_nc)
            up_norm = nn.BatchNorm2d(outer_nc)
            use_bias = False
            if norm_mode == 'instance':
                down_norm = nn.BatchNorm2d(inner_nc, affine=False)
                up_norm = nn.BatchNorm2d(outer_nc, affine=False)
                use_bias = True
            if in_planes is None:
                in_planes = outer_nc
            down_conv = nn.Conv2d(in_planes, inner_nc, kernel_size=4,
                                  stride=2, padding=1, has_bias=use_bias, pad_mode='pad')
            down_relu = nn.LeakyReLU(alpha)
            up_relu = nn.ReLU()
            if outermost:
                up_conv = nn.Conv2dTranspose(inner_nc * 2, outer_nc,
                                             kernel_size=4, stride=2,
                                             padding=1, pad_mode='pad')
                down = [down_conv]
                up = [up_relu, up_conv, nn.Tanh()]
                model = down + [submodule] + up
            elif innermost:
                up_conv = nn.Conv2dTranspose(inner_nc, outer_nc,
                                             kernel_size=4, stride=2,
                                             padding=1, has_bias=use_bias, pad_mode='pad')
                down = [down_relu, down_conv]
                up = [up_relu, up_conv, up_norm]
                model = down + up
            else:
                up_conv = nn.Conv2dTranspose(inner_nc * 2, outer_nc,
                                             kernel_size=4, stride=2,
                                             padding=1, has_bias=use_bias, pad_mode='pad')
                down = [down_relu, down_conv, down_norm]
                up = [up_relu, up_conv, up_norm]
    
                model = down + [submodule] + up
                if dropout:
                    model.append(nn.Dropout(p=0.5))
            self.model = nn.SequentialCell(model)
            self.skip_connections = not outermost
    
        def construct(self, x):
            out = self.model(x)
            if self.skip_connections:
                out = ops.concat((out, x), axis=1)
            return out

![在这里插入图片描述][00fa623d60f6410bac238ff65e64b3cc.png]

#### 基于UNet的生成器 ####

class UNetGenerator(nn.Cell):
        def __init__(self, in_planes, out_planes, ngf=64, n_layers=8, norm_mode='bn', dropout=False):
            super(UNetGenerator, self).__init__()
            unet_block = UNetSkipConnectionBlock(ngf * 8, ngf * 8, in_planes=None, submodule=None,
                                                 norm_mode=norm_mode, innermost=True)
            for _ in range(n_layers - 5):
                unet_block = UNetSkipConnectionBlock(ngf * 8, ngf * 8, in_planes=None, submodule=unet_block,
                                                     norm_mode=norm_mode, dropout=dropout)
            unet_block = UNetSkipConnectionBlock(ngf * 4, ngf * 8, in_planes=None, submodule=unet_block,
                                                 norm_mode=norm_mode)
            unet_block = UNetSkipConnectionBlock(ngf * 2, ngf * 4, in_planes=None, submodule=unet_block,
                                                 norm_mode=norm_mode)
            unet_block = UNetSkipConnectionBlock(ngf, ngf * 2, in_planes=None, submodule=unet_block,
                                                 norm_mode=norm_mode)
            self.model = UNetSkipConnectionBlock(out_planes, ngf, in_planes=in_planes, submodule=unet_block,
                                                 outermost=True, norm_mode=norm_mode)
    
        def construct(self, x):
            return self.model(x)

![在这里插入图片描述][ab78eda751ef4590a910056ac82d57bb.png]

> 原始cGAN的输入是条件x和噪声z两种信息，这里的生成器只使用了条件信息，因此不能生成多样性的结果。因此Pix2Pix在训练和测试时都使用了dropout，这样可以生成多样性的结果。

### 基于PatchGAN的判别器 ###

> 判别器使用的PatchGAN结构，可看做卷积。生成的矩阵中的每个点代表原图的一小块区域（patch）。通过矩阵中的各个值来判断原图中对应每个Patch的真假。

import mindspore.nn as nn
    
    class ConvNormRelu(nn.Cell):
        def __init__(self,
                     in_planes,
                     out_planes,
                     kernel_size=4,
                     stride=2,
                     alpha=0.2,
                     norm_mode='batch',
                     pad_mode='CONSTANT',
                     use_relu=True,
                     padding=None):
            super(ConvNormRelu, self).__init__()
            norm = nn.BatchNorm2d(out_planes)
            if norm_mode == 'instance':
                norm = nn.BatchNorm2d(out_planes, affine=False)
            has_bias = (norm_mode == 'instance')
            if not padding:
                padding = (kernel_size - 1) // 2
            if pad_mode == 'CONSTANT':
                conv = nn.Conv2d(in_planes, out_planes, kernel_size, stride, pad_mode='pad',
                                 has_bias=has_bias, padding=padding)
                layers = [conv, norm]
            else:
                paddings = ((0, 0), (0, 0), (padding, padding), (padding, padding))
                pad = nn.Pad(paddings=paddings, mode=pad_mode)
                conv = nn.Conv2d(in_planes, out_planes, kernel_size, stride, pad_mode='pad', has_bias=has_bias)
                layers = [pad, conv, norm]
            if use_relu:
                relu = nn.ReLU()
                if alpha > 0:
                    relu = nn.LeakyReLU(alpha)
                layers.append(relu)
            self.features = nn.SequentialCell(layers)
    
        def construct(self, x):
            output = self.features(x)
            return output
    
    class Discriminator(nn.Cell):
        def __init__(self, in_planes=3, ndf=64, n_layers=3, alpha=0.2, norm_mode='batch'):
            super(Discriminator, self).__init__()
            kernel_size = 4
            layers = [
                nn.Conv2d(in_planes, ndf, kernel_size, 2, pad_mode='pad', padding=1),
                nn.LeakyReLU(alpha)
            ]
            nf_mult = ndf
            for i in range(1, n_layers):
                nf_mult_prev = nf_mult
                nf_mult = min(2 ** i, 8) * ndf
                layers.append(ConvNormRelu(nf_mult_prev, nf_mult, kernel_size, 2, alpha, norm_mode, padding=1))
            nf_mult_prev = nf_mult
            nf_mult = min(2 ** n_layers, 8) * ndf
            layers.append(ConvNormRelu(nf_mult_prev, nf_mult, kernel_size, 1, alpha, norm_mode, padding=1))
            layers.append(nn.Conv2d(nf_mult, 1, kernel_size, 1, pad_mode='pad', padding=1))
            self.features = nn.SequentialCell(layers)
    
        def construct(self, x, y):
            x_y = ops.concat((x, y), axis=1)
            output = self.features(x_y)
            return output

![在这里插入图片描述][880fe82c5cea4ef08724d204c4be73be.png]

### Pix2Pix的生成器和判别器初始化 ###

实例化Pix2Pix生成器和判别器。

import mindspore.nn as nn
    from mindspore.common import initializer as init
    
    g_in_planes = 3
    g_out_planes = 3
    g_ngf = 64
    g_layers = 8
    d_in_planes = 6
    d_ndf = 64
    d_layers = 3
    alpha = 0.2
    init_gain = 0.02
    init_type = 'normal'
    
    
    net_generator = UNetGenerator(in_planes=g_in_planes, out_planes=g_out_planes,
                                  ngf=g_ngf, n_layers=g_layers)
    for _, cell in net_generator.cells_and_names():
        if isinstance(cell, (nn.Conv2d, nn.Conv2dTranspose)):
            if init_type == 'normal':
                cell.weight.set_data(init.initializer(init.Normal(init_gain), cell.weight.shape))
            elif init_type == 'xavier':
                cell.weight.set_data(init.initializer(init.XavierUniform(init_gain), cell.weight.shape))
            elif init_type == 'constant':
                cell.weight.set_data(init.initializer(0.001, cell.weight.shape))
            else:
                raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
        elif isinstance(cell, nn.BatchNorm2d):
            cell.gamma.set_data(init.initializer('ones', cell.gamma.shape))
            cell.beta.set_data(init.initializer('zeros', cell.beta.shape))
    
    
    net_discriminator = Discriminator(in_planes=d_in_planes, ndf=d_ndf,
                                      alpha=alpha, n_layers=d_layers)
    for _, cell in net_discriminator.cells_and_names():
        if isinstance(cell, (nn.Conv2d, nn.Conv2dTranspose)):
            if init_type == 'normal':
                cell.weight.set_data(init.initializer(init.Normal(init_gain), cell.weight.shape))
            elif init_type == 'xavier':
                cell.weight.set_data(init.initializer(init.XavierUniform(init_gain), cell.weight.shape))
            elif init_type == 'constant':
                cell.weight.set_data(init.initializer(0.001, cell.weight.shape))
            else:
                raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
        elif isinstance(cell, nn.BatchNorm2d):
            cell.gamma.set_data(init.initializer('ones', cell.gamma.shape))
            cell.beta.set_data(init.initializer('zeros', cell.beta.shape))
    
    class Pix2Pix(nn.Cell):
        """Pix2Pix模型网络"""
        def __init__(self, discriminator, generator):
            super(Pix2Pix, self).__init__(auto_prefix=True)
            self.net_discriminator = discriminator
            self.net_generator = generator
    
        def construct(self, reala):
            fakeb = self.net_generator(reala)
            return fakeb

![在这里插入图片描述][c58069285209497499883530518f5b87.png]

## 五、训练 ##

训练分为两个主要部分：训练判别器和训练生成器。训练判别器的目的是最大程度地提高判别图像真伪的概率。训练生成器是希望能产生更好的虚假图像。在这两个部分中，分别获取训练过程中的损失，并在每个周期结束时进行统计。

下面进行训练：

import numpy as np
    import os
    import datetime
    from mindspore import value_and_grad, Tensor
    
    epoch_num = 100
    ckpt_dir = "results/ckpt"
    dataset_size = 400
    val_pic_size = 256
    lr = 0.0002
    n_epochs = 100
    n_epochs_decay = 100
    
    def get_lr():
        lrs = [lr] * dataset_size * n_epochs
        lr_epoch = 0
        for epoch in range(n_epochs_decay):
            lr_epoch = lr * (n_epochs_decay - epoch) / n_epochs_decay
            lrs += [lr_epoch] * dataset_size
        lrs += [lr_epoch] * dataset_size * (epoch_num - n_epochs_decay - n_epochs)
        return Tensor(np.array(lrs).astype(np.float32))
    
    dataset = ds.MindDataset("./dataset/dataset_pix2pix/train.mindrecord", columns_list=["input_images", "target_images"], shuffle=True, num_parallel_workers=16)
    steps_per_epoch = dataset.get_dataset_size()
    loss_f = nn.BCEWithLogitsLoss()
    l1_loss = nn.L1Loss()
    
    def forword_dis(reala, realb):
        lambda_dis = 0.5
        fakeb = net_generator(reala)
        pred0 = net_discriminator(reala, fakeb)
        pred1 = net_discriminator(reala, realb)
        loss_d = loss_f(pred1, ops.ones_like(pred1)) + loss_f(pred0, ops.zeros_like(pred0))
        loss_dis = loss_d * lambda_dis
        return loss_dis
    
    def forword_gan(reala, realb):
        lambda_gan = 0.5
        lambda_l1 = 100
        fakeb = net_generator(reala)
        pred0 = net_discriminator(reala, fakeb)
        loss_1 = loss_f(pred0, ops.ones_like(pred0))
        loss_2 = l1_loss(fakeb, realb)
        loss_gan = loss_1 * lambda_gan + loss_2 * lambda_l1
        return loss_gan
    
    d_opt = nn.Adam(net_discriminator.trainable_params(), learning_rate=get_lr(),
                    beta1=0.5, beta2=0.999, loss_scale=1)
    g_opt = nn.Adam(net_generator.trainable_params(), learning_rate=get_lr(),
                    beta1=0.5, beta2=0.999, loss_scale=1)
    
    grad_d = value_and_grad(forword_dis, None, net_discriminator.trainable_params())
    grad_g = value_and_grad(forword_gan, None, net_generator.trainable_params())
    
    def train_step(reala, realb):
        loss_dis, d_grads = grad_d(reala, realb)
        loss_gan, g_grads = grad_g(reala, realb)
        d_opt(d_grads)
        g_opt(g_grads)
        return loss_dis, loss_gan
    
    if not os.path.isdir(ckpt_dir):
        os.makedirs(ckpt_dir)
    
    g_losses = []
    d_losses = []
    data_loader = dataset.create_dict_iterator(output_numpy=True, num_epochs=epoch_num)
    
    for epoch in range(epoch_num):
        for i, data in enumerate(data_loader):
            start_time = datetime.datetime.now()
            input_image = Tensor(data["input_images"])
            target_image = Tensor(data["target_images"])
            dis_loss, gen_loss = train_step(input_image, target_image)
            end_time = datetime.datetime.now()
            delta = (end_time - start_time).microseconds
            if i % 2 == 0:
                print("ms per step:{:.2f}  epoch:{}/{}  step:{}/{}  Dloss:{:.4f}  Gloss:{:.4f} ".format((delta / 1000), (epoch + 1), (epoch_num), i, steps_per_epoch, float(dis_loss), float(gen_loss)))
            d_losses.append(dis_loss.asnumpy())
            g_losses.append(gen_loss.asnumpy())
        if (epoch + 1) == epoch_num:
            mindspore.save_checkpoint(net_generator, ckpt_dir + "Generator.ckpt")

![在这里插入图片描述][46f5893455c94efdaddde67e304dca28.png]

## 六、推理 ##

获取上述训练过程完成后的ckpt文件，通过load\_checkpoint和load\_param\_into\_net将ckpt中的权重参数导入到模型中，获取数据进行推理并对推理的效果图进行演示（由于时间问题，训练过程只进行了100个epoch）。

from mindspore import load_checkpoint, load_param_into_net
    
    param_g = load_checkpoint(ckpt_dir + "Generator.ckpt")
    load_param_into_net(net_generator, param_g)
    dataset = ds.MindDataset("./dataset/dataset_pix2pix/train.mindrecord", columns_list=["input_images", "target_images"], shuffle=True)
    data_iter = next(dataset.create_dict_iterator())
    predict_show = net_generator(data_iter["input_images"])
    plt.figure(figsize=(10, 3), dpi=140)
    for i in range(10):
        plt.subplot(2, 10, i + 1)
        plt.imshow((data_iter["input_images"][i].asnumpy().transpose(1, 2, 0) + 1) / 2)
        plt.axis("off")
        plt.subplots_adjust(wspace=0.05, hspace=0.02)
        plt.subplot(2, 10, i + 11)
        plt.imshow((predict_show[i].asnumpy().transpose(1, 2, 0) + 1) / 2)
        plt.axis("off")
        plt.subplots_adjust(wspace=0.05, hspace=0.02)
    plt.show()

![在这里插入图片描述][c84d629bb9d74956ad58faa4784b6c02.png]

![在这里插入图片描述][5c900cd2e3974c1cbc89ed1e1eeb3f0a.png]

各数据集分别推理的效果如下

![在这里插入图片描述][d2b29441dd054afeac9963c8a190f2b4.png]

[MindSpore]: https://bbs.csdn.net/forums/MindSpore_Official
[a9571b75523b4cbca146948dbadf8715.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/73927fe73f4a4723964d316b4a768b4f.png
[8e1b9518e76a42838be8cde13c4655c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/effa49f8f9af4765b9c7cbb180a32826.png
[Link 1]: https://mindspore.cn/install
[ModelArts]: https://console.huaweicloud.com/modelarts/?region=cn-north-4#/dashboard
[661e20e619f840aba899fac2091e96bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/9359e8a028b045f1b96fa33080e90774.png
[547900ad31bf4f4386132554fe26dfb9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/ec7c7ef9b7eb4326b881a624f2629ee1.png
[1466f73e44fa4fe69bd38b0b30661e22.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/abe423a420fb485982d25be46ba7af2e.png
[NoteBook]: https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r2.0/tutorials/application/zh_cn/generative/mindspore_pix2pix.ipynb
[Pix2Pix]: https://www.mindspore.cn/tutorials/application/zh-CN/r2.0/generative/pix2pix.html
[0568efbcd7b64bae8c91d29cd60ca993.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/e2a53dfeea1246369dd8e346366d67f2.png
[e61bd133ba3542f09c446844d843b8fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/24e3bc02c5c941039b0c93c0578ad9aa.png
[21ea3d8438b6494a8e54507b21a4dd98.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/6fcd581996ee4bda8c83899c9b034f77.png
[64ce46ee17764bb0a6b03cbc6cde1f4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/26c614356f814c7bbc76eb765a9fc471.png
[6930996b327a468998e613a7e2ad2974.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/d64c3f88234344508fe579283acd801e.png
[3ee6f6bb23454bbeb5fec682705b3873.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/50b35771e6824d3ab223140691c38536.png
[MindSpore 1]: https://www.mindspore.cn/
[2dec09846d164105b79d514aa0deed82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/7b0f1fcb345f495292b7dcb04929b0d7.png
[084d07e792b64e8e857146e81183ca42.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/58e24cf980f542bb852583b1415325f0.png
[d1b5e7f5355b410599f32ed6a59d9000.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/c38318100f954f2390803eeded303c3b.png
[805039f1f2df413daf3a797d6ef58b01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/ee408e770dbf46fcab56765096118323.png
[95a53f7dde714310a336b134e5a51f1d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/1c26d67d3c0b4593bfc841581fcd5b5b.png
[7eec4a2d97634beeae03da93eabf8eb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/26c227ce5aac4ff18334055389bc9d18.png
[119027ad29034ed9be82b75092515c6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/9be2ee63e92f4442a3a28fdc71c1f99d.png
[f125207e4a344eab97b29a034ece3ebd.png]: https://img-blog.csdnimg.cn/f125207e4a344eab97b29a034ece3ebd.png
[9c7942867a7644bdb1b9751f335aefac.png]: https://img-blog.csdnimg.cn/9c7942867a7644bdb1b9751f335aefac.png
[ad91ecb0f16547c8a252b36398350874.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/d086f636dd8e450c8fee610d77b4d0f5.png
[Link 2]: https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/models/application/dataset_pix2pix.tar
[048a46cc521c4d148353ce2a6ed72dbc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/fbc53f17a3ee474bafdd733f4a06fc5f.png
[74bbf4f9ef2f4167b681aaf109e2d96b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/6f8761dfcdb448fcacf33535502af047.png
[793d16bc37b241e0ace524f99dcfb151.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/8f6297bf6ed14a18a529d9b38afd9ee5.png
[00fa623d60f6410bac238ff65e64b3cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/3c0449b1253d467da7e755bc3cbf93f7.png
[ab78eda751ef4590a910056ac82d57bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/bcd76a98e1094b678772867dbfbba249.png
[880fe82c5cea4ef08724d204c4be73be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/1098ae89f4504e8293bcb1a819168bd7.png
[c58069285209497499883530518f5b87.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/434455d6eaaf4b03bb552721d426eef6.png
[46f5893455c94efdaddde67e304dca28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/70f64210f2f64ea48da08817c94f4ad0.png
[c84d629bb9d74956ad58faa4784b6c02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/959578e61f1f4cae8ea6ce9fea1072aa.png
[5c900cd2e3974c1cbc89ed1e1eeb3f0a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/e3ed59bae3914aedb6f167fd6c2ff34e.png
[d2b29441dd054afeac9963c8a190f2b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/1c667e07383c4fb2b88512b99ebe62a1.png