CycleGAN详解与实现（采用tensorflow2，2024年最新面试看这个就够了

这可以通过对抗性训练反向循环GAN来完成。 目的是使生成器 F F F学习如何欺骗鉴别器 D x D_x Dx​。

此外，还具有类似的反向循环一致性以恢复原始源 y y y：

y ′ = G ( F ( y ) ) ( 4 ) y’=G(F(y))\qquad(4) y′=G(F(y))(4)

这是通过最小化反向循环一致性 L 1 L_1 L1​损失来完成的：

L b a c k w a r d − c y c = E y ∼ p d a t a ( y ) [ ∥ G ( F ( y ) ) − y ∥ 1 ] ( 5 ) \mathcal L_{backward-cyc}= \mathbb E_{y\sim p_{data}(y)}[\| G(F(y))-y\|_1] \qquad (5) Lbackward−cyc​=Ey∼pdata​(y)​[∥G(F(y))−y∥1​](5)

CycleGAN的最终目标是让生成器 G G G学习如何合成伪造的目标数据 y ′ y’ y′，该伪造的目标数据 y ′ y’ y′使用前向循环的鉴别器 D y D_y Dy​。 由于网络是对称的，因此CycleGAN还希望生成器 F F F学习如何合成伪造的源数据 x ′ x’ x′，该伪造的源数据 x ′ x’ x′可以在反向循环中欺骗鉴别器 D x D_x Dx​。

受最小二乘GAN（LSGAN）更好的感知质量的启发，CycleGAN的鉴别器和生成器还使用MSE损失。 LSGAN与原始GAN之间的差异是使用MSE损失，而不是二元交叉熵损失。

训练过程

CycleGAN将生成器－鉴别器损失函数表示为：

L f o r w a r d − G A N ( D ) = E y ∼ p d a t a ( y ) ( D y ( y ) − 1 ) 2 + E x ∼ p d a t a ( x ) D y ( G ( x ) ) 2 ( 6 ) \mathcal L_{forward-GAN}^{(D)}= \mathbb E_{y\sim p_{data}(y)}(D_y(y)-1)^2+ \mathbb E_{x\sim p_{data}(x)}D_y(G(x))^2\qquad (6) Lforward−GAN(D)​=Ey∼pdata​(y)​(Dy​(y)−1)2+Ex∼pdata​(x)​Dy​(G(x))2(6)

L f o r w a r d − G A N ( G ) = E x ∼ p d a t a ( x ) ( D y ( G ( x ) ) − 1 ) 2 ( 7 ) \mathcal L_{forward-GAN}^{(G)}= \mathbb E_{x\sim p_{data}(x)}(D_y(G(x))-1)^2\qquad (7) Lforward−GAN(G)​=Ex∼pdata​(x)​(Dy​(G(x))−1)2(7)

L b a c k w a r d − G A N ( D ) = E x ∼ p d a t a ( x ) ( D x ( x ) − 1 ) 2 + E y ∼ p d a t a ( y ) D x ( G ( y ) ) 2 ( 8 ) \mathcal L_{backward-GAN}^{(D)}= \mathbb E_{x\sim p_{data}(x)}(D_x(x)-1)^2+ \mathbb E_{y\sim p_{data}(y)}D_x(G(y))^2\qquad (8) Lbackward−GAN(D)​=Ex∼pdata​(x)​(Dx​(x)−1)2+Ey∼pdata​(y)​Dx​(G(y))2(8)

L b a c k w a r d − G A N ( G ) = E y ∼ p d a t a ( y ) ( D x ( G ( y ) ) − 1 ) 2 ( 9 ) \mathcal L_{backward-GAN}^{(G)}= \mathbb E_{y\sim p_{data}(y)}(D_x(G(y))-1)^2\qquad (9) Lbackward−GAN(G)​=Ey∼pdata​(y)​(Dx​(G(y))−1)2(9)

L G A N ( D ) = L f o r w a r d − G A N ( D ) + L b a c k w a r d − G A N ( D ) ( 10 ) \mathcal L_{GAN}^{(D)}=\mathcal L_{forward-GAN}^{(D)}+\mathcal L_{backward-GAN}^{(D)}\qquad(10) LGAN(D)​=Lforward−GAN(D)​+Lbackward−GAN(D)​(10)

L G A N ( G ) = L f o r w a r d − G A N ( G ) + L b a c k w a r d − G A N ( G ) ( 11 ) \mathcal L_{GAN}^{(G)}=\mathcal L_{forward-GAN}^{(G)}+\mathcal L_{backward-GAN}^{(G)}\qquad(11) LGAN(G)​=Lforward−GAN(G)​+Lbackward−GAN(G)​(11)

第二组损失函数是循环一致性损失，可以通过对前向和反向GAN的计算求和得出：

L c y c = L f o r w a r d − c y c + L b a c k w a r d − c y c ( 12 ) \mathcal L_{cyc}=\mathcal L_{forward-cyc}+\mathcal L_{backward-cyc}\qquad(12) Lcyc​=Lforward−cyc​+Lbackward−cyc​(12)

L c y c = E x ∼ p d a t a ( x ) [ ∥ F ( G ( x ) ) − x ∥ 1 ] + E y ∼ p d a t a ( y ) [ ∥ G ( F ( y ) ) − y ∥ 1 ] ( 13 ) \mathcal L_{cyc}= \mathbb E_{x\sim p_{data}(x)}[\| F(G(x))-x\|_1]+\mathbb E_{y\sim p_{data}(y)}[\| G(F(y))-y\|_1]\qquad(13) Lcyc​=Ex∼pdata​(x)​[∥F(G(x))−x∥1​]+Ey∼pdata​(y)​[∥G(F(y))−y∥1​](13)

CycleGAN的总损失为：

L = λ 1 L G A N + λ 2 L c y c ( 14 ) \mathcal L= \lambda_1\mathcal L_{GAN}+\lambda_2\mathcal L_{cyc}\qquad(14) L=λ1​LGAN​+λ2​Lcyc​(14)

CycleGAN论文中建议使用以下权重值 λ 1 = 1.0 \lambda_1=1.0 λ1​=1.0, λ 2 = 10.0 \lambda_2=10.0 λ2​=10.0，以更加重视循环一致性检查。

CycleGAN训练过程：

重复 n n n次以下训练步骤：

1.通过使用实际源数据和目标数据训练前向循环鉴别器，将 L f o r w a r d − G A N ( G ) \mathcal L_{forward-GAN}^{(G)} Lforward−GAN(G)​最小化。 真实目标数据 y y y的标签为1.0。伪造目标数据 y ′ = G ( x ) y’=G(x) y′=G(x)的标签为0.0。

2.通过使用真实的源数据和目标数据训练反向循环鉴别器，将 L b a c k w a r d − G A N ( G ) \mathcal L_{backward-GAN}^{(G)} Lbackward−GAN(G)​最小化。 实际源数据x标签为1.0。 伪造的源数据 x ′ = F ( y ) x’=F(y) x′=F(y)的标签为0.0。

3.通过训练对抗网络中的前向和反向生成器，使 L G A N ( G ) \mathcal L_{GAN}^{(G)} LGAN(G)​和 L c y c \mathcal L_{cyc} Lcyc​最小化。伪造的目标数据 y ′ = G ( x ) y’=G(x) y′=G(x)的标签为1.0。 伪造的源数据 x ′ = F ( y ) x’=F(y) x′=F(y)的标签为1.0。

在神经风格转移问题中，颜色组合可能无法成功地从源图像转移到伪造目标图像，为了解决这个问题，CycleGAN提出包括前向和反向标识损失函数（identity loss function）：

L i d e n t i t y = E x ∼ p d a t a ( x ) [ ∥ F ( x ) − x ∥ 1 ] + E y ∼ p d a t a ( y ) [ ∥ G ( y ) − y ∥ 1 ] ( 15 ) \mathcal L_{identity}= \mathbb E_{x\sim p_{data}(x)}[\| F(x)-x\|_1]+\mathbb E_{y\sim p_{data}(y)}[\| G(y)-y\|_1]\qquad(15) Lidentity​=Ex∼pdata​(x)​[∥F(x)−x∥1​]+Ey∼pdata​(y)​[∥G(y)−y∥1​](15)

CycleGAN的总损失变为：

L = λ 1 L G A N + λ 2 L c y c + λ 3 L i d e n t i t y ( 16 ) \mathcal L= \lambda_1\mathcal L_{GAN}+\lambda_2\mathcal L_{cyc}+\lambda_3\mathcal L_{identity}\qquad(16) L=λ1​LGAN​+λ2​Lcyc​+λ3​Lidentity​(16)

其中 λ 3 = 0.5 \lambda_3=0.5 λ3​=0.5。 在对抗训练中，标识损失也得到了优化。

CycleGAN实现

---

实现彩色图片与灰度图片转换。将灰度训练图像用作源域图像，将原始彩色图像用作目标域图像。简单起见，使用cifar10数据集，并通过随机采样使训练数据的源域与目标域不相对应。

要实现CycleGAN，需要构建两个生成器和两个鉴别器。 CycleGAN的生成器学习源输入分布的潜在表示，并将该表示转换为目标输出分布。这正是自编码器的功能。但是，典型的自编码器使用的编码器会对输入进行下采样，直到瓶颈层为止，解码器中的处理过程将相反。

由于在编码器和解码器层之间共享许多低级特征，因此该结构不适用于某些图像转换问题。CycleGAN生成器使用U-Net结构：

在U-Net结构中，编码器层的输出 e n − i e_{n-i} en−i​与解码器层的输出 d i d_i di​连接在一起，其中n = 4是编码器/解码器层的数量，i = 1、2和3 是共享信息的层号。

应该注意，尽管使用n = 4，但输入/输出尺寸较大的问题可能需要更深的编码器/解码器层。 通过U-Net结构，可以在编码器和解码器之间自由传输特征信息。

编码器层由实例规范化（Instance Normalization, IN）-LeakyReLU-Conv2D组成，而解码器层由IN-ReLU-Conv2D组成。

实例规范化（IN）是每个数据样本的批量规范化（BN）（即，IN是每个图像或每个特征的BN）。在样式转换中，重要的是标准化每个样本而不是每个批次的对比度。IN等效于对比度归一化。

为了使用IN层，除了可以自己编写函数外，也可以通过安装附加库tensorflow_addons

加载库

import numpy as np

import tensorflow as tf

import math

import os

import matplotlib.pyplot as plt

from PIL import Image

from tensorflow import keras

import datetime

import argparse

from tensorflow_addons.layers import InstanceNormalization

生成器

def encoder_layer(inputs,

filters=16,

kernel_size=3,

strides=2,

activation=‘leaky_relu’,

instance_normal=True):

“”"encoder layer

Conv2D-IN-LeakyReLU, IN is optional

“”"

conv = keras.layers.Conv2D(filters=filters,

kernel_size=kernel_size,

strides=strides,

padding=‘same’)

x = inputs

if instance_normal:

x = InstanceNormalization(axis=3)(x)

if activation == ‘relu’:

x = keras.layers.Activation(‘relu’)(x)

else:

x = keras.layers.LeakyReLU(alpha=0.2)(x)

x = conv(x)

return x

def decoder_layer(inputs,

paired_inputs,

filters=16,

kernel_size=3,

strides=2,

activation=‘leaky_relu’,

instance_normal=True):

“”"decoder layer

Conv2D-IN-LeakyReLU, IN is optional

Arguments: (partial)

inputs (tensor): the decoder layer input

paired_inputs (tensor): the encoder layer output

provided by U-Net skip connection & concatenated to inputs.

“”"

conv = keras.layers.Conv2DTranspose(filters=filters,

kernel_size=kernel_size,

strides=strides,

padding=‘same’)

x = inputs

if instance_normal:

x = InstanceNormalization(axis=3)(x)

if activation == ‘relu’:

x = keras.layers.Activation(‘relu’)(x)

else:

x = keras.layers.LeakyReLU(alpha=0.2)(x)

x = conv(x)

x = keras.layers.concatenate([x,paired_inputs])

return x

def build_generator(input_shape,

output_shape=None,

kernel_size=3,

name=None):

“”"The generator is a U-Network made of a 4-layer encoder and

a 4-layer decoder. Layer n-i is connected to layer i.

Arguments:

input_shape (tuple): input shape

output_shape (tuple): output shape

kernel_size (int): kenel size of encoder $ decoder layers

name (string): name assigned to generator model

Returns:

generator (model)

“”"

inputs = keras.layers.Input(shape=input_shape)

channals = int(output_shape[-1])

e1 = encoder_layer(inputs,32,kernel_size=kernel_size,strides=1)

e2 = encoder_layer(e1,64,kernel_size=kernel_size)

e3 = encoder_layer(e2,128,kernel_size=kernel_size)

e4 = encoder_layer(e3,256,kernel_size=kernel_size)

d1 = decoder_layer(e4,e3,128,kernel_size=kernel_size)

d2 = decoder_layer(d1,e2,64,kernel_size=kernel_size)

d3 = decoder_layer(d2,e1,32,kernel_size=kernel_size)

outputs = keras.layers.Conv2DTranspose(channals,

kernel_size=kernel_size,

strides=1,

activation=‘sigmoid’,

padding=‘same’)(d3)

generator = keras.Model(inputs,outputs,name=name)

return generator

鉴别器

CycleGAN的鉴别器类似于原始GAN鉴别器。输入图像被下采样数次。 最后一层是Dense(1)层，它预测输入为真实图片的概率。除了不使用IN之外，每一层都类似于生成器的编码器层。但是，在大图像中，用一个概率将图像分类为真实或伪造会导致参数更新效率低下，并导致生成的图像质量较差。

解决方案是使用PatchGAN，该方法将图像划分为patch网格，并使用标量值网格来预测patch是真实图片概率。

PatchGAN并没有在CycleGAN中引入一种新型的GAN。 为了提高生成的图像质量，不是仅输出一个

鉴别结果，如果使用2 x 2 PatchGAN，有四个输出结果。损失函数没有变化。

def build_discriminator(input_shape,

kernel_size=3,

patchgan=True,

name=None):

“”"The discriminator is a 4-layer encoder that outputs either

a 1-dim or a n * n-dim patch of probility that input is real

Arguments:

input_shape (tuple): input shape

kernel_size (int): kernel size of decoder layers

patchgan (bool): whether the output is a patch or just a 1-dim

name (string): name assigned to discriminator model

Returns:

discriminator (model)

“”"

inputs = keras.layers.Input(shape=input_shape)

x = encoder_layer(inputs,

32,

kernel_size=kernel_size,

instance_normal=False)

x = encoder_layer(x,

64,

kernel_size=kernel_size,

instance_normal=False)

x = encoder_layer(x,

128,

kernel_size=kernel_size,

instance_normal=False)

x = encoder_layer(x,

256,

kernel_size=kernel_size,

instance_normal=False)

if patchgan:

x = keras.layers.LeakyReLU(alpha=0.2)(x)

outputs = keras.layers.Conv2D(1,

kernel_size=kernel_size,

strides=2,

padding=‘same’)(x)

else:

x = keras.layers.Flatten()(x)

x = keras.layers.Dense(1)(x)

outputs = keras.layers.Activation(‘linear’)(x)

discriminator = keras.Model(inputs,outputs,name=name)

return discriminator

CycleGAN

使用生成器和鉴别器构建CycleGAN。实例化了两个生成器g_source = F F F和g_target = G G G以及两个鉴别器d_source = D x D_x Dx​和d_target = D y D_y Dy​。前向循环是 x ′ = F ( G ( x ) ) x’=F(G(x)) x′=F(G(x))= reco_source = g_source(g_target(source_input))。反向循环是 y ′ = G ( F ( y ) ) y’=G(F(y)) y′=G(F(y))= reco_target = g_target(g_source(target_input))。

对抗模型的输入是源数据和目标数据，而输出是 D x D_x Dx​和 D y D_y Dy​的以及输入的重构 x ′ x’ x′和 y ′ y’ y′。由于灰度图像和彩色图像中通道数之间的差异，未使用标识网络。对于GAN和循环一致性损失，分别使用损失权重 λ 1 = 1.0 \lambda_1=1.0 λ1​=1.0和 λ 2 = 10.0 \lambda_2=10.0 λ2​=10.0。使用RMSprop作为鉴别器器的优化器，其学习率为2e-4，衰减率为6e-8。对抗网络的学习率和衰退率是鉴别器的一半。

def build_cyclegan(shapes,

source_name=‘source’,

target_name=‘target’,

kernel_size=3,

patchgan=False,

identity=False):

“”"CycleGAN

1. build target and source discriminators

2. build target and source generators

3. build the adversarial network

Arguments:

shapes (tuple): source and target shapes

source_name (string): string to be appended on dis/gen models

target_name (string): string to be appended on dis/gen models

kernel_size (int): kernel size for the encoder/decoder

or dis/gen models

patchgan (bool): whether to use patchgan on discriminator

identity (bool): whether to use identity loss

returns:

list: 2 generator, 2 discriminator, and 1 adversarial models

“”"

source_shape,target_shape = shapes

lr = 2e-4

decay = 6e-8

gt_name = ‘gen_’ + target_name

gs_name = ‘gen_’ + source_name

dt_name = ‘dis_’ + target_name

ds_name = ‘dis_’ + source_name

#build target and source generators

g_target = build_generator(source_shape,

target_shape,

kernel_size=kernel_size,

name=gt_name)

g_source = build_generator(target_shape,

source_shape,

kernel_size=kernel_size,

name=gs_name)

print(‘----TARGET GENERATOR----’)

g_target.summary()

print(‘----SOURCE GENERATOR----’)

g_source.summary()

#build target and source discriminators

d_target = build_discriminator(target_shape,

patchgan=patchgan,

kernel_size=kernel_size,

name=dt_name)

d_source = build_discriminator(source_shape,

patchgan=patchgan,

kernel_size=kernel_size,

name=ds_name)

print(‘----TARGET DISCRIMINATOR----’)

d_target.summary()

print(‘----SOURCE DISCRIMINATOR----’)

d_source.summary()

optimizer = keras.optimizers.RMSprop(lr=lr,decay=decay)

d_target.compile(loss=‘mse’,

optimizer=optimizer,

metrics=[‘acc’])

d_source.compile(loss=‘mse’,

optimizer=optimizer,

metrics=[‘acc’])

d_target.trainable = False

d_source.trainable = False

#the adversarial model

#forward cycle network and target discriminator

source_input = keras.layers.Input(shape=source_shape)

fake_target = g_target(source_input)

preal_target = d_target(fake_target)

reco_source = g_source(fake_target)

#backward cycle network and source discriminator

target_input = keras.layers.Input(shape=target_shape)

fake_source = g_source(target_input)

preal_source = d_source(fake_source)

reco_target = g_target(fake_source)

if identity:

iden_source = g_source(source_input)

iden_target = g_target(target_input)

loss = [‘mse’,‘mse’,‘mae’,‘mae’,‘mae’,‘mae’]

loss_weights = [1.,1.,10.,10.,0.5,0.5]

inputs = [source_input,target_input]

outputs = [preal_source,

preal_target,

reco_source,

reco_target,

iden_source,

iden_target]

else:

loss = [‘mse’,‘mse’,‘mae’,‘mae’]

loss_weights = [1.0,1.0,10.0,10.0]

inputs = [source_input,target_input]

outputs = [preal_source,preal_target,reco_source,reco_target]

#build

adv = keras.Model(inputs,outputs,name=‘adversarial’)

optimizer = keras.optimizers.RMSprop(lr=lr0.5,decay=decay0.5)

adv.compile(loss=loss,

loss_weights=loss_weights,

optimizer=optimizer,

metrics=[‘acc’])

print(‘----ADVERSARIAL NETWORK----’)

adv.summary()

return g_source,g_target,d_source,d_target,adv

加载与处理数据

def rgb2gray(rgb):

“”"Convert from color image to grayscale

Formula: grayscale = 0.299 * red + 0.587 * green + 0.114 * blue

“”"

return np.dot(rgb[…,:3],[0.299,0.587,0.114])

def display_images(imgs,

filename,

title=‘’,

imgs_dir=None,

show=False):

“”"Display images in an n*n grid

Arguments:

imgs (tensor): array of images

filename (string): filename to save the displayed image

title (string): title on the displayed image

imgs_dir (string): directory where to save the files

show (bool): whether to display the image or not

“”"

rows = imgs.shape[1]

cols = imgs.shape[2]

channels = imgs.shape[3]

side = int(math.sqrt(imgs.shape[0]))

assert int(side * side) == imgs.shape[0]

#create saved_images folder

if imgs_dir is None:

imgs_dir = ‘saved_images’

save_dir = os.path.join(os.getcwd(),imgs_dir)

if not os.path.isdir(save_dir):

os.makedirs(save_dir)

filename = os.path.join(imgs_dir,filename)

if channels == 1:

imgs = imgs.reshape((side,side,rows,cols))

else:

imgs = imgs.reshape((side,side,rows,cols,channels))

imgs = np.vstack([np.hstack(i) for i in imgs])

plt.figure()

plt.axis(‘off’)

plt.title(title)

if channels==1:

plt.imshow(imgs,interpolation=‘none’,cmap=‘gray’)

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）

如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费学习大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-KgigOOgZ-1712652371550)]