¿Has visto a Yui Aragaki en la animación de Hayao Miyazaki? Use Python para ser un generador de animación de código abierto para convertir sus fotos en cómics japoneses dibujados a mano en segundos ~

Introducción

Tome una foto y conviértala en las obras de estilo pintadas a mano de los maestros del manga japonés como Hayao Miyazaki y Makoto Shinkai. Este GAN, que se especializa en generar imágenes animadas, es muy útil en la medición real.

Si hay un modelo que puede transformar la imagen real en una imagen pintada a mano al estilo japonés, debe ser genial. Recientemente, el corazón de la máquina descubrió que, de hecho, estos modelos, desde CartoonGAN hasta AnimeGAN, pueden generar imágenes muy interesantes.

Aquí hay un nuevo proyecto de TensorFlow que implementa AnimeGAN y proporciona modelos previamente entrenados. Es decir, directamente podemos intentar generar el efecto tras la descarga.

Aunque muchos de los mejores ejemplos dados por el proyecto original son escenas callejeras, descubrimos que todo tipo de escenas también están bien. Las siguientes son las imágenes originales y los efectos generados que probamos. Mirando el efecto de generación del primer camino de flores de cerezo, de repente hay una sensación de "El viaje de Chihiro".

Si es solo para personajes, el efecto de conversión también es muy bueno. Intente ingresar la foto de Yui Aragaki en el modelo AnimeGAN, y luego tendrá el siguiente estilo mágico.

En el proyecto original de GitHub, el autor también dio muchos ejemplos, los anteriores son solo los resultados del corazón de la máquina, también puede usarlo.

AnimeGAN

Todo el proyecto implementa el método propuesto en el documento "AnimeGAN: una nueva GAN ligera para animación fotográfica". El autor compara AnimeGAN con CartoonGAN y ComixGAN en el documento.

Como se puede ver en la figura, AnimeGAN es mejor que los dos métodos anteriores en términos de detalles, el color es relativamente más natural y la sensación de manchado no es tan fuerte. La más obvia son las representaciones de la segunda fila, las caricaturas generadas usando AnimeGAN están más cerca del estilo de Hayao Miyazaki.

Introducción al método

Para el AnimeGAN de este proyecto, la red generadora y la red discriminadora adoptadas por AnimeGAN se muestran a continuación. Parece que el modelo en su conjunto es una red neuronal convolucional más convencional, pero utilizará la normalización de instancias y la nueva función de activación de LReLU.

Además de las actualizaciones en los detalles arquitectónicos, los autores también proponen las siguientes tres nuevas funciones de pérdida:

• pérdida de estilo en escala de grises

• pérdida por adversario en escala de grises

• pérdida de reconstrucción de color

Estas funciones de pérdida pueden hacer que el estilo de la imagen generada se acerque más al estilo cómico real.

La siguiente tabla compara el tamaño del modelo y la velocidad de inferencia de ACartoonGAN y AnimeGAN. Se puede ver claramente que AnimeGAN es una GAN relativamente liviana con menos parámetros y una velocidad de inferencia más rápida.

En general, el recientemente propuesto AnimeGAN es un modelo de confrontación generativo liviano que utiliza menos parámetros de modelo e introduce una matriz de Gram para mejorar el estilo de las fotos. El método de los investigadores requiere entrenamiento en una serie de imágenes reales y una serie de imágenes de dibujos animados, y estas imágenes no necesitan emparejarse en pares, lo que demuestra que los datos de entrenamiento son muy fáciles de obtener.

Medición de proyectos

Probamos este proyecto en Ubuntu 18.04 y las dependencias relevantes son las siguientes:

• pitón 3.6.8

• tensorflow-gpu 1.8

• opencv

• tqdm

• entumecido

• globo

• argparse

Se puede decir que estas dependencias son bibliotecas de extensión de uso común en CV, por lo que no tenemos que molestarnos en resolver los problemas de varios conflictos de entorno de dependencia, aquí hay una buena revisión.

El siguiente es el proceso detallado de entrenamiento y prueba de este proyecto. Primero clonamos el proyecto AnimeGAN localmente e ingresamos en el cuaderno Jupyter:

!git clone https://github.com/TachibanaYoshino/AnimeGAN

 Cambia el directorio de trabajo a AnimeGAN:

import os
os.chdir('AnimeGAN')
print(os.getcwd())

 A continuación, descargue el modelo previamente entrenado proporcionado por el autor del proyecto, use vim download_staffs.sh para crear un archivo de shell e ingrese el siguiente comando:

URL=https://github.com/TachibanaYoshino/AnimeGAN/releases/download/Haoyao-style_V1.0/Haoyao-style.zip
ZIP_FILE=./checkpoint/Haoyao-style.zip
TARGET_DIR=./checkpoint/saved_model

mkdir -p ./checkpoint
wget -N $URL -O $ZIP_FILE
mkdir -p $TARGET_DIR
unzip $ZIP_FILE -d $TARGET_DIR
rm $ZIP_FILE

DatesetURL=https://github.com/TachibanaYoshino/AnimeGAN/releases/download/dataset-1/dataset.zip
ZIP_FILE=./dataset.zip
TARGET_DIR=./dataset

rm -rf dataset
wget -N $DatesetURL -O $ZIP_FILE
unzip $ZIP_FILE -d $TARGET_DIR
rm $ZIP_FILE

VGG_FILE=./vgg19_weight/vgg19.npy
wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1U5HCRpZWAbDVLipNoF8t0ZHpwCRX7kdF' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1U5HCRpZWAbDVLipNoF8t0ZHpwCRX7kdF" -O $VGG_FILE && rm -rf /tmp/cookies.txt

 Guarde y salga, el comando anterior descargará y guardará el modelo preentrenado, los pesos vgg19 y el conjunto de datos de entrenamiento en su directorio correspondiente. Ejecutar en el cuaderno:

!bash download_staffs.sh

En este punto, se completaron todos los preparativos y el modelo se puede entrenar ejecutando el siguiente código:

!python main.py --phase train --dataset Hayao --epoch 101 --init_epoch 1

 El proceso de entrenamiento de AnimeGAN se muestra en la siguiente figura:

Al realizar la prueba, debemos guardar la imagen para realizar la prueba en el directorio dataset/test/real y ejecutar el siguiente código:

!python test.py --checkpoint_dir checkpoint/saved_model --test_dir dataset/test/real --style_name H

Cuando vea el resultado anterior, el programa se ha ejecutado correctamente y los resultados generados se guardan en la carpeta de resultados. Como puede ver, se tarda unos 2,3 segundos en generar una imagen en la GPU P100.

final

Eso es todo por este problema ~ ¡Espero que te ayude! Si te gusta, recuerda darle tres golpes al editor antes de irte~

Si desea obtener un código fuente más completo y materiales de aprendizaje de Python, puede hacer clic en esta línea de fuentes