autoencoder WIP

models/autoencoder.py

@@ -10,7 +10,7 @@ import misc
 latent_dim = 64
 
 
-# print("# GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
+print("# GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
 
 
 class Autoencoder(Model):
@@ -18,17 +18,19 @@ class Autoencoder(Model):
         super(Autoencoder, self).__init__()
         self.latent_dim = latent_dim
         self.encoder = tf.keras.Sequential()
-        self.encoder.add(tf.keras.Input(shape=(4,), dtype=bool))
-        self.encoder.add(layers.Dense(units=32))
-        self.encoder.add(layers.Dense(units=2, activation='relu'))
+        self.encoder.add(tf.keras.Input(shape=(nary,), dtype=bool))
+        self.encoder.add(layers.Dense(units=16))
         # self.encoder.add(layers.Dropout(0.2))
+        self.encoder.add(layers.Dense(units=2))
         # self.encoder.add(layers.ReLU(max_value=1.0))
 
         self.decoder = tf.keras.Sequential()
         self.decoder.add(tf.keras.Input(shape=(2,)))
-        self.decoder.add(layers.Dense(units=32))
-        # self.encoder.add(tf.keras.layers.Dropout(0.2))
-        self.decoder.add(layers.Dense(units=4, activation='softmax'))
+        self.decoder.add(layers.Dense(units=16))
+        # self.decoder.add(layers.Dropout(0.2))
+        self.decoder.add(layers.Dense(units=nary))
+
+        self.randomiser = tf.random_normal_initializer(mean=0.0, stddev=0.1, seed=None)
         # self.decoder.add(layers.Softmax(units=4, dtype=bool))
 
         # [
@@ -44,7 +46,11 @@ class Autoencoder(Model):
 
     def call(self, x, **kwargs):
         encoded = self.encoder(x)
-        decoded = self.decoder(encoded)
+        encoded = tf.clip_by_value(encoded,  clip_value_min=[0, 0], clip_value_max=[1, 2*np.pi], name=None)
+        # noise = self.randomiser(shape=(-1, 2), dtype=tf.float32)
+        noise = np.random.normal(0, 1, (1, 2)) * 0.2
+        noisy = tf.convert_to_tensor(noise, dtype=tf.float32)
+        decoded = self.decoder(encoded + noisy)
         return decoded
 
 
@@ -52,15 +58,15 @@ def view_encoder(encoder, N, samples=1000):
     test_values = misc.generate_random_bit_array(samples).reshape((-1, N))
     mvector = np.array([2**i for i in range(N)], dtype=int)
     symbols = (test_values * mvector).sum(axis=1)
-    encoded = encoder(test_values).numpy()
+    encoded = misc.polar2rect(encoder(test_values).numpy())
     for i in range(2**N):
         xy = encoded[symbols == i]
         plt.plot(xy[:, 0], xy[:, 1], 'x', markersize=12, label=format(i, f'0{N}b'))
-        # plt.annotate(xy=[xy[:, 0].mean(), xy[:, 1].mean()] + [0.01, 0.01], s=format(i, f'0{N}b'))
+        plt.annotate(xy=[xy[:, 0].mean()+0.01, xy[:, 1].mean()+0.01], text=format(i, f'0{N}b'))
     plt.xlabel('Real')
     plt.ylabel('Imaginary')
     plt.title("Autoencoder generated alphabet")
-    plt.legend()
+    # plt.legend()
     plt.show()
 
     pass
@@ -75,16 +81,17 @@ if __name__ == '__main__':
     # print(f"Train data: {x_train.shape}")
     # print(f"Test data: {x_test.shape}")
 
-    samples = 1e5
-    x_train = misc.generate_random_bit_array(samples).reshape((-1, 4))
-    x_test_array = misc.generate_random_bit_array(samples * 0.2)
-    x_test = x_test_array.reshape((-1, 4))
+    samples = 3e6
+    n = 4
+    x_train = misc.generate_random_bit_array(samples).reshape((-1, n))
+    x_test_array = misc.generate_random_bit_array(samples * 0.25)
+    x_test = x_test_array.reshape((-1, n))
 
-    autoencoder = Autoencoder(latent_dim)
+    autoencoder = Autoencoder(n)
     autoencoder.compile(optimizer='adam', loss=losses.MeanSquaredError())
 
     autoencoder.fit(x_train, x_train,
-                    epochs=2,
+                    epochs=1,
                     shuffle=True,
                     validation_data=(x_test, x_test))
 
@@ -95,6 +102,6 @@ if __name__ == '__main__':
     result[decoded_data > 0.5] = True
 
     print("Accuracy: %.4f" % accuracy_score(x_test_array, result))
-    view_encoder(autoencoder.encoder, 4)
+    view_encoder(autoencoder.encoder, n)
 
     pass