Exemples connus : principalement de la génération d’images de haute qualité

Generative adversarial networks (gan)

2 octobre 2020

Yann LeCun

“Generative Adversarial Network : the most interesting idea in the last ten years in machine learning”

Exemples connus : principalement de la génération d’images de haute qualité

Génération automatique de visages humains ...

Ou d’autres choses [LISIC].

Deepfake (Obama speech, Home alone avec Stallone).

En art : Vente d’une oeuvre 432k€ (2018).

Jeux vidéo : amélioration de textures basses résolutions.

...

Référence

Ian Goodfellow, 2016 (NIPS) : [paper]

Les GANs

Principe

Définition

Deux réseaux de neurones sont placés en compétition. Le premier, le générateur va essayer de générer un échantillon. Le second, le discriminateur va essayer de deviner si l’exemple qu’il reçoit est réel ou s’il est générer par le générateur.

Difficulté

Convergence lente et parfois compliquée.

Les GANs

Principe

[source]

Les GANs

Exemple

Generateur

.. .

.. . I₁

I2

I_n

O1

=⇒

Discriminateur

.. .

.. . I1

I₂

I_n

O1

=⇒

NO !

Les GANs

Exemple

Generateur

.. .

.. . I₁

I2

I_n

O1

=⇒

Discriminateur

.. .

.. . I1

I₂

I_n

O1

=⇒

NO !

Les GANs

Exemple

Generateur

.. .

.. . I₁

I2

I_n

O1

=⇒

Discriminateur

.. .

.. . I1

I₂

I_n

O1

=⇒

YES !

Génération d’une fonction cosinus

Définition du problème

Génération d’une fonction cosinus en 1D.

Espace de points : (-5,5).

Utilisation de la bibliothèque Keras.

Simple définition de la fonction d’évaluation avec numpy def evaluate(x):

return np.cos(x)

Génération des données

def plot_points(real, fake):

plt.scatter(real[:,0], real[:,1], color='blue')

plt.scatter(fake[:,0], fake[:,1], color='red')

plt.legend(['real points', 'fake points'])

plt.show()

Visualition des données générées

def create_discriminator(intput_size=2):

model = Sequential()

model.add(Dense(15, activation='relu',

input_dim = intput_size)) model.add(Dense(5, activation='relu'))

model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy',

optimizer='adam',

metrics=['accuracy'])

return model

Visualition des données générées

Création du discriminateur

Le discriminateur

En entrée : un vecteur de 2 éléments

En sortie : une prédiction de classification (échantillon réel ou faux)

Le réseau :

Une couche dense d’entrée de 15 neurones, fonction d’activation relu.

Une couche dense cachée de 5 neurones, fonction d’activation relu.

Une couche dense de sortie de 1 neurone, fonction d’activation sigmoid.

Optimizer : adam.

Fonction de perte : binary crossentropy.

Création du discriminateur

def create_discriminator(intput_size=2):

model = Sequential()

model.add(Dense(15, activation='relu',

input_dim = intput_size)) model.add(Dense(5, activation='relu'))

model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy',

optimizer='adam',

metrics=['accuracy'])

return model

Une parenthèse : apprentissage du discriminateur

Pour vérifier le bon fonctionnement de notre disciminateur on peut lancer un entrainement.

La moitié des données sont des échantillons faux, l’autre des réels (de la fonction cosinus).

Comme on veut faire simple, laissons tous les paramètres par

défaut.

Une parenthèse : apprentissage du discriminateur

def generate_real_points(n=100):

x = np.random.uniform(-5, 5, n)

x = x.reshape(n, 1) # shape(n,) --> shape(n, 1) x2 = evaluate(x)

# stacking the data et labeling as real points return np.hstack((x, x2)), np.ones((n, 1))

def generate_fake_points(n=100):

x = np.random.uniform(-10, 10, n) x2 = np.random.uniform(-10, 10, n)

x = x.reshape(n, 1) # shape(n,) --> shape(n, 1) x2 = x2.reshape(n, 1) # shape(n,) --> shape(n, 1)

# stacking the data et labeling as fake points

return np.hstack((x, x2)), np.zeros((n, 1))

Une parenthèse : apprentissage du discriminateur

Création du générateur

Le générateur

En entrée : le générateur prend un point de l’espace latent.

L’espace latent est un espace 5D de variables aléatoires gaussiennes.

En sortie : un vecteur de 2 éléments.

Le réseau :

Une couche dense d’entrée de 15 neurones, fonction d’activation relu.

Une couche dense cachée de 5 neurones, fonction d’activation relu.

Une couche dense de sortie de 1 neurone, fonction d’activation linear.

Optimizer : adam.

Fonction de perte : binary crossentropy.

Création du générateur

def create_generator(latent_space_dim=5, n_outputs=2):

model = Sequential()

model.add(Dense(15, activation='relu',

input_dim=latent_space_dim)) model.add(Dense(5, activation='relu'))

model.add(Dense(n_outputs, activation='linear')) return model

def generate_latent_points(latent_dim=5, n=100):

x_input = np.random.normal(0, 1, latent_dim*n)

x_input = x_input.reshape(n, latent_dim)

return x_input

Création du générateur

def generate_fake_samples(generator, latent_dim=5, n=100):

x_input = generate_latent_points(latent_dim, n) X = generator.predict(x_input)

y = np.zeros((n,1))

return X, y

Générateur sans apprentissage

Création du gan

def create_gan(generator, discriminator):

discriminator.trainable = False

# Le discriminateur est seulement utilisé

# pour distinguer le vrai du faux model = Sequential()

model.add(generator) model.add(discriminator)

model.compile(loss='binary_crossentropy', optimizer='adam')

return model

Création du gan

def create_gan(generator, discriminator):

discriminator.trainable = False

# Le discriminateur est seulement utilisé

# pour distinguer le vrai du faux model = Sequential()

model.add(generator) model.add(discriminator)

model.compile(loss='binary_crossentropy', optimizer='adam')

return model

Entrainement du gan

def train_gan(generator, discriminator, gan, latent_dim=5, n_epochs=30000, n_batch=256, n_eval=1000):

for i in range(n_epochs):

X_real, y_real = generate_real_points(n_batch//2) X_fake, y_fake = generate_fake_samples(generator,

latent_dim, n_batch//2) discriminator.train_on_batch(X_real, y_real) discriminator.train_on_batch(X_fake, y_fake)

x_gan = generate_latent_points(latent_dim, n_batch) y_gan = np.ones((n_batch, 1))

gan.train_on_batch(x_gan, y_gan) if (i % n_eval == 0):

summarize_performances(i, generator,

discriminator, latent_dim)

def summarize_performances(epoch, generator, discriminator, latent_dim=5, n_points=100):

X_real, y_real = generate_real_points(n_points) X_fake, y_fake = generate_fake_samples(generator,

latent_dim, n_points)

_, acc_real = discriminator.evaluate(X_real, y_real) _, acc_fake = discriminator.evaluate(X_fake, y_fake) print('Epoch {}, fakeAcc {}, realAcc {}'.format(epoch,

acc_fake, acc_real))

plt.scatter(X_real[:,0], X_real[:,1], color='blue') plt.scatter(X_fake[:,0], X_fake[:,1], color='red') plt.legend(['Real points', 'Fake points'])

filename = '../images/generated/cos{}_'.format(epoch) plt.savefig(filename)

plt.show()

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Résultats de notre simple réseau

Générer une image

Que faut-il changer dans notre code Chargement des données :

Commnencez par charger la base de données pour ne garder que des images d’un même digit (peu importe lequel).

Ré-écrire la fonction generate_real_samples afin de sélectionner au hasard un certain nombre d’images.

Changer la dimension de l’espace latent (100).

Discriminateur :

Changer la taille de l’input.

Rajouter une couche Flatten.