VAE traj

Author: zhkmxx9302013

VAE-GAIL/VAE/.idea/VAE.iml

@@ -1,5 +1,6 @@
-model_checkpoint_path: "vae-15000"
-all_model_checkpoint_paths: "vae-0"
-all_model_checkpoint_paths: "vae-5000"
-all_model_checkpoint_paths: "vae-10000"
-all_model_checkpoint_paths: "vae-15000"
+model_checkpoint_path: "vae-67000"
+all_model_checkpoint_paths: "vae-63000"
+all_model_checkpoint_paths: "vae-64000"
+all_model_checkpoint_paths: "vae-65000"
+all_model_checkpoint_paths: "vae-66000"
+all_model_checkpoint_paths: "vae-67000"

VAE-GAIL/VAE/.idea/misc.xml

@@ -2,39 +2,81 @@
 import tensorflow.contrib.slim as slim
 
 class Decoder:
-    def __init__(self, x_dim, hidden_size, z_dim):
-        self.X_dim = x_dim
+    def __init__(self, hidden_size, z_dim, time_steps, lstm_unit_size, action_num, state_num):
+        """
+
+        :param hidden_size:
+        :param z_dim:
+        """
         self.hidden_size = hidden_size
         self.z_dim = z_dim
-        self.P_W1 = tf.Variable(self.xavier_init([self.z_dim, self.hidden_size]))
-        self.P_b1 = tf.Variable(tf.zeros(shape=[self.hidden_size]))
-        self.P_W2 = tf.Variable(self.xavier_init([self.hidden_size, self.X_dim]))
-        self.P_b2 = tf.Variable(tf.zeros(shape=[self.X_dim]))
+        self.timesteps = time_steps
+        self.lstm_unit_size = lstm_unit_size
+        self.action_num = action_num
+        self.state_num = state_num
+
+        self.A_W1 = tf.Variable(self.xavier_init([self.z_dim, self.hidden_size]))
+        self.A_b1 = tf.Variable(tf.zeros(shape=[self.hidden_size]))
+        self.A_W2 = tf.Variable(self.xavier_init([self.hidden_size, self.timesteps * self.action_num]))
+        self.A_b2 = tf.Variable(tf.zeros(shape=[self.timesteps * self.action_num]))
+
+        self.S_W1 = tf.Variable(self.xavier_init([self.z_dim, self.hidden_size]))
+        self.S_b1 = tf.Variable(tf.zeros(shape=[self.hidden_size]))
+        self.S_W2 = tf.Variable(self.xavier_init([self.hidden_size, self.timesteps * self.state_num]))
+        self.S_b2 = tf.Variable(tf.zeros(shape=[self.timesteps * self.state_num]))
         pass
 
     def create_network(self, z, is_sample):
+        self.action_in = tf.placeholder(tf.float32, shape=[None, self.timesteps, self.action_num], name='decoder_input_action')
         with tf.name_scope('decoder') as scope:
-            if is_sample:
+            """
+            处理latent space 输入
+            """
+            if is_sample: # 来自 encoder μ，σ采样
                 z_name = '_input_z'
                 self.z = tf.placeholder(tf.float32, shape=[None, self.z_dim], name='decoder_input_z')
-            else:
+            else: # 与latent space 相同维度的高斯噪声
                 z_name = '_sample_z'
                 with tf.variable_scope('decoder_sample_z'):
                     self.z = z
-
-            with tf.variable_scope('decoder'+z_name+'_layer_1'):
-                layer1 = tf.nn.relu(tf.matmul(self.z, self.P_W1) + self.P_b1)
-            with tf.variable_scope('decoder'+z_name+'_logits'):
-                logits = tf.matmul(layer1, self.P_W2) + self.P_b2
+            self.z = tf.reshape(self.z, [-1, self.z_dim*self.timesteps])
+            self.z = slim.fully_connected(self.z,
+                                          self.z_dim,
+                                          activation_fn=tf.nn.leaky_relu,
+                                          weights_initializer=tf.contrib.layers.xavier_initializer(),
+                                          biases_initializer=tf.constant_initializer(0.0))
+            """
+            构建 action decoder
+            """
+            with tf.variable_scope('decoder'+z_name+'_action_layer_1'):
+                action_layer1 = tf.nn.relu(tf.matmul(self.z, self.A_W1) + self.A_b1)
+            with tf.variable_scope('decoder'+z_name+'_action_logits'):
+                action_logits = tf.matmul(action_layer1, self.A_W2) + self.A_b2
             with tf.variable_scope('decoder'+z_name+'_prob'):
-                prob = tf.nn.sigmoid(logits)
+                action_prob = tf.nn.sigmoid(action_logits)
+
+            """
+            构建 state decoder
+            """
+            with tf.variable_scope('decoder' + z_name + '_state_layer_1'):
+                state_layer1 = tf.nn.relu(tf.matmul(self.z, self.S_W1) + self.S_b1)
+            with tf.variable_scope('decoder' + z_name + '_state_logits'):
+                state_logits = tf.matmul(state_layer1, self.S_W2) + self.S_b2
+            with tf.variable_scope('decoder' + z_name + '_state_prob'):
+                state_prob = tf.nn.sigmoid(state_logits)
 
-            return logits, prob
+            return action_logits, action_prob, state_logits, state_prob
 
     def xavier_init(self, size):
         in_dim = size[0]
         xavier_stddev = 1. / tf.sqrt(in_dim / 2.)
         return tf.random_normal(shape=size, stddev=xavier_stddev)
 
     def get_model_param_list(self):
-        return [variable for variable in tf.trainable_variables('decoder')]
+        return [variable for variable in tf.trainable_variables('decoder')]
+
+# if __name__ == '__main__':
+#     e =Decoder(10,3,2000,10,40,27)
+#     e.create_network()
+#     # e.sample_z(1,1)
+#     print(e.state_in, e.z_var, e.z_mu, e.latent)

VAE-GAIL/VAE/.idea/modules.xml

@@ -3,8 +3,8 @@
 from tensorflow.contrib import rnn
 
 class Encoder:
-    def __init__(self, x_dim, hidden_size, z_dim, time_steps, lstm_unit_size, action_num, state_num):
-        self.X_dim = x_dim
+    def __init__(self, hidden_size, z_dim, time_steps, lstm_unit_size, action_num, state_num):
+
         self.h_dim = hidden_size
         self.z_dim = z_dim
         self.state_num = state_num
@@ -16,17 +16,19 @@ def __init__(self, x_dim, hidden_size, z_dim, time_steps, lstm_unit_size, action
 
     def create_network(self):
         with tf.name_scope('encoder') as scope:
-            self.X = tf.placeholder(tf.float32, shape=[None, self.time_steps, self.state_num], name='encoder_input_x')
+            self.state_in = tf.placeholder(tf.float32, shape=[None, self.time_steps, self.state_num], name='encoder_input_x')
             # Unstack to get a list of 'time_steps' tensors of shape (batch_size, num_input)
-            x = tf.unstack(self.X, self.time_steps, 1)
+            # unstack_state = tf.unstack(self.state_in, self.time_steps, 1)
 
-            # Forward direction cell
+            # 前向 cell
             lstm_fw_cell = rnn.BasicLSTMCell(self.lstm_unit_size, forget_bias=1.0)
-            # Backward direction cell
+            # 反向 cell
             lstm_bw_cell = rnn.BasicLSTMCell(self.lstm_unit_size, forget_bias=1.0)
 
             with tf.variable_scope('encoder_bi_lstm'):
-                outputs, _, _ = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x, dtype=tf.float32)
+                # outputs, _, _ = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, unstack_state, dtype=tf.float32)
+                outputs, _ = tf.nn.bidirectional_dynamic_rnn(lstm_fw_cell, lstm_bw_cell, self.state_in, dtype=tf.float32)  # [batch_szie, max_time, depth]
+
 
 
 
@@ -70,8 +72,9 @@ def xavier_init(self, size):
     def get_model_param_list(self):
         return [variable for variable in tf.trainable_variables('encoder')]
 
-if __name__ == '__main__':
-    e =Encoder(1,1,1)
-    e.create_network()
-    e.sample_z(1,1)
-    print(e.X, e.z_var, e.z_mu, e.latent)
+# if __name__ == '__main__':
+#     e =Encoder(1,1,1)
+#     e.create_network()
+#     e.sample_z(1,1)
+#     print(e.state_in, e.z_var, e.z_mu, e.latent)
+

VAE-GAIL/VAE/.idea/workspace.xml

@@ -1,96 +1,124 @@
 import tensorflow as tf
-import matplotlib.pyplot as plt
-import matplotlib.gridspec as gridspec
+# import matplotlib.pyplot as plt
+# import matplotlib.gridspec as gridspec
 import os
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
 import numpy as np
-from tensorflow.examples.tutorials.mnist import input_data
-
+import util_vae
+from tensorboardX import SummaryWriter
+import pandas as pd
 from vae import Vae
-def plot(samples):
-    fig = plt.figure(figsize=(4, 4))
-    gs = gridspec.GridSpec(4, 4)
-    gs.update(wspace=0.05, hspace=0.05)
+import pickle
+import random
 
-    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
 
+def get_dataset():
+    rootdir = './gen_traj/'
+    with open(rootdir+'state.pickle', 'rb') as sp:
+        state_list = pickle.load(sp)
+    with open(rootdir+'action.pickle', 'rb') as ap:
+        action_list = pickle.load(ap)
+    return state_list, action_list
 
 def train():
-    mnist = input_data.read_data_sets('../../MNIST_data', one_hot=True)
-    mb_size = 64
-    z_dim = 100
-    X_dim = mnist.train.images.shape[1]
-    h_dim = 128
-    timesteps = 28
-    num_input = 28
-
+    mb_size = 4                        # minibatch size  64条轨迹
+    z_dim = 30                         # latent space size
+    h_dim = 10                         # hidden layer size
+    timesteps = 2000                    # timesteps 每个轨迹采样2000个时间点, 动态lstm，带padding
+    state_num = 27                      # state space size
+    action_num = 40                     # action space size
 
-
-    vae_obj =  Vae(X_dim, h_dim, z_dim,  timesteps, lstm_unit_size=100, action_num=10, state_num=num_input)
+    writer = SummaryWriter()
+    vae_obj = Vae(h_dim, z_dim,  timesteps, lstm_unit_size=10, action_num=action_num, state_num=state_num)
 
     with tf.Session() as sess:
         sess.run(tf.global_variables_initializer())
         saver_vae = tf.train.Saver()
-        # saver_encoder = tf.train.Saver(vae_obj.encoder.get_model_param_list())
-        # saver_decoder = tf.train.Saver(vae_obj.decoder.get_model_param_list())
 
         if not os.path.exists('out/'):
             os.makedirs('out/')
 
-        i = 0
-        for it in range(1000000):
-            X_mb, y_mb = mnist.train.next_batch(mb_size)
+
+        states, actions = get_dataset()
+        idx_list = [i-1 for i ,item in enumerate(states)]
+        for episode in range(1000000):
+
+            rnd_idx = random.sample(idx_list, mb_size)
+            state_mb = np.array(np.array(states)[rnd_idx])
+            action_mb = np.array(np.array(actions)[rnd_idx])
             # Reshape data to get 28 seq of 28 elements
-            batch_x = X_mb.reshape((mb_size, timesteps, num_input))
-            loss = vae_obj.get_loss(batch_x)
-            if it % 1000 == 0:
-                if it % 5000 == 0:
-                    saver_vae.save(sess, "./checkpoint_dir/vae_bilstm/vae", global_step=it, write_meta_graph=True)
-                print('Iter: {}'.format(it))
-                print('Loss: {:.4}'.format(loss))
-                print()
-                samples = vae_obj.get_sample(np.random.randn(16, z_dim))
-                fig = plot(samples)
-                plt.savefig('out/{}.png'.format(str(i).zfill(3)), bbox_inches='tight')
-                i += 1
-                plt.close(fig)
+            batch_state= state_mb.reshape((mb_size, timesteps, state_num))
+            batch_action = action_mb.reshape((mb_size, timesteps, action_num))
+            loss = vae_obj.get_loss(batch_state, batch_action)
+
+            print(episode)
+            print('Iter: {}'.format(episode))
+            print('Loss: {:.4}'.format(loss))
+            print()
+
+
+            if episode % 1000 == 0:
+                saver_vae.save(sess, "./checkpoint_dir/vae_bilstm/vae", global_step=episode, write_meta_graph=True)
+
+                # samples = vae_obj.get_sample(np.random.randn(16, z_dim), action_mb)
+
+            writer.add_scalar('loss', loss, episode)
+            # writer.add_graph()
+                # fig = plot(samples)
+                # plt.savefig('out/{}.png'.format(str(i).zfill(3)), bbox_inches='tight')
+                # i += 1
+                # plt.close(fig)
 
 def test():
     with tf.Session() as sess:
         saver = tf.train.import_meta_graph('./checkpoint_dir/vae/vae-10000.meta')
         saver.restore(sess, tf.train.latest_checkpoint('./checkpoint_dir/vae'))
 
         mb_size = 64
-        mnist = input_data.read_data_sets('../../MNIST_data')
+        # mnist = input_data.read_data_sets('../../MNIST_data')
         # (x_train, y_train_), (x_test, y_test_) = mnist.load_data()
-        x_test = mnist.test.images
-        y_test_ = mnist.test.labels
+        # x_test = mnist.test.images
+        # y_test_ = mnist.test.labels
 
         #
         graph = tf.get_default_graph()
         input = graph.get_tensor_by_name("encoder/encoder_input_x:0")
         latent = graph.get_tensor_by_name("add:0")
         # var = graph.get_tensor_by_name("encoder/encoder_latent_var/fully_connected/BiasAdd:0")
-        l = sess.run(latent, feed_dict={input:x_test})
+        # l = sess.run(latent, feed_dict={input:x_test})
 
-        print(l)
+        # print(l)
 
-        pic01=plt.figure(figsize=(6, 6))
-        plt.scatter(l[:,0], l[:,1], c=y_test_)
-        plt.plot()
-        plt.colorbar()
-        plt.show()
-        pic01.savefig('temp.png')
+        # pic01=plt.figure(figsize=(6, 6))
+        # plt.scatter(l[:,0], l[:,1], c=y_test_)
+        # plt.plot()
+        # plt.colorbar()
+        # plt.show()
+        # pic01.savefig('temp.png')
         # print(sess.run('encoder_layer_1/fully_connected/weights:0'))
 
 
+# def plot(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__':
     train()
-    # test()
+    # test()
+    # print(get_dataset())
+
+