Add files via upload

Author: An-Yuhang-ace

AttentionSeq2Seqtrain.py

@@ -0,0 +1,99 @@
+import tensorflow as tf
+import numpy as np
+import random
+import csv
+import Model
+from TrajectoryLoader import TrajectoryLoader
+
+
+# parameters for traning
+learnig_rate = 0.001
+num_batches = 100000
+batch_size = 256
+display_step = 50
+# parameters for seq2seq model
+n_lstm = 128
+encoder_length = 20
+decoder_length = 10
+
+attention_func1 = 'dot' 
+attention_func2 = 'general' 
+attention_func3 = 'concat'
+
+# Choose Adam optimizer.
+optimizer = tf.keras.optimizers.Adam(learnig_rate)
+
+# Create and build encoder and decoder.
+encoder_a = Model.Encoder(n_lstm, batch_size)
+decoder_a = Model.DecoderAttention(n_lstm, batch_size, attention_func2)
+
+x = np.zeros((batch_size, 1, 5), dtype=np.float32)
+output = encoder_a(x)
+decoder_a(x, output[1:], output[0])
+encoder_a.summary()
+decoder_a.summary()
+
+#tensorboard
+summary_writer = tf.summary.create_file_writer('tensorboard')
+tf.summary.trace_on(profiler=True)
+# checkpoint
+checkpoint1 = tf.train.Checkpoint(EncoderAttention = encoder_a)
+manager1 = tf.train.CheckpointManager(checkpoint1, directory = './SaveEncoderAttention', checkpoint_name = 'EncoderAttention.ckpt', max_to_keep = 10)
+checkpoint2 = tf.train.Checkpoint(DecoderAttention = decoder_a)
+manager2 = tf.train.CheckpointManager(checkpoint2, directory = './SaveDecoderAttention', checkpoint_name = 'DecoderAttention.ckpt', max_to_keep = 10)
+
+
+def RunOptimization(source_seq, target_seq_in, target_seq_out, step):
+    loss = 0
+    decoder_length = target_seq_out.shape[1]
+    with tf.GradientTape() as tape:
+        encoder_outputs = encoder_a(source_seq)
+        states = encoder_outputs[1:]
+        y_sample = 0
+        for t in range(decoder_length):
+            '''
+            if t == 0 or random.randint(0,1) == 0:
+                decoder_in = tf.expand_dims(target_seq_in[:, t], 1)
+            else:
+                decoder_in = tf.expand_dims(y_sample, 1)  
+            '''         
+            decoder_in = tf.expand_dims(target_seq_in[:, t], 1)
+            logit, de_state_h, de_state_c, _= decoder_a(decoder_in, states, encoder_outputs[0])
+            # TODO scheduled sampling
+            y_sample = logit
+            states = de_state_h, de_state_c
+            # loss function : RSME TODO
+            loss_0 = tf.keras.losses.MSE(target_seq_out[:, t, 1:3], logit[:, 1:3])
+            loss += tf.sqrt(loss_0)# TODO
+       
+    variables = encoder_a.trainable_variables + decoder_a.trainable_variables
+    gradients = tape.gradient(loss, variables)
+    optimizer.apply_gradients(zip(gradients, variables))  
+    
+    loss = tf.reduce_mean(loss) 
+    loss = loss / decoder_length
+    with summary_writer.as_default():
+        tf.summary.scalar("loss", loss.numpy(), step = step)   
+
+    return loss
+
+# Load trajectory data.
+seq2seq_loader = TrajectoryLoader()
+seq2seq_loader.loadTrajectoryData("./DataSet/TrajectoryMillion.csv")
+
+
+for batch_index in range(1, num_batches+1):
+    seq_encoder, seq_decoder = seq2seq_loader.getBatchSeq2Seq(batch_size, encoder_length, decoder_length)
+    seq_decoder_in = seq_decoder[:, :decoder_length, :]
+    seq_decoder_out = seq_decoder[:, 1:decoder_length+1, :]
+    loss = RunOptimization(seq_encoder, seq_decoder_in, seq_decoder_out, batch_index)
+
+    if batch_index % display_step == 0:
+        print("batch %d: loss %f" % (batch_index, loss.numpy()))
+        path1 = manager1.save(checkpoint_number = batch_index)
+        path2 = manager2.save(checkpoint_number = batch_index)
+
+
+with summary_writer.as_default():
+    tf.summary.trace_export(name = "model_trace", step = 0, profiler_outdir = 'tensorboard')
+

BPtrain.py

@@ -0,0 +1,62 @@
+import csv
+import tensorflow as tf
+import numpy as np
+from TrajectoryLoader import TrajectoryLoader
+import Model
+
+# parameters for mini-batch gradient descent training
+learning_rate = 0.001
+training_step = 30000
+batch_size = 1024
+display_step = 100
+
+# parameters for network model
+n_hidden = 128
+bp_step = 6
+
+# Load trajectory data.
+bp_loader = TrajectoryLoader()
+bp_loader.loadTrajectoryData("./DataSet/TrajectoryMillion.csv")
+
+# Create bp model and build it.
+neural_net = Model.BP(n_hidden, bp_step, batch_size)
+
+x = np.zeros((batch_size, bp_step, 5), dtype= np.float32)
+neural_net(x)
+neural_net.summary()
+
+# Choose Adam optimizer.
+optimizer = tf.optimizers.Adam(learning_rate)
+
+#tensorboard
+summary_writer = tf.summary.create_file_writer('tensorboard')
+tf.summary.trace_on(profiler=True)
+
+# checkpoint
+checkpoint = tf.train.Checkpoint(BP_network = neural_net)
+manager = tf.train.CheckpointManager(checkpoint, directory = './SaveBP', checkpoint_name = 'BPnetwork.ckpt', max_to_keep = 10)
+
+# optimazation process.
+for batch_index in range(1, training_step + 1):
+    x, y = bp_loader.getBatchBP(batch_size, bp_step)
+    with tf.GradientTape() as tape:
+        pred = neural_net(x)
+        loss = tf.keras.losses.MSE(y, pred)
+        loss = tf.reduce_mean(loss)
+        with summary_writer.as_default():
+            tf.summary.scalar("loss", loss.numpy(), step = batch_index)
+    gradients = tape.gradient(loss, neural_net.trainable_variables)
+    optimizer.apply_gradients(zip(gradients, neural_net.trainable_variables))
+
+    if batch_index % display_step == 0:
+        pred = neural_net(x)
+        loss = tf.keras.losses.MSE(y, pred)
+        loss = tf.reduce_mean(loss)
+        print("batch %d: loss %f" % (batch_index, loss.numpy()))
+        path = manager.save(checkpoint_number = batch_index)
+
+with summary_writer.as_default():
+    tf.summary.trace_export(name = "model_trace", step = 0, profiler_outdir = 'tensorboard')
+
+
+

LSTMtrain.py

@@ -0,0 +1,84 @@
+import csv
+import tensorflow as tf
+import numpy as np
+from TrajectoryLoader import TrajectoryLoader
+import Model
+
+# parameters for mini-batch gradient descent training
+learning_rate = 0.0005
+num_batches = 10000
+batch_size = 256
+display_step = 100
+# parameters for LSTM network
+n_lstm = 128
+lstm_step = 6
+seq_length = 20
+
+# Choose Adam optimizer.
+optimizer = tf.optimizers.Adam(learning_rate)
+#optimizer = tf.optimizers.SGD(learning_rate)
+
+# Create lstm model and build it.
+neural_net = Model.LSTM(n_lstm, lstm_step, batch_size)
+
+x = np.zeros((batch_size, seq_length-lstm_step, lstm_step*5), dtype= np.float32)
+neural_net(x)
+neural_net.summary()
+
+#tensorboard
+summary_writer = tf.summary.create_file_writer('tensorboard')
+tf.summary.trace_on(profiler=True)
+# checkpoint
+checkpoint = tf.train.Checkpoint(LSTM_network = neural_net)
+manager = tf.train.CheckpointManager(checkpoint, directory = './SaveLSTM', checkpoint_name = 'LSTMnetwork.ckpt', max_to_keep = 10)
+
+
+def StepProcess(input, batch_size, seq_length, lstm_step):
+    if lstm_step == 1:
+        return input
+    else:
+        seq_length_new = seq_length - lstm_step + 1
+        output = []
+        for i in range(lstm_step):
+            seq_sub = input[:, i:seq_length_new+i, :]
+            output.append(seq_sub)
+        return np.concatenate(output, axis=2)
+
+def RunOptimization(x, y, step):
+    with tf.GradientTape() as tape:
+        pred = neural_net(x)
+        # loss function : RMSE TODO
+        loss = tf.keras.losses.MSE(y[:, 1:3], pred[:, 1:3])
+        loss = tf.sqrt(loss)
+    
+    gradients = tape.gradient(loss, neural_net.trainable_variables)
+    optimizer.apply_gradients(zip(gradients, neural_net.trainable_variables))
+
+    loss = tf.reduce_mean(loss)
+    with summary_writer.as_default():
+        tf.summary.scalar("loss", loss.numpy(), step = step)
+    return loss
+
+
+# Load trajectory data.
+lstm_loader = TrajectoryLoader()
+lstm_loader.loadTrajectoryData("./DataSet/TrajectoryMillion.csv")
+
+# optimazation process.
+for batch_index in range(1, num_batches+1):
+    # x.shape: [batch_size, seq_length, 5], y.shape: [batch_size, 5]
+    x, y = lstm_loader.getBatchLSTM(batch_size, seq_length)
+    # after StepProcess, x.shape: [batch_size, seq_lenght-lstm_step+1, lstm_step*5]
+    x = StepProcess(x, batch_size, seq_length, lstm_step)
+    loss = RunOptimization(x, y, batch_index)
+
+    if batch_index % display_step == 0:
+        print("batch %d: loss %f" % (batch_index, loss.numpy()))
+        path = manager.save(checkpoint_number = batch_index)
+
+with summary_writer.as_default():
+    tf.summary.trace_export(name = "model_trace", step = 0, profiler_outdir = 'tensorboard')
+
+
+
+