Keras로 GAN을 사용하여 추상 미술 생성

기계 내에서 창의성을 불러 일으키려는 시도

Unsplash에 Steve Johnson의 사진

인공 지능이 극복해야 할 가장 큰 장애물은 창의력을 발휘하는 것입니다. 그래디언트 기반 최적화를 사용하여 문제를 해결하거나 임베딩 및 워드 웹을 사용하여 자연어 처리 문제를 해결하는 것은 상당히 간단합니다. 진정한 어려움은 AI가 독창적이고 독창적 인 콘텐츠를 만드는 것입니다.

이 기사에서는 추상 미술을 생성하기 위해 GAN을 훈련 시키려고합니다. GAN을 훈련시키기 위해 사실적인 예술 작품을 사용하지 않은 이유는 컴퓨터가 진정으로 독창적 인 사실적인 예술을 만들기 위해 실제 세계와 그들이 어떻게 상호 작용하는지에 대해 배울 필요가 있다는 사실 때문입니다.

GAN은 무엇입니까?

General Adversarial Networks (줄여서 GAN)는 생성 적 기계 학습을위한 일종의 신경망입니다. 그들은 공급되는 것과 유사하지만 동일하지는 않은 콘텐츠를 정확하게 재현 할 수 있습니다.

GAN은 어떻게 작동합니까?

GAN은 생성기와 판별 기의 두 부분으로 구성됩니다.

생성기는 임의의 값을 받아 이미지를 형성하기 위해 재구성 할 수있는 긴 픽셀 값 배열을 반환하는 신경망입니다. 판별자는 "실제"이미지와 "가짜"이미지를 비교하고 실제 이미지인지 가짜인지 추측하는 또 다른 별도의 신경망입니다.

GAN의 적대적인 부분은 이들이 함께 작동하고 서로에게 공급하는 방식입니다. GAN을 훈련 할 때 생성자의 손실 값은 판별자가 얼마나 정확한지입니다. 판별 기가 더 나쁠수록 생성기가 더 잘 수행됩니다. 반면, 판별 기의 손실 값은 예측의 정확성을 기반으로합니다.

이것은 두 신경망이 서로 경쟁하고 있음을 의미합니다. 하나는 다른 하나를 속이려고하고 다른 하나는 속지 않으려 고합니다.

GAN의 장점 :

  • 비지도 학습
  • 매우 적용 가능

GAN의 단점 :

  • 긴 계산 시간
  • 붕괴 가능성
  • 모델을 평가하는 진정한 방법이 없음

이제 GAN이 이론적으로 어떻게 작동해야하는지에 대한 기본적인 이해를 했으므로 코드를 살펴 보겠습니다.

암호:

이 프로젝트의 데이터 세트는 여기 에서 찾을 수 있습니다 . 이 코드는 GAN에 대한 Jason Brownlee 박사의 게시물에서 영감 을 받았습니다 .

1 단계 | 전제 조건 :

from numpy import expand_dims
from numpy import zeros
from numpy import ones
from numpy import vstack
from numpy.random import randn
from numpy.random import randint
from keras.datasets.mnist import load_data
from keras.optimizers import Adam
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Reshape
from keras.layers import Flatten
from keras.layers import Conv2D
from keras.layers import Conv2DTranspose
from keras.layers import LeakyReLU
from keras.layers import Dropout
from matplotlib import pyplot
from IPython.display import clear_output

2 단계 | 데이터 준비 :

import os
from PIL import Image
from matplotlib import pyplot as plt 
import numpy as np
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
def inv_sigmoid(x):
    return np.log(y/(1-y))
%matplotlib inline
path = 'XXXXXXXXXXX'
os.getcwd()
img_list = os.listdir(path)
def access_images(img_list,path,length):
    pixels = []
    imgs = []
    for i in range(length):
        img = Image.open(path+'\\'+img_list[i],'r')
        basewidth = 100
        img = img.resize((basewidth,basewidth), Image.ANTIALIAS)
        pix = np.array(img.getdata())
        pixels.append(pix.reshape(100,100,3))
        imgs.append(img)
    return np.array(pixels),imgs
def show_image(pix_list):
    array = np.array(pix_list.reshape(100,100,3), dtype=np.uint8)
    new_image = Image.fromarray(array)
    new_image.show()
pixels,imgs = access_images(img_list,path,1000)
pixels.shape

3 단계 | 판별 자 정의 :

def define_discriminator(in_shape = (100,100,3)):
    model = Sequential()
    model.add(Conv2D(64, (3,3), strides=(2, 2), padding='same', input_shape=in_shape))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.4))
    model.add(Conv2D(64, (3,3), strides=(2, 2), padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.4))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    opt = Adam(lr=0.0002, beta_1=0.5)
    model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
    return model

4 단계 | 생성기 정의 :

def define_generator(latent_dim):
    model = Sequential()
    n_nodes = 128 * 25 * 25
    model.add(Dense(n_nodes, input_dim=latent_dim))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Reshape((25, 25, 128)))
    model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Conv2DTranspose(128, (4,4), strides=(2,2), padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Conv2D(3, (7,7) , padding='same'))
    return model

5 단계 | GAN 정의 :

def define_gan(g_model, d_model):
    d_model.trainable = False
    model = Sequential()
    model.add(g_model)
    model.add(d_model)
    opt = Adam(lr=0.0002, beta_1=0.5)
    model.compile(loss='binary_crossentropy', optimizer=opt)
    return model

6 단계 | 부품 생성 :

def generate_real_samples(dataset, n_samples):
    ix = randint(0, dataset.shape[0], n_samples)
    X = dataset[ix]
    y = ones((n_samples, 1))
    return X, y
 
def generate_latent_points(latent_dim, n_samples):
    x_input = randn(latent_dim * n_samples)
    x_input = x_input.reshape(n_samples, latent_dim)
    return x_input
def generate_fake_samples(g_model, latent_dim, n_samples):
    x_input = generate_latent_points(latent_dim, n_samples)
    X = g_model.predict(x_input)
    y = zeros((n_samples, 1))
    return X, y

7 단계 | 기차:

def train(g_model, d_model, gan_model, dataset, latent_dim, n_epochs=100, n_batch=10):
    bat_per_epo = int(dataset.shape[0] / n_batch)
    print(dataset.shape[0])
    half_batch = int(n_batch / 2)
    for i in range(n_epochs):
        for j in range(bat_per_epo):
            X_real, y_real = generate_real_samples(dataset, half_batch)
            X_fake, y_fake = generate_fake_samples(g_model, latent_dim, half_batch)
            X, y = vstack((X_real, X_fake)), vstack((y_real, y_fake))
            d_loss, _ = d_model.train_on_batch(X, y)
            X_gan = generate_latent_points(latent_dim, n_batch)
            y_gan = ones((n_batch, 1))
            g_loss = gan_model.train_on_batch(X_gan, y_gan)
            print('>%d, %d/%d, d=%.3f, g=%.3f' % (i+1, j+1, bat_per_epo, d_loss, g_loss))
        if (i+1) % 10 == 0:
            summarize_performance(i, g_model, d_model, dataset, latent_dim)
            clear_output()

8 단계 | 성능 요약 :

def summarize_performance(epoch, g_model, d_model, dataset, latent_dim, n_samples=100):
    X_real, y_real = generate_real_samples(dataset, n_samples)
    _, acc_real = d_model.evaluate(X_real, y_real, verbose=0)
    x_fake, y_fake = generate_fake_samples(g_model, latent_dim, n_samples)
    _, acc_fake = d_model.evaluate(x_fake, y_fake, verbose=0)
    print('>Accuracy real: %.0f%%, fake: %.0f%%' % (acc_real*100, acc_fake*100))
    filename = 'generator_model_%03d.h5' % (epoch + 1)
    g_model.save(filename)

9 단계 | 프로그램 실행 :

latent_dim = 100
d_model = define_discriminator()
g_model = define_generator(latent_dim)
gan_model = define_gan(g_model, d_model)
print(pixels.shape)
train(g_model, d_model, gan_model, np.array(pixels), latent_dim)
print(pixels)

10 단계 | 이미지 생성 시각화 :

from keras.models import load_model
from numpy.random import randn
from matplotlib import pyplot
def generate_latent_points(latent_dim, n_samples):
    x_input = randn(latent_dim * n_samples)
    x_input = x_input.reshape(n_samples, latent_dim)
    return x_input
model = g_model
latent_points = generate_latent_points(100,1)
X = model.predict(latent_points)
array = np.array(X.reshape(100,100,3), dtype=np.uint8)
new_image = Image.fromarray(array)
new_image.show()
X

결론:

이 기사에서 무언가를 배웠기를 바랍니다. 이 프로젝트의 결과는 GAN을 제대로 훈련시킬 리소스가없고 데이터 세트가 상당히 작기 때문에 상당히 열악했습니다. 이 모델을 다른 데이터 세트 또는 응용 프로그램에 적용하면 만족스러운 결과를 얻을 수 있습니다!

제 기사를 읽어 주셔서 감사합니다!

Suggested posts

중요하지만 종종 간과되는 데이터 과학 및 분석 기술

중요하지만 종종 간과되는 데이터 과학 및 분석 기술

이제 데이터 과학 및 분석에 들어가는 데 필요한 기술 기술을 배울 수있는 방법이 그 어느 때보 다 많았습니다. 온라인 과정, Kaggle 대회, YouTube 자습서, 스택 오버플로가있는 금광 등이 있습니다. 현장에 침입하려는 사람들은 종종 "X 데이터 작업을 수행하려면 어떤 프로그래밍 기술이 필요한가요?", "어떤 기계 학습 기술을 배워야합니까?", "기술을 구축하려면 어떤 프로젝트를 수행해야합니까?"와 같은 질문을 자주합니다. / 포트폴리오?”.

데이터 포인트가 얼마나 극단적입니까?

특이 치 및 모델 선택

데이터 포인트가 얼마나 극단적입니까?

이상치 및 모델 선택 회귀를 실행할 수있는 것은 하나이지만 올바른 모델과 올바른 데이터를 선택할 수 있다는 것은 또 다른 문제입니다. 곡선의 맨 끝에있는 데이터 포인트가 실수로 여분의 제로 (인간 오류)를 기록한 사람 또는 블랙 스완 이벤트 (드물지만 중요한 이벤트)에서 가져온 것임을 어떻게 알 수 있습니까? 회귀 모델에 유지하면서 여전히 작동하는 예측을 가질 수 있습니까? 이 기사에서 알아 보자.

Related posts

데이터 과학을위한 필수 수학 : 기초 및 기초 변경

데이터 과학을위한 필수 수학 : 기초 및 기초 변경

고유 분해 및 SVD에 유용한 기저의 선형 대수 개념 이해이 기사에서는 고유 분해 또는 특이 값 분해 (SVD)와 같은 행렬 분해 방법을 이해하는 흥미로운 방법 인 기저 개념에 대해 알아 봅니다. 정의 기본은 벡터 공간 (벡터 집합)을 설명하는 데 사용되는 좌표계입니다.

판다와 에라스무스 연구 교환 분석

판다와 에라스무스 연구 교환 분석

Erasmus 프로그램 2011-12에서 발생한 20 만 개의 연구 교환으로 데이터 세트를 분석 한 결과 1987 년 이후 Erasmus 프로그램은 매년 수십만 명의 유럽 학생들에게 한 학기 또는 1 년을 해외에서 보낼 기회를 다른 유럽에서 보낼 수있는 기회를 제공합니다. 경제적 인 지원뿐만 아니라 쉬운 교환 과정을 제공합니다. 유럽의 다양한 사람, 언어 및 문화에 대한 마음과 마음을 열어주는 정말 귀중한 경험입니다.

데이터 과학을위한 8 가지 기본 통계 개념

… 평범한 영어로 설명

데이터 과학을위한 8 가지 기본 통계 개념

통계는 "수량 데이터의 수집, 분석, 해석 및 표현을 다루는 수학의 한 분야"입니다. 프로그래밍과 기계 학습을 혼합하면 데이터 과학의 핵심 기술에 대해 꽤 잘 설명 할 수 있습니다.

데이터 과학의 9 가지 거리 측정

일반적인 거리 측정의 장점과 함정

데이터 과학의 9 가지 거리 측정

감독되거나 감독되지 않는 많은 알고리즘은 거리 측정을 사용합니다. 유클리드 거리 또는 코사인 유사성과 같은 이러한 측정은 종종 k-NN, UMAP, HDBSCAN 등과 같은 알고리즘에서 찾을 수 있습니다.