近日，有关人贩子“梅姨”的图片在朋友圈以及网络平台热传，所有人都以为这是一张官方发布的照片，于是纷纷在朋友圈转发。

但是当天下午，公安部儿童失踪信息紧急发布平台曾发布消息称，“梅姨”的第二张画像非官方公布信息，CCSER不是公安机关官方权威平台。

后来更是被爆料出CCSER其实是一个民间民间互助平台，并非官方组织。

广东省公安厅未邀请专家对"梅姨"进行二次画像。那么这张彩色照片到底是怎么来的呢？

原来是今年3月份，因接触过‘梅姨’的人认为此前‘梅姨’画像不像，于是邀请了画像专家林宇辉对进行了第二次画像。

林宇辉说，通过与“梅姨”同居两年的当地老人及其女儿进行沟通，画出了这一张新的黑白照片。



这个林宇辉专家，在震惊中外的章莹颖案件中，根据三段模糊的远距离视频，画出嫌疑犯相貌。嫌疑犯抓获后，发现其长相与画上相似度达80%

有热心人士看到这张新画的黑白画像后，用电脑合成了蓝底的彩色“梅姨”画像，发给了被拐儿童家属。于是儿童家属把这个彩色的画像发布到社交平台上和媒体手上。

后来被CCSER使用，加了二维码，在朋友圈传播开来。

新闻中说，彩色照片是通过黑白照片经过电脑合成的，那么，计算机在合成的时候，背后的技术原理是什么呢？

照片上色技术

这种技术被称之为"图像彩色化"，这项技术目前已经非常成熟了，广泛应用于各个领域，比较普遍的就是照片修复。

目前也有很多这样的网站，下图就是我们在https://colourise.sg/ 网站上，上传了"梅姨"的黑白照，经过人工智能处理后，获得的彩色照片。



提到人工智能为照片上色，不得不提的一个技术就是GAN（生成对抗网络）。

生成式对抗网络（GAN）是近年来大热的深度学习模型。

GAN的基本原理其实非常简单，这里以生成图片为例进行说明。假设我们有两个网络，G（Generator）和D（Discriminator）。正如它的名字所暗示的那样，它们的功能分别是：

G是一个生成图片的网络，它接收一个随机的噪声z，通过这个噪声生成图片，记做G(z)。

D是一个判别网络，判别一张图片是不是“真实的”。它的输入参数是x，x代表一张图片，输出D（x）代表x为真实图片的概率，如果为1，就代表100%是真实的图片，而输出为0，就代表不可能是真实的图片。

在训练过程中，生成网络G的目标就是尽量生成真实的图片去欺骗判别网络D。而D的目标就是尽量把G生成的图片和真实的图片分别开来。这样，G和D构成了一个动态的“博弈过程”。



最后博弈的结果是什么？在最理想的状态下，G可以生成足以“以假乱真”的图片G(z)。对于D来说，它难以判定G生成的图片究竟是不是真实的，因此D(G(z)) = 0.5。

这样我们的目的就达成了：我们得到了一个生成式的模型G，它可以用来生成图片。

那么，如何利用GAN技术为图片上色呢？

这要看下目前人工给图片上色的过程：

• 对照片的历史、地理、文化背景进行深入研究，以推断出合适的颜色；

• 用 Photoshop 等软件工具对黑白图像进行上色。

同样，计算机程序也需要完成两项任务：

• 识别黑白照片中的目标并基于之前见过的照片推断出适合目标的颜色；

• 给黑白照片上色

接下来我们直接上代码，代码参考自：https://zhuanlan.zhihu.com/p/70192339

上色实战

上色的首要条件就是对图片进行预处理：

class PairImageDataset(data.Dataset):    def __init__(self, path):        files = os.listdir(path)        self.files = [os.path.join(path, x) for x in files]

    def __len__(self):        return len(self.files)

    def __getitem__(self, index):        img = Image.open(self.files[index])        yuv = rgb2yuv(img)        y = yuv[..., 0] - 0.5        u_t = yuv[..., 1] / 0.43601035        v_t = yuv[..., 2] / 0.61497538        return torch.Tensor(np.expand_dims(y, axis=0)), torch.Tensor(            np.stack([u_t, v_t], axis=0))

这段小巧的代码，就是我们定义的数据输入器，使用pytorch的dataset API编写。通过读取图片，RGB转到YUV，然后分离Y和UV通道，就可以构建我们的输入数据了！

在之前我写的30行代码自动上色的程序里面，我们用很少的代码实现了一个自动上色程序，这次使用GAN方法略显复杂，但实际代码并不多：

train_ds = PairImageDataset(args.training_dir)    logging.info('loaded dataset from: {}, data length: {}'.format(args.training_dir, train_ds.__len__()))    train_dataloader = data.DataLoader(train_ds, batch_size=args.batch_size, shuffle=True, num_workers=0)

    i = 0    adversarial_loss = torch.nn.BCELoss()    optimizer_G = torch.optim.Adam(G.parameters(),                                   lr=args.g_lr,                                   betas=(0.5, 0.999))    optimizer_D = torch.optim.Adam(D.parameters(),                                   lr=args.d_lr,                                   betas=(0.5, 0.999))    for epoch in range(start_epoch, args.epoch):        for i, (y, uv) in enumerate(train_dataloader):            try:                # Adversarial ground truths                valid = Variable(torch.Tensor(y.size(0), 1).fill_(1.0),                                requires_grad=False).to(device)                fake = Variable(torch.Tensor(y.size(0), 1).fill_(0.0),                                requires_grad=False).to(device)

                yvar = Variable(y).to(device)                uvvar = Variable(uv).to(device)                real_imgs = torch.cat([yvar, uvvar], dim=1)

                optimizer_G.zero_grad()                uvgen = G(yvar)                # Generate a batch of images                gen_imgs = torch.cat([yvar.detach(), uvgen], dim=1)

                # Loss measures generator's ability to fool the discriminator                g_loss_gan = adversarial_loss(D(gen_imgs), valid)                g_loss = g_loss_gan + args.pixel_loss_weights * torch.mean(                    (uvvar - uvgen)**2)                if i % args.g_every == 0:                    g_loss.backward()                    optimizer_G.step()

                optimizer_D.zero_grad()                # Measure discriminator's ability to classify real from generated samples                real_loss = adversarial_loss(D(real_imgs), valid)                fake_loss = adversarial_loss(D(gen_imgs.detach()), fake)                d_loss = (real_loss + fake_loss) / 2                d_loss.backward()                optimizer_D.step()                if i % 300 == 0:                    logging.info("Epoch: %d, iter: %d, D loss: %f, G total loss: %f, GAN Loss: %f"                        % (epoch, i, d_loss.item(), g_loss.item(), g_loss_gan.item()))                    save_weights(                        {'D': D.state_dict(), 'G': G.state_dict(), 'epoch': epoch},                        epoch                    )

                    # snap some images from dir                    test_imgs = glob.glob('images/*.jpeg')                    for test_img in test_imgs:                        snap_image_result_from_file(test_img, G)

            except KeyboardInterrupt:                logging.info('interrupted. try saving model now..')                save_weights(                    {'D': D.state_dict(), 'G': G.state_dict(), 'epoch': epoch}, 0                )                logging.info('saved.')                exit(0)

其中最核心是D和G的loss传递过程，首先我们定义了D的loss是BCEloss，也就是两个类别的交叉商，然后将返回的插值用来更新G，而D的loss呢则是生成的BCE和真实值的BCE二者的均值。

代码几乎没有什么比较难以理解的地方，唯一复杂的就是训练的步骤和方式。

好啦，有了Python+GAN，我们也可以把黑白照片美化成彩色照片咯！~

参考资料：

https://zhuanlan.zhihu.com/p/24767059

https://zhuanlan.zhihu.com/p/70192339

有道无术，术可成；有术无道，止于术

欢迎大家关注Java之道公众号

好文章，我在看❤️