Working autoencoder prototype

models/autoencoder.py

@@ -7,9 +7,9 @@ from tensorflow.keras import layers, losses
 from tensorflow.keras.models import Model
 import misc
 
-
 latent_dim = 64
 
+
 # print("# GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU')))
 
 
@@ -18,14 +18,15 @@ 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,)))
-        self.encoder.add(layers.Dense(units=8, activation='relu'))
+        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(layers.Dropout(0.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=8))
+        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.Softmax(units=4, dtype=bool))
@@ -47,6 +48,24 @@ class Autoencoder(Model):
         return decoded
 
 
+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()
+    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.xlabel('Real')
+    plt.ylabel('Imaginary')
+    plt.title("Autoencoder generated alphabet")
+    plt.legend()
+    plt.show()
+
+    pass
+
+
 if __name__ == '__main__':
     # (x_train, _), (x_test, _) = fashion_mnist.load_data()
     #
@@ -56,19 +75,26 @@ if __name__ == '__main__':
     # print(f"Train data: {x_train.shape}")
     # print(f"Test data: {x_test.shape}")
 
-    x_train = misc.generate_random_bit_array(1e5).reshape((-1, 4))
-    x_test = misc.generate_random_bit_array(1e4).reshape((-1, 4))
+    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))
 
     autoencoder = Autoencoder(latent_dim)
     autoencoder.compile(optimizer='adam', loss=losses.MeanSquaredError())
 
     autoencoder.fit(x_train, x_train,
-                    epochs=1,
+                    epochs=2,
                     shuffle=True,
                     validation_data=(x_test, x_test))
 
     encoded_data = autoencoder.encoder(x_test)
-    decoded_data = autoencoder.decoder(encoded_data)
+    decoded_data = autoencoder.decoder(encoded_data).numpy().reshape((-1,))
+
+    result = np.zeros(x_test_array.shape, dtype=bool)
+    result[decoded_data > 0.5] = True
+
+    print("Accuracy: %.4f" % accuracy_score(x_test_array, result))
+    view_encoder(autoencoder.encoder, 4)
 
-    print(accuracy_score(x_test, encoded_data))
     pass