In letzter Zeit ist das Deep-Generation-System, das sogenannte GAN, heiß. Ich probiere auch verschiedene Dinge aus und spiele. Die Bibliothek ist intuitiv und leicht zu verstehen.
Übrigens können gewöhnliches DCGAN und Wasserstein GAN auch mit Keras schnell implementiert und erlernt werden, aber wenn es um diejenigen geht, die geringfügige Verbesserungen wie die Fehleroptimierung vorgenommen haben: "Wie schreiben Sie dies in Keras? ,,? ”Ich denke, es kann passieren. Ich habe dies mit der in Verbessertes Training von Wasserstein-GANs vorgeschlagenen Implementierung der Gradientenstrafe getan. Ich werde die Erklärung der Gradientenstrafe weglassen, aber ich denke, es wäre gut, wenn das Modell in Keras definiert und das Lernen in TensorFlow durchgeführt würde. Ich dachte, ich habe es geschafft, dies mit normalem Wasserstein GAN gut zu lernen, also würde ich gerne einen Artikel schreiben. Ich bin froh, wenn Sie es als Referenz verwenden können. Platzieren Sie den Code unter hier.
Generator und Diskriminator werden von Keras geschrieben. Es ist einfach. (Siehe model.py) Der Generator verwendet Deconvolution (Filtergröße 4 * 4, Schritt 2 * 2), um zufällige Eingaben in ein Bild umzuwandeln. Der Diskriminator gibt den Funktionswert aus dem Eingabebild durch Faltung aus (Filtergröße 4 * 4, Schritt 2 * 2). Ich habe es in Keras 'Functional API Model geschrieben, aber es sollte kein Problem mit dem Sequential Model geben (Schreibmethode, die mit model.add verbunden ist).
In Wasserstein GAN übernimmt Discriminator die Ausgabe von Funktionswerten, anstatt die Authentizität des Eingabebilds zu bestimmen.
\max_{D} \min_{G} \mathbb{E}_{x\sim p(x)}D(x) - \mathbb{E}_{z \sim p(z)}D(G(z))
Dies macht das Gradientenlernen stabiler als das ursprüngliche GAN, wodurch die Jensen-Shannon-Divergenz minimiert wird. Weitere Informationen finden Sie im Originalpapier (https://arxiv.org/abs/1701.07875) und in anderen Kommentaren. Bitte gib mir.
Geben Sie im Fall von Keras normalerweise die vorbereitete oder von Ihnen und model.compile definierte Verlustfunktion an. In diesem Artikel wird diese Optimierung jedoch von TensorFlow durchgeführt.
main.py
class WassersteinGAN:
def __init__(self, ...):
self.image_size = 64
self.gen = generator # model.Generator in py definiert
self.disc = discriminator # model.Diskriminator in py definiert
#Das Eingabebild und die Eingabezufallszahl werden durch Platzhalter definiert.
self.x = tf.placeholder(tf.float32, (None, self.image_size, self.image_size, 3), name = 'x') #Echtes Bild
self.z = tf.placeholder(tf.float32, (None, 100), name = 'z') #Zufallszahl eingeben
self.x_ = self.gen(self.z) #Gefälschtes Bild<-Zufallszahl eingeben
self.d = self.disc(self.x) #Ausgabe mit echtem Bild als Eingabe
self.d_ = self.disc(self.x_) #Ausgabe mit gefälschtem Bild als Eingabe
self.d_loss = -(tf.reduce_mean(self.d) - tf.reduce_mean(self.d_)) #Diskriminator Zielfunktion
self.g_loss = -tf.reduce_mean(self.d_) #Generatorzielfunktion
#Optimierer einstellen. Die Lernrate des Generators ist etwas kleiner eingestellt.
self.d_opt = tf.train.RMSPropOptimizer(learning_rate = 5e-5)\
.minimize(self.d_loss, var_list = self.disc.trainable_weights)
self.g_opt = tf.train.RMSPropOptimizer(learning_rate = 1e-5)\
.minimize(self.g_loss, var_list = self.gen.trainable_weights)
#Legen Sie die Sitzung von TensorFlow fest.
self.sess = tf.Session()
K.set_session(self.sess) #← In Kombination mit Keras erscheint dies erforderlich
def train(self, ...):
Unter diesen Einstellungen werden wir die Daten tatsächlich fließen lassen und lernen.
In meinem Code eine Klasse zum Abrufen von Eingabebildern und Eingabe von Zufallszahlen (misc / dataIO.py, InputSampler ) Wurde gemacht, Der im folgenden Code angezeigte Sampler ist eine Instanz dieses InputSamplers. Die image_sample-Methode gibt einen Mini-Stapel realer Bilder zurück, und die Noise_sample-Methode gibt einen Mini-Stapel von Eingabe-Zufallszahlen zurück. Die Nachlademethode ist eine Methode zum Teilen und Halten einer großen Anzahl von Bildern von Trainingsdaten. (Da der häufig verwendete Gesichtsbilddatensatz CelebA mehr als 200.000 Bilder enthält, haben wir diese Spezifikation zur Vereinfachung des Speichers erstellt.)
Wenn das von Keras implementierte Modell die Stapelnormalisierung enthält, muss beim Datenfluss K.learning_phase () festgelegt werden. Einschließlich dessen wird es im folgenden Code beschrieben.
main.py
class WassersteinGAN:
def __init__(self, ...):
# --Abkürzung--
def train(self, ...):
for e in range(epochs):
for batch in range(num_batches):
#Diskriminator lernt viel
for _ in range(5):
#Gewichtsbeschneidung zur Gewährleistung der Lipsitz-Kontinuität
d_weights = [np.clip(w, -0.01, 0.01) for w in self.disc.get_weights()]
self.disc.set_weights(d_weights)
#Mini-Stapel von echten Bildern
bx = sampler.image_sample(batch_size)
#Mini-Stapel von Eingabe-Zufallszahlen
bz = sampler.noise_sample(batch_size)
#Eingabe und K, um zum Platzhalter zu fließen.learning_phase()Diskriminator durch Angabe lernen
self.sess.run(self.d_opt, feed_dict = {self.x: bx, self.z: bz,
K.learning_phase(): 1})
bz = sampler.noise_sample(batch_size, self.z_dim)
#Eingabe und K, um zum Platzhalter zu fließen.learning_phase()Generator durch Angabe lernen
self.sess.run(self.g_opt, feed_dict = {self.z: bz,
K.learning_phase(): 1})
#Bei der Ausgabe von Verlust
d_loss, g_loss = self.sess.run([self.d_loss, self.g_loss],
feed_dict = {self.x: bx, self.z: bz,
K.learning_phase(): 1})
print('epoch : {}, batch : {}, d_loss : {}, g_loss : {}'\
.format(e, batch, d_loss, g_loss))
~~ Da das Modell in Keras beschrieben ist, können Parameter durch die Keras-Formel gespeichert werden. Ich rette oft jede Epoche. ~~
~~ * Wenn Sie versuchen, das Modell in einer TensorFlow-Sitzung auf Keras-Weise zu speichern, funktioniert es möglicherweise nicht. bestätigen. ~~
Modellparameter können mit dem Keras-Ausdruck `model.save_weights ()` gespeichert werden. Sie können gespeicherte Parameter auch mit `model.load_weights ()` laden.
`tf.Session ()` verschoben werden müssen.main.py
class WassersteinGAN:
def __init__(self, ...):
# --Abkürzung--
def train(self, ...):
for e in range(epochs):
for batch in range(num_batches):
# --Abkürzung--
#Parameter können auf Keras-Weise gespeichert werden
self.gen.save_weights('path/to/g_{}epoch.h5'.format(e))
self.disc.save_weights('path/to/d_{}epoch.h5'.format(e))
Das hat mich ziemlich gut unterrichtet, aber das erzeugte Bild war etwas verschwommen. Im Allgemeinen scheint Wasserstein GAN ein wenig verschwommen zu sein als DCGAN, aber ich bin der Meinung, dass es je nach Einstellung wie Lernrate wunderbar generiert werden kann.
Auf diese Weise konnte ich mit Keras ein Modell bauen und mit TensorFlow trainieren. In letzter Zeit habe ich das Gefühl, dass viele Methoden mit ausgefeilter Optimierung vorgeschlagen wurden, und ich hoffe, dass sie bei den Folgetests hilfreich sein werden. Bitte zögern Sie nicht, uns zu kontaktieren, wenn Sie Vorschläge oder Verbesserungen haben.
Ich habe den Code geschrieben, um mit Keras und Tensorflow auf die gleiche Weise mit einem einfachen CNN zu lernen. Wenn Sie GAN mögen, ist hier leicht zu verstehen.
Recommended Posts