La pintura con IA es muy popular. Tome Kunlun AIGC como ejemplo para revelar el algoritmo modelo detrás de la pintura con IA.

La pintura con IA es muy popular. Tome Kunlun AIGC como ejemplo para revelar el algoritmo modelo detrás de la pintura con IA.

I. Introducción

Recientemente, la pintura con IA ha vuelto a poner la inteligencia artificial en el ojo público. En los primeros días del desarrollo de la inteligencia artificial, siempre se creyó que las funciones que podía realizar la inteligencia artificial eran muy limitadas. Generalmente son cosas rígidas, como jugar al ajedrez, concursos, etc., y no son creativas. La gente en ese momento nunca hubiera imaginado que la IA ahora puede dibujar, componer música y componer poesía. Estas cosas que alguna vez se consideraron exclusivas de los humanos ahora también están involucradas en la IA.
Lo que vamos a discutir hoy es la pintura con IA, que es muy popular hoy en día. Veamos si la IA es realmente creativa o si simplemente sigue moviéndose.
Hay muchos modelos que pueden implementar pintura AI, hoy discutiremos principalmente dos modelos: GAN condicional y difusión estable. Ahora existen versiones comerciales correspondientes. Por ejemplo, el dibujo de IA de Kunlun Wanwei utiliza el modelo de rama de difusión estable y ha logrado resultados considerables.

2.GAN

Aquí analizamos el principio de GAN condicional (red generativa adversaria) para implementar IA. Antes de hablar sobre GAN condicional, echemos un vistazo a qué es GAN.

2.1 Generar

Las redes generativas siempre se han considerado un gran avance en el potenciamiento de la creatividad de la IA. La generación incluye generación de texto, generación de imágenes, generación de audio, etc.
GAN es una red de generación relativamente madura, generalmente utilizada para generar imágenes. Hay muchas variantes de GAN, incluidas DCGAN, CycleGAN, etc.

2.2 Expertos y falsificaciones

El nombre chino de GAN es Generative Adversarial Network. Cuando se hace referencia a GAN, a menudo se utilizan dos caracteres opuestos como ejemplos. Uno es un experto en falsificaciones que se especializa en hacer falsificaciones; el otro es un experto en identificación que se especializa en identificar falsificaciones. Al principio no eran expertos, pero aprendieron a través de la confrontación. Con el tiempo, los expertos en falsificación pudieron crear falsificaciones que eran difíciles de identificar para cualquiera. Con el tiempo, abandonaremos a los expertos en autenticación y dejaremos que los expertos en falsificación nos sirvan.
El experto en falsificación mencionado anteriormente es la red G, que es el Generador; y el experto en identificación es la red D, que es el Discriminador. Aprenden unos de otros y eventualmente se convierten en expertos en sus respectivos campos: ésta es la idea de GAN.

2.3 Generador

A continuación utilizamos el ejemplo de generación de avatares de anime para analizar el Generador y Discriminador de la red GAN.
Primero, analicemos el Generador, que desempeña el papel de falsificación en GAN y también se utiliza para generar imágenes. El generador recibe una variable aleatoria que satisface una distribución simple específica, como la distribución gaussiana. Después de recibir la variable aleatoria de entrada, la red genera un vector muy largo a través de la operación. Podemos remodelar este vector en w × h × 3, que es una imagen en color.

La estructura específica del generador puede ser diversa, normalmente una red basada en convolución. Por ejemplo, en DCGAN, Generator consta de 5 capas de deconvolución y su estructura de red es la siguiente:

Ingrese un vector con una dimensión de 100 y genere una imagen de 64 × 64 × 3. La implementación de PyTorch es la siguiente:

class Generator(nn.Module):
    def __init__(self, ngpu):
        super(Generator, self).__init__()
        self.ngpu = ngpu
        self.main = nn.Sequential(
            # input is Z, going into a convolution
            nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False),
            nn.BatchNorm2d(ngf * 8),
            nn.ReLU(True),
            # state size. (ngf*8) x 4 x 4
            nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 4),
            nn.ReLU(True),
            # state size. (ngf*4) x 8 x 8
            nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf * 2),
            nn.ReLU(True),
            # state size. (ngf*2) x 16 x 16
            nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ngf),
            nn.ReLU(True),
            # state size. (ngf) x 32 x 32
            nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False),
            nn.Tanh()
            # state size. (nc) x 64 x 64
        )

    def forward(self, input):
        return self.main(input)

2.4 Discriminador

El discriminador es un papel muy importante en GAN. Es una red que acepta una entrada de imagen. La imagen de entrada contendrá una parte de la imagen real (la imagen de animación que recopilamos) y una parte de la imagen falsa (la imagen generada por el Generador) y luego generar un resultado. Este resultado puede ser la probabilidad de que la imagen falsa sea una imagen real, o puede ser la categoría de la falsificación (0 significa falso, 1 significa verdadero). Para Discriminator, su propósito es ajustar los parámetros de la red para que la red sepa que la imagen falsa es falsa.

No existen restricciones muy fijas en la estructura de Discriminator, que suele ser una red convolucional. Aquí también nos referimos a DCGAN, aquí hay una implementación de PyTorch:

class Discriminator(nn.Module):
    def __init__(self, ngpu):
        super(Discriminator, self).__init__()
        self.ngpu = ngpu
        self.main = nn.Sequential(
            # input is (nc) x 64 x 64
            nn.Conv2d(nc, ndf, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf) x 32 x 32
            nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 2),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*2) x 16 x 16
            nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 4),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*4) x 8 x 8
            nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False),
            nn.BatchNorm2d(ndf * 8),
            nn.LeakyReLU(0.2, inplace=True),
            # state size. (ndf*8) x 4 x 4
            nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, input):
        return self.main(input)

Lo especial aquí es el uso de LeakyReLU.

2.5 AMBOS

Con Generator y Discriminator, se puede formar una red GAN.
Al principio, Generator y Discriminator eran dos niños ignorantes, Generator no sabía generar y Discriminator no sabía distinguir. La formación de la red GAN se divide en los siguientes pasos.

• El primer paso: entrenar la red Discriminador. En este momento, las fotos proporcionadas por el Generador son todas ruido. Entrenar primero al Discriminador puede permitirle saber cómo distinguir imágenes reales y ruido.
• Paso 2: Arregle el Discriminador y entrene al Generador para que las imágenes generadas por el Generador puedan ocultarse del Discriminador
• Paso 3: Reciclar y entrenar Discriminador-Generador hasta que las imágenes generadas por Generator puedan satisfacer nuestras necesidades
• Paso 4: use el Generador para generar imágenes.
  Los pasos anteriores se pueden ver en la siguiente figura:

Lo anterior es el proceso de capacitación de la red GAN. De hecho, es el proceso de alternancia de entrenamiento entre Generador y Discriminador, su implementación en PyTorch es la siguiente:

# Create the generator
netG = Generator(ngpu).to(device)
if (device.type == 'cuda') and (ngpu > 1):
    netG = nn.DataParallel(netG, list(range(ngpu)))
netG.apply(weights_init)

# Create the Discriminator
netD = Discriminator(ngpu).to(device)

if (device.type == 'cuda') and (ngpu > 1):
    netD = nn.DataParallel(netD, list(range(ngpu)))
netD.apply(weights_init)

criterion = nn.BCELoss()

fixed_noise = torch.randn(64, nz, 1, 1, device=device)
real_label = 1.
fake_label = 0.
optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999))
optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))

# Training Loop

# Lists to keep track of progress
img_list = []
G_losses = []
D_losses = []
iters = 0

print("Starting Training Loop...")
# For each epoch
for epoch in range(num_epochs):
    # For each batch in the dataloader
    for i, data in enumerate(dataloader, 0):

        ############################
        # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
        ###########################
        ## Train with all-real batch
        netD.zero_grad()
        # Format batch
        real_cpu = data[0].to(device)
        b_size = real_cpu.size(0)
        label = torch.full((b_size,), real_label, dtype=torch.float, device=device)
        # Forward pass real batch through D
        output = netD(real_cpu).view(-1)
        # Calculate loss on all-real batch
        errD_real = criterion(output, label)
        # Calculate gradients for D in backward pass
        errD_real.backward()
        D_x = output.mean().item()

        ## Train with all-fake batch
        # Generate batch of latent vectors
        noise = torch.randn(b_size, nz, 1, 1, device=device)
        # Generate fake image batch with G
        fake = netG(noise)
        label.fill_(fake_label)
        # Classify all fake batch with D
        output = netD(fake.detach()).view(-1)
        # Calculate D's loss on the all-fake batch
        errD_fake = criterion(output, label)
        # Calculate the gradients for this batch, accumulated (summed) with previous gradients
        errD_fake.backward()
        D_G_z1 = output.mean().item()
        # Compute error of D as sum over the fake and the real batches
        errD = errD_real + errD_fake
        # Update D
        optimizerD.step()

        ############################
        # (2) Update G network: maximize log(D(G(z)))
        ###########################
        netG.zero_grad()
        label.fill_(real_label)  # fake labels are real for generator cost
        # Since we just updated D, perform another forward pass of all-fake batch through D
        output = netD(fake).view(-1)
        # Calculate G's loss based on this output
        errG = criterion(output, label)
        # Calculate gradients for G
        errG.backward()
        D_G_z2 = output.mean().item()
        # Update G
        optimizerG.step()

        # Output training stats
        if i % 50 == 0:
            print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f'
                  % (epoch, num_epochs, i, len(dataloader),
                     errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))

        # Save Losses for plotting later
        G_losses.append(errG.item())
        D_losses.append(errD.item())

        # Check how the generator is doing by saving G's output on fixed_noise
        if (iters % 500 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):
            with torch.no_grad():
                fake = netG(fixed_noise).detach().cpu()
            img_list.append(vutils.make_grid(fake, padding=2, normalize=True))

        iters += 1

Después de un período de entrenamiento, podemos generar algunas imágenes de animación. Para la implementación del código de DCGAN, consulte https://pytorch.org/tutorials/beginner/dcgan_faces_tutorial.html#sphx-glr-beginner-dcgan-faces-tutorial-py.

3. GAN condicional

A través de la red GAN anterior, podemos generar imágenes de animación. Pero esta generación es incontrolable, solo sabemos que genera imágenes de anime y no podemos conocer el contenido de las imágenes. No podemos generar imágenes basadas en descripciones, esta es una limitación de la red GAN, por lo que se propone una variante llamada GAN condicional, esta red GAN puede resolver los problemas anteriores.

3.1 Generador

La GAN condicional se diferencia de la GAN en que la cantidad de parámetros recibidos por su Generador y Discriminador es diferente. El generador no solo recibe variables aleatorias, sino que también recibe un "vector de pensamiento", que puede ser la codificación de una oración. En este momento, la estructura de nuestro Generador se convierte en una red que ingresa dos vectores y genera una imagen.

Por ejemplo, en la imagen de arriba, convertimos la oración ojos rojos en un vector y se la damos al Generador, y luego dejamos que genere una imagen anime de ojos rojos. Al modificar x, podemos obtener imágenes diferentes y, debido a la existencia de la variable aleatoria z, podemos obtener imágenes diferentes incluso si damos la misma x.

Para que la red aprenda la relación entre texto y descripción, necesitamos preparar un conjunto de datos de esta combinación (descripción de texto-imagen).

3.2 Discriminador

Discriminador también necesita ingresar dos vectores, a saber, la imagen generada por el Generador y la entrada x al Generador, y luego si la salida es correcta.

Los datos de entrenamiento enviados al Generador deben tener (descripción correcta - imagen correcta) como categoría 1, (descripción correcta, imagen incorrecta), (descripción correcta, imagen correcta, pero la imagen y la descripción no coinciden) como categoría 0.

Sin incluir (descripción correcta, imagen correcta, pero la imagen y la descripción no coinciden) como datos de entrenamiento, nuestra red no obtendrá buenos resultados.

Después de conocer las redes Generador y Discriminador, podemos usar un método similar a GAN para entrenar, y el Generador final es nuestro pintor de IA. Le damos una descripción de texto y nos devuelve la imagen correspondiente.

四、Difusión estable

La difusión estable y la GAN condicional tienen muchas similitudes, porque ambas se pueden usar para resolver problemas de texto a imagen, por lo que ambos modelos reciben texto y ruido gaussiano que afecta la imagen. Es solo que las estructuras de red utilizadas son diferentes y Stable Diffusion introduce Latent Diffusion para que el entrenamiento sea más fluido.

Latent Diffusion consta de tres partes, a saber, autoencoder, U-Net y Text-Encoder.

El codificador automático consta de dos partes: codificador y decodificador. La salida del codificador se entregará a U-Net para su procesamiento. La salida de U-Net se entregará al decodificador.

U-Net recibe la entrada del codificador y también recibe un vector de oración. Este vector de oración lo proporciona Text-Encoder. La siguiente figura es la estructura de U-Net.

Debido a que U-Net funciona en un espacio de baja dimensión, la difusión latente es rápida y eficaz. El proceso general de Difusión Estable es el siguiente:

5. Experiencia Kunlun Wanwei-Tiangong Qiaohua

Hay muchas plataformas listas para usar para pintar con IA. En comparación con GAN, Stable Diffusion es mejor para pintar. Aquí puede usar SkyPaint de Kunlun Tiangong para una experiencia simple. SkyPaint utiliza el primero del mundo. El modelo de rama multilingüe de Stable Diffusion es uno de los pocos. Modelos de generación de texto e imágenes en China que admiten bilingües en chino e inglés.

El modelo de pintura Kunlun Wanwei AI adopta principalmente las siguientes estrategias durante el proceso de capacitación del modelo:

• Si bien aumenta la capacidad de ingresar palabras de aviso en chino, también es compatible con el modelo de palabras de aviso en inglés original stable_diffusion. Los manuales de palabras de aviso en inglés acumulados por usuarios anteriores aún se pueden usar en el modelo;
• El uso de 150 millones de niveles de corpus paralelos para optimizar el modelo de palabras clave para lograr la comparación entre chino e inglés no solo implica un corpus de tareas de traducción, sino que también incluye materiales en chino e inglés para palabras clave que los usuarios utilizan con frecuencia, materiales en chino e inglés. para poemas antiguos, subtítulos, enciclopedias y textos ilustrados. Una colección masiva de corpus de múltiples escenarios y tareas, como corpus de descripción;
• Durante el entrenamiento, se utilizan un esquema de destilación de modelos y un esquema de alineación bilingüe. El modelo del maestro se utiliza para destilar el modelo del estudiante y se complementa con una tarea de alineación del lenguaje del decodificador para ayudar en el entrenamiento del modelo.

Tanto en aplicaciones de generación de imágenes como de texto que generan imágenes, el modelo Tiangong Qiaohui SkyPaint de Kunlun Tiangong es comparable a los modelos más avanzados en el campo de la pintura con IA. La siguiente tabla compara el rendimiento de diferentes modelos en el conjunto de datos Flickr30K-CN.

A continuación se muestran algunos ejemplos de prueba.

1. El Gato con Sombrero y Espada.
   Mi idea original era obtener una imagen similar al Gato con Botas. Los siguientes resultados tienen algo de sabor al Gato con Botas.

2. La noche estrellada de Van Gogh

La primera representación es algo similar a la escena original, mientras que las pinturas restantes son diferentes.

3. Un helicóptero rojo despega de las montañas nevadas de Alaska que nunca se han derretido en miles de años.

La descripción esta vez contiene muchos detalles, el helicóptero rojo, el despegue, etc. De los resultados a continuación se puede ver que la IA ha captado estos detalles y no hay mucha sensación de inconsistencia en cada imagen, pero todavía hay algunos puntos de insatisfacción al observar de cerca la hélice.

Puedes probar el efecto del dibujo de IA tú mismo.

6. Resumen y perspectivas

La pintura de IA no se copia simplemente de la implementación de GAN condicional. Al entrenar GAN condicional, aprendemos la distribución de imágenes mientras lo hacemos. Para una imagen de 8 bits de 64 × 64 × 3, puede haber 12288 ^ 256 combinaciones, y solo una parte muy pequeña de estas combinaciones son las imágenes que necesitamos. La red del Generador cambia z de una distribución simple (como la distribución gaussiana). ), mapea una distribución compleja (la distribución de imágenes). Después de aprender esta distribución, solo necesitamos muestrear un punto de la distribución de z para que corresponda a una imagen. Esto es lo que está haciendo nuestro Generador.
Afortunadamente, basándose en su juicio prospectivo sobre la tecnología de inteligencia artificial, Kunlun Wanwei comenzó a implementar el campo AIGC en 2020, capacitó grupos de 200 tarjetas, invirtió decenas de millones de yuanes y formó un equipo de I + D de más de 200 personas. A finales de 2020, en abril de 2021, se desarrolló un modelo chino GPT-3 con decenas de miles de millones de parámetros, y en agosto de 2021, comenzó a desarrollar un robot de conversación basado en su propio modelo de texto grande; en enero de 2022, SkyMusic El laboratorio de música se lanzó y se alcanzó en abril de 2022. Los mejores resultados en el campo de la inteligencia artificial; los productos AIGC en programación, imágenes y direcciones de texto se lanzarán en septiembre de 2022. Vale la pena mencionar que los modelos actuales de imagen de IA, texto de IA y programación de IA son de código abierto en GitHub.

Enlace al sitio web oficial, salto de experiencia: http://www.kunlun.com/Kunlun
Tiangong Dirección de código abierto:
Github: https://github.com/SkyWorkAIGCHuggingface https://huggingface.co/SkyWork
Huggingface: https://huggingface .co/SkyWork
Sitios web relacionados:
SkyPaint:
https://sky-paint.singularity-ai.com
SkyCode:
https://sky-code.singularity-ai.com
SkyText:
https://openapi.singularity-ai.com
Podemos creer que a través de la innovación tecnológica y el desarrollo de los algoritmos modelo AIGC, el desarrollo del algoritmo AIGC de código abierto y la comunidad modelo se volverá cada vez más fuerte, y el umbral de uso y aprendizaje de la tecnología AIGC en diversas industrias también disminuirá gradualmente y Llegará una nueva era perteneciente a AIGC.