encoder training

models/autoencoder.py

@@ -5,8 +5,12 @@ import tensorflow as tf
 from sklearn.metrics import accuracy_score
 from tensorflow.keras import layers, losses
 from tensorflow.keras.models import Model
+from tensorflow.python.keras.layers import LeakyReLU
+
 import misc
 import defs
+import os
+from models import basic
 
 latent_dim = 64
 
@@ -41,7 +45,6 @@ class AutoencoderDemod(defs.Demodulator):
         result = misc.int2bit_array(decoded.argmax(axis=1), self.N)
         return result.reshape(-1, )
 
-
 class Autoencoder(Model):
     def __init__(self, N, noise):
         super(Autoencoder, self).__init__()
@@ -49,16 +52,20 @@ class Autoencoder(Model):
         self.encoder = tf.keras.Sequential()
         self.encoder.add(tf.keras.Input(shape=(2 ** N,), dtype=bool))
         self.encoder.add(layers.Dense(units=2 ** (N + 1)))
+        self.encoder.add(LeakyReLU(alpha=0.001))
         # self.encoder.add(layers.Dropout(0.2))
         self.encoder.add(layers.Dense(units=2 ** (N + 1)))
-        self.encoder.add(layers.Dense(units=2, activation="sigmoid"))
+        self.encoder.add(LeakyReLU(alpha=0.001))
+        self.encoder.add(layers.Dense(units=2, activation="tanh"))
         # 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=2 ** (N + 1)))
+        self.decoder.add(LeakyReLU(alpha=0.001))
         # self.decoder.add(layers.Dropout(0.2))
         self.decoder.add(layers.Dense(units=2 ** (N + 1)))
+        self.decoder.add(LeakyReLU(alpha=0.001))
         self.decoder.add(layers.Dense(units=2 ** N, activation="softmax"))
 
         # self.randomiser = tf.random_normal_initializer(mean=0.0, stddev=0.1, seed=None)
@@ -85,7 +92,7 @@ class Autoencoder(Model):
 
     def call(self, x, **kwargs):
         encoded = self.encoder(x)
-        encoded = encoded * 2 - 1
+        # encoded = encoded * 2 - 1
         # encoded = tf.clip_by_value(encoded, clip_value_min=0, clip_value_max=1, name=None)
         # noise = self.randomiser(shape=(-1, 2), dtype=tf.float32)
         noise = np.random.normal(0, 1, (1, 2)) * self.noise
@@ -93,6 +100,33 @@ class Autoencoder(Model):
         decoded = self.decoder(encoded + noisy)
         return decoded
 
+    def fit_encoder(self, modulation, sample_size, train_size=0.8, epochs=1, batch_size=1, shuffle=False):
+        os.chdir('../')
+        alphabet = basic.load_alphabet(modulation, polar=False)
+
+        if not alphabet.shape[0] == self.N**2:
+            raise Exception("Cardinality of modulation scheme is different from cardinality of autoencoder!")
+
+        x_train = np.random.randint(self.N**2, size=int(sample_size*train_size))
+        y_train = alphabet[x_train]
+        x_train_ho = np.zeros((int(sample_size*train_size), self.N**2))
+        for idx, x in np.ndenumerate(x_train):
+            x_train_ho[idx, x] = 1
+
+        x_test = np.random.randint(self.N**2, size=int(sample_size*(1-train_size)))
+        y_test = alphabet[x_test]
+        x_test_ho = np.zeros((int(sample_size*(1-train_size)), self.N ** 2))
+        for idx, x in np.ndenumerate(x_test):
+            x_test_ho[idx, x] = 1
+
+        self.encoder.compile(optimizer='adam', loss=tf.keras.losses.MeanSquaredError())
+        self.encoder.fit(x_train_ho, y_train,
+                         epochs=epochs,
+                         batch_size=batch_size,
+                         shuffle=shuffle,
+                         validation_data=(x_test_ho, y_test))
+        pass
+
     def train(self, samples=1e6):
         if samples % self.N:
             samples += self.N - (samples % self.N)
@@ -153,26 +187,35 @@ if __name__ == '__main__':
 
     n = 4
 
-    samples = 1e6
-    x_train = misc.generate_random_bit_array(samples).reshape((-1, n))
-    x_train_ho = misc.bit_matrix2one_hot(x_train)
-    x_test_array = misc.generate_random_bit_array(samples * 0.3)
-    x_test = x_test_array.reshape((-1, n))
-    x_test_ho = misc.bit_matrix2one_hot(x_test)
+    # samples = 1e6
+    # x_train = misc.generate_random_bit_array(samples).reshape((-1, n))
+    # x_train_ho = misc.bit_matrix2one_hot(x_train)
+    # x_test_array = misc.generate_random_bit_array(samples * 0.3)
+    # x_test = x_test_array.reshape((-1, n))
+    # x_test_ho = misc.bit_matrix2one_hot(x_test)
 
     autoencoder = Autoencoder(n, -8)
-    autoencoder.compile(optimizer='adam', loss=losses.MeanSquaredError())
-
-    autoencoder.fit(x_train_ho, x_train_ho,
-                    epochs=1,
-                    shuffle=False,
-                    validation_data=(x_test_ho, x_test_ho))
-
-    encoded_data = autoencoder.encoder(x_test_ho)
-    decoded_data = autoencoder.decoder(encoded_data).numpy()
 
-    result = misc.int2bit_array(decoded_data.argmax(axis=1), n)
-    print("Accuracy: %.4f" % accuracy_score(x_test_array, result.reshape(-1, )))
+    autoencoder.fit_encoder(modulation='16qam',
+                            sample_size=1e6,
+                            train_size=0.8,
+                            epochs=50,
+                            batch_size=256,
+                            shuffle=True)
     view_encoder(autoencoder.encoder, n)
 
+    # autoencoder.compile(optimizer='adam', loss=losses.MeanSquaredError())
+    #
+    # autoencoder.fit(x_train_ho, x_train_ho,
+    #                 epochs=1,
+    #                 shuffle=False,
+    #                 validation_data=(x_test_ho, x_test_ho))
+    #
+    # encoded_data = autoencoder.encoder(x_test_ho)
+    # decoded_data = autoencoder.decoder(encoded_data).numpy()
+    #
+    # result = misc.int2bit_array(decoded_data.argmax(axis=1), n)
+    # print("Accuracy: %.4f" % accuracy_score(x_test_array, result.reshape(-1, )))
+    # view_encoder(autoencoder.encoder, n)
+
     pass