update

Author: MorvanZhou

tutorial-contents/DQN.py renamed to tutorial-contents/405_DQN_reinforcement_learning.py

@@ -61,7 +61,7 @@ def artist_works():     # painting from the famous artist (real target)
 
 plt.ion()   # something about continuous plotting
 plt.show()
-for step in range(10000):
+for step in range(5000):
     artist_paintings = artist_works()           # real painting from artist
     G_ideas = np.random.randn(BATCH_SIZE, N_IDEAS)
     G_paintings, pa0, Dl = sess.run([G_out, prob_artist0, D_loss, train_D, train_G],    # train and get results

tutorial-contents/GAN.py renamed to tutorial-contents/406_GAN.py

@@ -0,0 +1,101 @@
+"""
+Know more, visit my Python tutorial page: https://morvanzhou.github.io/tutorials/
+My Youtube Channel: https://www.youtube.com/user/MorvanZhou
+
+Dependencies:
+tensorflow: 1.1.0
+matplotlib
+numpy
+"""
+import tensorflow as tf
+import numpy as np
+import matplotlib.pyplot as plt
+
+tf.set_random_seed(1)
+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)
+    labels = (a - 1) > 0.5  # upper paintings (1), lower paintings (0), two classes
+    labels = labels.astype(np.float32)
+    return paintings, labels
+
+art_labels = tf.placeholder(tf.float32, [None, 1])
+with tf.variable_scope('Generator'):
+    G_in = tf.placeholder(tf.float32, [None, N_IDEAS])          # random ideas (could from normal distribution)
+    G_art = tf.concat((G_in, art_labels), 1)                    # combine ideas with labels
+    G_l1 = tf.layers.dense(G_art, 128, tf.nn.relu)
+    G_out = tf.layers.dense(G_l1, ART_COMPONENTS)               # making a painting from these random ideas
+
+with tf.variable_scope('Discriminator'):
+    real_in = tf.placeholder(tf.float32, [None, ART_COMPONENTS], name='real_in')   # receive art work from the famous artist + label
+    real_art = tf.concat((real_in, art_labels), 1)                                  # art with labels
+    D_l0 = tf.layers.dense(real_art, 128, tf.nn.relu, name='l')
+    prob_artist0 = tf.layers.dense(D_l0, 1, tf.nn.sigmoid, name='out')              # probability that the art work is made by artist
+    # reuse layers for generator
+    G_art = tf.concat((G_out, art_labels), 1)                                       # art with labels
+    D_l1 = tf.layers.dense(G_art, 128, tf.nn.relu, name='l', reuse=True)            # receive art work from a newbie like G
+    prob_artist1 = tf.layers.dense(D_l1, 1, tf.nn.sigmoid, name='out', reuse=True)  # probability that the art work is made by artist
+
+D_loss = -tf.reduce_mean(tf.log(prob_artist0) + tf.log(1-prob_artist1))
+G_loss = tf.reduce_mean(tf.log(1-prob_artist1))
+
+train_D = tf.train.AdamOptimizer(LR_D).minimize(
+    D_loss, var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator'))
+train_G = tf.train.AdamOptimizer(LR_G).minimize(
+    G_loss, var_list=tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Generator'))
+
+sess = tf.Session()
+sess.run(tf.global_variables_initializer())
+
+plt.ion()   # something about continuous plotting
+plt.show()
+for step in range(7000):
+    artist_paintings, labels = artist_works()               # real painting from artist
+    G_ideas = np.random.randn(BATCH_SIZE, N_IDEAS)
+    G_paintings, pa0, Dl = sess.run([G_out, prob_artist0, D_loss, train_D, train_G],    # train and get results
+                                    {G_in: G_ideas, real_in: artist_paintings, art_labels: labels})[:3]
+
+    if step % 50 == 0:  # plotting
+        plt.cla()
+        plt.plot(PAINT_POINTS[0], G_paintings[0], c='#4AD631', lw=3, label='Generated painting',)
+        bound = [0, 0.5] if labels[0, 0] == 0 else [0.5, 1]
+        plt.plot(PAINT_POINTS[0], 2 * np.power(PAINT_POINTS[0], 2) + bound[1], c='#74BCFF', lw=3, label='upper bound')
+        plt.plot(PAINT_POINTS[0], 1 * np.power(PAINT_POINTS[0], 2) + bound[0], c='#FF9359', lw=3, label='lower bound')
+        plt.text(-.5, 2.3, 'D accuracy=%.2f (0.5 for D to converge)' % pa0.mean(), fontdict={'size': 15})
+        plt.text(-.5, 2, 'D score= %.2f (-1.38 for G to converge)' % -Dl, fontdict={'size': 15})
+        plt.text(-.5, 1.7, 'Class = %i' % int(labels[0, 0]), fontdict={'size': 15})
+        plt.ylim((0, 3))
+        plt.legend(loc='upper right', fontsize=12)
+        plt.draw()
+        plt.pause(0.1)
+
+plt.ioff()
+
+# plot a generated painting for upper class
+plt.figure(2)
+z = np.random.randn(1, N_IDEAS)
+label = np.array([[1.]])            # for upper class
+G_paintings = sess.run(G_out, {G_in: z, art_labels: label})
+plt.plot(PAINT_POINTS[0], G_paintings[0], c='#4AD631', lw=3, label='G painting for upper class',)
+plt.plot(PAINT_POINTS[0], 2 * np.power(PAINT_POINTS[0], 2) + bound[1], c='#74BCFF', lw=3, label='upper bound (class 1)')
+plt.plot(PAINT_POINTS[0], 1 * np.power(PAINT_POINTS[0], 2) + bound[0], c='#FF9359', lw=3, label='lower bound (class 1)')
+plt.ylim((0, 3))
+plt.legend(loc='upper right', fontsize=12)
+plt.show()

tutorial-contents/406_conditional_GAN.py

@@ -0,0 +1,84 @@
+"""
+Know more, visit my Python tutorial page: https://morvanzhou.github.io/tutorials/
+My Youtube Channel: https://www.youtube.com/user/MorvanZhou
+
+Dependencies:
+tensorflow: 1.1.0
+matplotlib
+numpy
+"""
+import tensorflow as tf
+import numpy as np
+import matplotlib.pyplot as plt
+
+tf.set_random_seed(1)
+np.random.seed(1)
+
+# Hyper parameters
+N_SAMPLES = 20
+N_HIDDEN = 300
+LR = 0.01
+
+# training data
+x = np.linspace(-1, 1, N_SAMPLES)[:, np.newaxis]
+y = x + 0.3*np.random.randn(N_SAMPLES)[:, np.newaxis]
+
+# test data
+test_x = x.copy()
+test_y = test_x + 0.3*np.random.randn(N_SAMPLES)[:, np.newaxis]
+
+# show data
+plt.scatter(x, y, c='magenta', s=50, alpha=0.5, label='train')
+plt.scatter(test_x, test_y, c='cyan', s=50, alpha=0.5, label='test')
+plt.legend(loc='upper left')
+plt.ylim((-2.5, 2.5))
+plt.show()
+
+# tf placeholders
+tf_x = tf.placeholder(tf.float32, [None, 1])
+tf_y = tf.placeholder(tf.float32, [None, 1])
+tf_is_training = tf.placeholder(tf.bool, None)  # to control dropout when training and testing
+
+# overfitting net
+o1 = tf.layers.dense(tf_x, N_HIDDEN, tf.nn.relu)
+o2 = tf.layers.dense(o1, N_HIDDEN, tf.nn.relu)
+o_out = tf.layers.dense(o2, 1)
+o_loss = tf.losses.mean_squared_error(tf_y, o_out)
+o_train = tf.train.AdamOptimizer(LR).minimize(o_loss)
+
+# dropout net
+d1 = tf.layers.dense(tf_x, N_HIDDEN, tf.nn.relu)
+d1 = tf.layers.dropout(d1, rate=0.5, training=tf_is_training)   # drop out 50% of inputs
+d2 = tf.layers.dense(d1, N_HIDDEN, tf.nn.relu)
+d2 = tf.layers.dropout(d2, rate=0.5, training=tf_is_training)   # drop out 50% of inputs
+d_out = tf.layers.dense(d2, 1)
+d_loss = tf.losses.mean_squared_error(tf_y, d_out)
+d_train = tf.train.AdamOptimizer(LR).minimize(d_loss)
+
+sess = tf.Session()
+sess.run(tf.global_variables_initializer())
+
+plt.ion()   # something about plotting
+plt.show()
+
+for t in range(500):
+    sess.run([o_train, d_train], {tf_x: x, tf_y: y, tf_is_training: True})  # train, set is_training=True
+
+    if t % 10 == 0:
+        # plotting
+        plt.cla()
+        o_loss_, d_loss_, o_out_, d_out_ = sess.run(
+            [o_loss, d_loss, o_out, d_out], {tf_x: test_x, tf_y: test_y, tf_is_training: False} # test, set is_training=False
+        )
+        plt.scatter(x, y, c='magenta', s=50, alpha=0.3, label='train')
+        plt.scatter(test_x, test_y, c='cyan', s=50, alpha=0.3, label='test')
+        plt.plot(test_x, o_out_, 'r-', lw=3, label='overfitting')
+        plt.plot(test_x, d_out_, 'b--', lw=3, label='dropout(50%)')
+        plt.text(0, -1.2, 'overfitting loss=%.4f' % o_loss_, fontdict={'size': 20, 'color':  'red'})
+        plt.text(0, -1.5, 'dropout loss=%.4f' % d_loss_, fontdict={'size': 20, 'color': 'blue'})
+        plt.legend(loc='upper left')
+        plt.ylim((-2.5, 2.5))
+        plt.pause(0.1)
+
+plt.ioff()
+plt.show()