Time to get graphs!

Author: pratikgujjar

code/autoencoder_model/scripts/thesis_scripts/.config_r16.py.swp

@@ -31,7 +31,7 @@
 TEST_DATA_DIR= '/local_home/JAAD_Dataset/iros/resized_imgs_208_thesis/test/'
 # TEST_DATA_DIR= '/local_home/JAAD_Dataset/fun_experiments/resized/'
 
-RESULTS_DIR = '/local_home/JAAD_Dataset/thesis/results/rendec/'
+RESULTS_DIR = '/local_home/JAAD_Dataset/thesis/results/rev/'
 
 # MODEL_DIR = './../' + path_var + 'models'
 MODEL_DIR = RESULTS_DIR + 'models/'
@@ -66,7 +66,7 @@
 SHUFFLE = True
 VIDEO_LENGTH = 32
 IMG_SIZE = (128, 208, 3)
-RAM_DECIMATE = False
+RAM_DECIMATE = True 
 REVERSE = True
 
 
@@ -75,8 +75,9 @@
 print ("Loading network/training configuration.")
 print ("Config file: " + str(__name__))
 
-BATCH_SIZE = 9
-TEST_BATCH_SIZE = 9
+BATCH_SIZE = 8
+
+TEST_BATCH_SIZE = 1
 NB_EPOCHS_AUTOENCODER = 30
 
 # OPTIM_A = Adam(lr=0.0001, beta_1=0.5)

code/autoencoder_model/scripts/thesis_scripts/config_r16.pyc

@@ -31,7 +31,7 @@
 TEST_DATA_DIR= '/local_home/JAAD_Dataset/iros/resized_imgs_208_thesis/test/'
 # TEST_DATA_DIR= '/local_home/JAAD_Dataset/fun_experiments/resized/'
 
-RESULTS_DIR = '/local_home/JAAD_Dataset/thesis/results/rescheck/'
+RESULTS_DIR = '/local_home/JAAD_Dataset/thesis/results/kernel/'
 
 # MODEL_DIR = './../' + path_var + 'models'
 MODEL_DIR = RESULTS_DIR + 'models/'

code/autoencoder_model/scripts/thesis_scripts/config_rendec16.py

@@ -4,8 +4,9 @@
 
 import hickle as hkl
 import numpy as np
-from tensorflow.python.pywrap_tensorflow import do_quantize_training_on_graphdef
 
+#import tensorflow as tf
+#tf.reset_default_graph()
 np.random.seed(9 ** 10)
 from keras import backend as K
 K.set_image_dim_ordering('tf')
@@ -223,13 +224,17 @@ def set_trainability(model, trainable):
 
 
 def autoencoder_model(encoder, decoder):
-    inputs = Input(shape=(int(VIDEO_LENGTH / 2), 128, 208, 3))
-    z = encoder(inputs)
+    # inputs = Input(shape=(int(VIDEO_LENGTH / 2), 128, 208, 3))
+    # z = encoder(inputs)
     # print (z.shape)
     # print (type(z))
-    future = decoder(z)
+    # future = decoder(z)
 
-    model = Model(inputs=inputs, outputs=future)
+    # model = Model(inputs=inputs, outputs=future)
+
+    model = Sequential()
+    model.add(encoder)
+    model.add(decoder)
 
     return model
 
@@ -401,11 +406,11 @@ def train(BATCH_SIZE, ENC_WEIGHTS, DEC_WEIGHTS):
 
     print("Beginning Training...")
     # Begin Training
-    for epoch in range(1, NB_EPOCHS_AUTOENCODER+1):
-        if epoch == 21:
+    for epoch in range(28, NB_EPOCHS_AUTOENCODER+1):
+        if epoch == 28:
             autoencoder.compile(loss="mean_absolute_error", optimizer=OPTIM_B)
-            load_weights(os.path.join(CHECKPOINT_DIR, 'encoder_epoch_20.h5'), encoder)
-            load_weights(os.path.join(CHECKPOINT_DIR, 'decoder_epoch_20.h5'), decoder)
+            load_weights(os.path.join(CHECKPOINT_DIR, 'encoder_epoch_27.h5'), encoder)
+            load_weights(os.path.join(CHECKPOINT_DIR, 'decoder_epoch_27.h5'), decoder)
 
         print("\n\nEpoch ", epoch)
         loss = []
@@ -515,6 +520,7 @@ def test(ENC_WEIGHTS, DEC_WEIGHTS):
     mae_errors = np.zeros(shape=(n_test_videos, int(VIDEO_LENGTH/2) + 1))
     mse_errors = np.zeros(shape=(n_test_videos, int(VIDEO_LENGTH/2) + 1))
 
+    # z_all = []
     for index in range(NB_TEST_ITERATIONS):
         X = load_X(test_videos_list, index, TEST_DATA_DIR, IMG_SIZE, batch_size=TEST_BATCH_SIZE)
         X_test = np.flip(X[:, 0: int(VIDEO_LENGTH / 2)], axis=1)
@@ -527,9 +533,16 @@ def test(ENC_WEIGHTS, DEC_WEIGHTS):
                      "\t    [" + "{0}>".format("=" * (arrow)))
         stdout.flush()
 
+
         if SAVE_GENERATED_IMAGES:
             # Save generated images to file
-            predicted_images = autoencoder.predict(X_test, verbose=0)
+            z = encoder.predict(X_test, verbose=0)
+            # z_all.append(z)
+
+            # z_new = np.zeros(shape=(TEST_BATCH_SIZE, 1, 16, 26, 64))
+            # z_new[0] = z[:, 15]
+            # z_new = np.repeat(z_new, int(VIDEO_LENGTH/2), axis=1)
+            predicted_images = decoder.predict(z, verbose=0)
             voila = np.concatenate((X_test, y_test), axis=1)
             truth_seq = arrange_images(voila)
             pred_seq = arrange_images(np.concatenate((X_test, predicted_images), axis=1))
@@ -558,7 +571,7 @@ def test(ENC_WEIGHTS, DEC_WEIGHTS):
 
     np.save(os.path.join(TEST_RESULTS_DIR + '/graphs/values/', str(index) + "_mae.npy"), np.asarray(mae_errors))
     np.save(os.path.join(TEST_RESULTS_DIR + '/graphs/values/', str(index) + "_mse.npy"), np.asarray(mse_errors))
-
+    # np.save(os.path.join(TEST_RESULTS_DIR + '/graphs/values/', "z_all.npy"), np.asarray(z_all))
 
     # then after each epoch/iteration
     avg_test_loss = sum(test_loss) / len(test_loss)

code/autoencoder_model/scripts/thesis_scripts/config_rendec16.pyc

@@ -23,9 +23,9 @@
 from keras.layers.normalization import BatchNormalization
 from keras.callbacks import LearningRateScheduler
 from keras.layers.advanced_activations import LeakyReLU
-# from sklearn.metrics import mean_absolute_error as mae
-# from sklearn.metrics import mean_squared_error as mse
-# from plot_results import plot_err_variation
+from sklearn.metrics import mean_absolute_error as mae
+from sklearn.metrics import mean_squared_error as mse
+from plot_results import plot_err_variation
 from keras.layers import Input
 from keras.models import Model
 from config_walle_r16 import *
@@ -413,15 +413,16 @@ def test(ENC_WEIGHTS, DEC_WEIGHTS):
     encoder = encoder_model()
     decoder = decoder_model()
     autoencoder = autoencoder_model(encoder, decoder)
-    autoencoder.compile(loss="mean_squared_error", optimizer=OPTIM_A)
+    autoencoder.compile(loss="mean_absolute_error", optimizer=OPTIM_A)
 
     run_utilities(encoder, decoder, autoencoder, ENC_WEIGHTS, DEC_WEIGHTS)
 
     NB_TEST_ITERATIONS = int(n_test_videos / TEST_BATCH_SIZE)
     test_loss = []
-    mae_errors = np.zeros(shape=(n_test_videos, int(VIDEO_LENGTH/2)))
-    mse_errors = np.zeros(shape=(n_test_videos, int(VIDEO_LENGTH/2)))
+    mae_errors = np.zeros(shape=(n_test_videos, int(VIDEO_LENGTH/2) + 1))
+    mse_errors = np.zeros(shape=(n_test_videos, int(VIDEO_LENGTH/2) + 1))
 
+    z_all = []
     for index in range(NB_TEST_ITERATIONS):
         X = load_X(test_videos_list, index, TEST_DATA_DIR, IMG_SIZE, batch_size=TEST_BATCH_SIZE)
         X_test = np.flip(X[:, 0: int(VIDEO_LENGTH / 2)], axis=1)
@@ -434,9 +435,16 @@ def test(ENC_WEIGHTS, DEC_WEIGHTS):
                      "\t    [" + "{0}>".format("=" * (arrow)))
         stdout.flush()
 
+
         if SAVE_GENERATED_IMAGES:
             # Save generated images to file
-            predicted_images = autoencoder.predict(X_test, verbose=0)
+            z = encoder.predict(X_test, verbose=0)
+            z_all.append(z)
+
+            # z_new = np.zeros(shape=(TEST_BATCH_SIZE, 1, 16, 26, 64))
+            # z_new[0] = z[:, 15]
+            # z_new = np.repeat(z_new, int(VIDEO_LENGTH/2), axis=1)
+            predicted_images = decoder.predict(z, verbose=0)
             voila = np.concatenate((X_test, y_test), axis=1)
             truth_seq = arrange_images(voila)
             pred_seq = arrange_images(np.concatenate((X_test, predicted_images), axis=1))
@@ -450,17 +458,22 @@ def test(ENC_WEIGHTS, DEC_WEIGHTS):
                 mae_errors[index, i] = (mae(y_test[0, i].flatten(), predicted_images[0, i].flatten()))
                 mae_error.append(mae_errors[index, i])
 
+
                 mse_errors[index, i] = (mse(y_test[0, i].flatten(), predicted_images[0, i].flatten()))
                 mse_error.append(mse_errors[index, i])
 
+            dc_mae = mae(X_test[0, 0].flatten(), predicted_images[0, 0].flatten())
+            mae_errors[index, -1] = dc_mae
+            dc_mse = mse(X_test[0, 0].flatten(), predicted_images[0, 0].flatten())
+            mse_errors[index, -1] = dc_mse
             cv2.imwrite(os.path.join(TEST_RESULTS_DIR + '/truth/', str(index) + "_truth.png"), truth_seq)
             cv2.imwrite(os.path.join(TEST_RESULTS_DIR + '/pred/', str(index) + "_pred.png"), pred_seq)
-            plot_err_variation(mae_error, index)
-            plot_err_variation(mse_error, index)
+            plot_err_variation(mae_error, index, dc_mae, 'mae')
+            plot_err_variation(mse_error, index, dc_mse, 'mse')
 
     np.save(os.path.join(TEST_RESULTS_DIR + '/graphs/values/', str(index) + "_mae.npy"), np.asarray(mae_errors))
     np.save(os.path.join(TEST_RESULTS_DIR + '/graphs/values/', str(index) + "_mse.npy"), np.asarray(mse_errors))
-
+    np.save(os.path.join(TEST_RESULTS_DIR + '/graphs/values/', "z_all.npy"), np.asarray(z_all))
 
     # then after each epoch/iteration
     avg_test_loss = sum(test_loss) / len(test_loss)
@@ -473,6 +486,7 @@ def test(ENC_WEIGHTS, DEC_WEIGHTS):
     print("\n Min: " + str(np.min(np.asarray(test_loss))))
 
 
+
 def get_args():
     parser = argparse.ArgumentParser()
     parser.add_argument("--mode", type=str)

code/autoencoder_model/scripts/thesis_scripts/config_walle_r16.py

@@ -84,3 +84,56 @@ def get_args():
 # dilation_mean = np.mean(dilation, axis=0)
 # kernel_mean = np.mean(dilation, axis=0)
 # rev_mean = np.mean(rev, axis=0)
+
+# import math
+# import numpy as np
+# import matplotlib.pyplot as plt
+# import matplotlib.patches as mpatches
+#
+# # def myreadlines(f, newline):
+# #   buf = ""
+# #   while True:
+# #     while newline in buf:
+# #       pos = buf.index(newline)
+# #       yield buf[:pos]
+# #       buf = buf[pos + len(newline):]
+# #     chunk = f.read(4096)
+# #     if not chunk:
+# #       yield buf
+# #       break
+# #     buf += chunk
+#
+# # plt.rcParams['font.family'] = 'serif'
+# plt.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
+# plt.rc('text', usetex=True)
+#
+# # plt.rcParams['font.serif'] = 'Ubuntu'
+# # plt.rcParams['font.monospace'] = 'Ubuntu Mono'
+# plt.rcParams['font.size'] = 10
+# plt.rcParams['axes.labelsize'] = 10
+# plt.rcParams['axes.labelweight'] = 'bold'
+# plt.rcParams['xtick.labelsize'] = 8
+# plt.rcParams['ytick.labelsize'] = 8
+# plt.rcParams['legend.fontsize'] = 10
+# plt.rcParams['figure.titlesize'] = 12
+# plt.style.use('seaborn-white')
+#
+# #   if (prefixStr == "Results/200Robots500Boxes/star_switch/star_switch"):
+# #     lines = plt.plot(stepNumbers, avgAvgDists)
+# #     plt.setp(lines, color='#3E6386', linewidth=1)
+# #     plt.fill_between(stepNumbers, [a-b for a,b in zip(avgAvgDists, stdDevs)], [a+b for a,b in zip(avgAvgDists, stdDevs)], facecolor="#9DB3C8", alpha=0.7)
+# #   else:
+# #     lines = plt.plot(stepNumbers, avgAvgDists)
+# #     plt.setp(lines, color='#430029', linewidth=1)
+# #     plt.fill_between(stepNumbers, [a-b for a,b in zip(avgAvgDists, stdDevs)], [a+b for a,b in zip(avgAvgDists, stdDevs)], facecolor="#C986AF", alpha=0.7)
+# #   ax = plt.gca()
+# #   ax.set_yticks(np.arange(0, math.ceil(max(avgAvgDists)), 0.50))
+# # plt.xlabel('World Steps')
+# # plt.ylabel('Mean Box Distance from Goal Shape (m)')
+# # plt.title("Avg Distance from Boxes to \nStar Shaped Goal with and without Switching\n200 Robots 500 Boxes")
+# # #plt.fill_between(stepNumbers, [a-b for a,b in zip(avgAvgDistsOut, stdDevsOut)], [a+b for a,b in zip(avgAvgDistsOut, stdDevsOut)], facecolor="#9DB3C8")
+# # red_patch = mpatches.Patch(color='#3E6386', label='With Switching')
+# # blue_patch = mpatches.Patch(color='#430029', label='Without Switching')
+# # plt.legend(handles=[blue_patch, red_patch])
+# # ax.set_facecolor([0.975, 0.975, 0.975])
+# # plt.savefig('/home/abignell/Pictures/push_pics/starstyle.pdf', bbox_inches='tight')