参考
- GAN 在NLP中应用：https://www.jianshu.com/p/54afd578b8a3
- GAN 原理浅析：http://www.sohu.com/a/121189842_465975 https://www.jianshu.com/p/edbcf96ca3c9
- GAN 论文整理：https://www.jianshu.com/p/2acb804dd811
- 机器之心：GAN论文以及GitHub地址
生成对抗网络（Generative Adversarial Networks）
https://arxiv.org/abs/1406.2661)
https://github.com/uclaacmai/Generative-Adversarial-Network-TutorialDCGAN:
https://arxiv.org/abs/1511.06434
Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks
TL; DR：一系列改进以前 DCGAN 的技术。比如，这个改进的基准允许生成更好的高分辨率图像。Wasserstein GAN
https://arxiv.org/abs/1701.07875
简单GAN实现
- 利用GAN生成图片，曲线（pytorch）， minst（tensorflow）。
pytorch(莫凡大神课程)
# -*- coding: utf-8 -*-
# @Time : 2018/10/14 22:42
# @Author : kean
# @Email :
# @File : gan_morvan.py
# @Software: PyCharm
"""
View more, visit my tutorial page: https://morvanzhou.github.io/tutorials/
My Youtube Channel: https://www.youtube.com/user/MorvanZhou
Dependencies:
torch: 0.4
numpy
matplotlib
"""
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
# torch.manual_seed(1) # reproducible
# np.random.seed(1)
# Hyper Parameters
BATCH_SIZE = 64
LR_G = 0.0001 # learning rate for generator
LR_D = 0.0001 # learning rate for discriminator
N_IDEAS = 5 # think of this as number of ideas for generating an art work (Generator)
ART_COMPONENTS = 15 # it could be total point G can draw in the canvas
PAINT_POINTS = np.vstack([np.linspace(-1, 1, ART_COMPONENTS) for _ in range(BATCH_SIZE)])
# show our beautiful painting range
# plt.plot(PAINT_POINTS[0], 2 * np.power(PAINT_POINTS[0], 2) + 1, c='#74BCFF', lw=3, label='upper bound')
# plt.plot(PAINT_POINTS[0], 1 * np.power(PAINT_POINTS[0], 2) + 0, c='#FF9359', lw=3, label='lower bound')
# plt.legend(loc='upper right')
# plt.show()
def artist_works(): # painting from the famous artist (real target)
a = np.random.uniform(1, 2, size=BATCH_SIZE)[:, np.newaxis]
paintings = a * np.power(PAINT_POINTS, 2) + (a-1)
paintings = torch.from_numpy(paintings).float()
return paintings
G = nn.Sequential( # Generator
nn.Linear(N_IDEAS, 128), # random ideas (could from normal distribution)
nn.ReLU(),
nn.Linear(128, ART_COMPONENTS), # making a painting from these random ideas
)
D = nn.Sequential( # Discriminator
nn.Linear(ART_COMPONENTS, 128), # receive art work either from the famous artist or a newbie like G
nn.ReLU(),
nn.Linear(128, 1),
nn.Sigmoid(), # tell the probability that the art work is made by artist
)
opt_D = torch.optim.Adam(D.parameters(), lr=LR_D)
opt_G = torch.optim.Adam(G.parameters(), lr=LR_G)
plt.ion() # something about continuous plotting
for step in range(10000):
artist_paintings = artist_works() # real painting from artist
G_ideas = torch.randn(BATCH_SIZE, N_IDEAS) # random ideas
G_paintings = G(G_ideas) # fake painting from G (random ideas)
prob_artist0 = D(artist_paintings) # D try to increase this prob
prob_artist1 = D(G_paintings) # D try to reduce this prob
D_loss = - torch.mean(torch.log(prob_artist0) + torch.log(1. - prob_artist1))
G_loss = torch.mean(torch.log(1. - prob_artist1))
opt_D.zero_grad()
D_loss.backward(retain_graph=True) # reusing computational graph
opt_D.step()
opt_G.zero_grad()
G_loss.backward()
opt_G.step()
if step % 50 == 0: # plotting
plt.cla()
plt.plot(PAINT_POINTS[0], G_paintings.data.numpy()[0], c='#4AD631', lw=3, label='Generated painting',)
plt.plot(PAINT_POINTS[0], 2 * np.power(PAINT_POINTS[0], 2) + 1, c='#74BCFF', lw=3, label='upper bound')
plt.plot(PAINT_POINTS[0], 1 * np.power(PAINT_POINTS[0], 2) + 0, c='#FF9359', lw=3, label='lower bound')
plt.text(-.5, 2.3, 'D accuracy=%.2f (0.5 for D to converge)' % prob_artist0.data.numpy().mean(), fontdict={'size': 13})
plt.text(-.5, 2, 'D score= %.2f (-1.38 for G to converge)' % -D_loss.data.numpy(), fontdict={'size': 13})
plt.ylim((0, 3))
plt.legend(loc='upper right', fontsize=10)
plt.draw()
plt.pause(0.01)
plt.ioff()
plt.show()
tensorflow（错误之处帮忙指出）
# -*- coding: utf-8 -*-
# @Time : 2018/10/27 17:18
# @Author : kean
# @Email :
# @File : simple_gan.py
# @Software: PyCharm
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import os
mnist = input_data.read_data_sets("D:/data/minst/", one_hot=True)
class Net:
def __init__(self):
# discrininator
# real input
self.x_input = tf.placeholder(shape=[None, 784], dtype=tf.float32, name="x_input")
# input_layer
self.d_input_weight, self.d_input_bias = self.init(shape=[784, 128], name="d_input")
# hidden 1
self.d_h1_weight, self.d_h1_bias = self.init(shape=[128, 1], name="d_h1") # full connection layer
# generator
# fake idea
self.idea = tf.placeholder(shape=[None, 10], dtype=tf.float32, name="idea")
self.g_input_weight, self.g_input_bias = self.init(shape=[10, 128], name="g_input")
self.g_h1_weight, self.g_h1_bias = self.init(shape=[128, 784], name="g_h1")
# optimazer
self.fake = self.generator()
self.d_loss, self.g_loss = self.loss()
self.d_optimazer = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(self.d_loss)
self.g_optimazer = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(self.g_loss)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
self.sess = sess
def generator(self):
g_h1_accept = tf.nn.relu(tf.matmul(self.idea, self.g_input_weight) + self.g_input_bias, name="g_h1_accept")
# print("g_input_weight", self.g_input_weight)
# print("g_input_bias", self.g_input_bias)
# print("g_h1_accept", g_h1_accept)
fake = tf.nn.sigmoid(tf.matmul(g_h1_accept, self.g_h1_weight) + self.g_h1_bias, name="fake")
# print("fake", fake)
return fake
def disciminator(self, x_input):
"""
:return: 0-1
"""
d_h1_accept = tf.nn.relu(tf.matmul(x_input, self.d_input_weight) + self.d_input_bias)
logits = tf.matmul(d_h1_accept, self.d_h1_weight) + self.d_h1_bias
scores = tf.nn.sigmoid(logits)
return scores, logits
def loss(self):
real_scores, real_logits = self.disciminator(self.x_input)
fake_scores, fake_logits = self.disciminator(self.fake)
# 尽可能区分真伪，real_scores->1,fake_scores->0, optimazer.min
d_loss = - tf.reduce_mean(tf.math.log(tf.clip_by_value(real_scores, 1e-8, 1)) +
tf.math.log(tf.clip_by_value(1 - fake_scores, 1e-8, 1)), name="d_loss")
# 尽可能让判别器错误， fake_scores越接近1越好，optimazer.min
g_loss = - tf.reduce_mean(tf.math.log(tf.clip_by_value(fake_scores, 1e-8, 1)), name="g_loss")
return d_loss, g_loss
def train(self, num_show=2000, batch_size=64):
count = 1
while True:
batch, _ = mnist.train.next_batch(batch_size)
idea = np.random.randn(batch_size, 10)
_, d_loss = self.sess.run([self.d_optimazer, self.d_loss],
feed_dict={self.x_input: batch, self.idea: idea}
)
_, g_loss = self.sess.run([self.g_optimazer, self.g_loss],
feed_dict={self.idea: idea}
)
if count % num_show == 0:
print("%d loss: (%.5f, %.5f)" % (count, d_loss, g_loss))
fake = self.sess.run([self.fake], {self.idea: np.random.randn(1, 10)})
fig = self.plot(fake)
fig.show()
plt.pause(1)
plt.close()
count += 1
def init(self, shape, name):
weight = tf.Variable(initial_value=tf.random_uniform(shape=shape, minval=-1, maxval=1), name=name + "_weight")
bias = tf.Variable(initial_value=tf.zeros(shape=[1, shape[-1]]), dtype=tf.float32, name=name + "_bias")
return weight, bias
def plot(self, samples):
fig = plt.figure(figsize=(4, 4))
gs = gridspec.GridSpec(4, 4)
gs.update(wspace=0.05, hspace=0.05)
for i, sample in enumerate(samples):
ax = plt.subplot(gs[i])
plt.axis('off')
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_aspect('equal')
plt.imshow(sample.reshape(28, 28), cmap='Greys_r')
return fig
if __name__ == '__main__':
net = Net()
net.train(num_show=1000)