ActivationInterface integrations in regular models

Author: Francisco Santos

src/ydata_synthetic/synthesizers/regular/cgan/model.py

@@ -1,13 +1,13 @@
 """CGAN implementation"""
 import os
 from os import path
-from typing import List, Union
+from typing import List, Union, Optional, NamedTuple
 
 import numpy as np
-from numpy import array, vstack, zeros, empty, hstack, ndarray
+from numpy import array, vstack, empty, hstack, ndarray
 from numpy.random import normal
 from pandas import DataFrame
-from tensorflow import convert_to_tensor, dtypes, expand_dims, tile, concat, constant
+from tensorflow import convert_to_tensor, dtypes, expand_dims, tile
 from tensorflow import data as tfdata
 from tensorflow.keras import Model
 from tensorflow.keras.layers import Dense, Dropout, Input, Flatten, Embedding, multiply
@@ -16,6 +16,7 @@
 
 from ydata_synthetic.synthesizers import TrainParameters
 from ydata_synthetic.synthesizers.gan import BaseModel
+from ydata_synthetic.utils.gumbel_softmax import ActivationInterface
 
 
 class CGAN(BaseModel):
@@ -27,9 +28,10 @@ def __init__(self, model_parameters, num_classes):
         self.label_col = None
         super().__init__(model_parameters)
 
-    def define_gan(self):
+    def define_gan(self, processor_info: Optional[NamedTuple] = None):
         self.generator = Generator(self.batch_size, self.num_classes). \
-            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim)
+            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim,
+                        processor_info = processor_info)
 
         self.discriminator = Discriminator(self.batch_size, self.num_classes). \
             build_model(input_shape=(self.data_dim,), dim=self.layers_dim)
@@ -100,7 +102,7 @@ def train(self, data: Union[DataFrame, array], label_col: str, train_arguments:
 
         processed_data = self.processor.transform(data)
         self.data_dim = processed_data.shape[1]
-        self.define_gan()
+        self.define_gan(self.processor.col_transform_info if preprocess else None)
 
         # Merging labels with processed data
         processed_data = hstack([processed_data, label])
@@ -177,7 +179,7 @@ def __init__(self, batch_size, num_classes):
         self.batch_size = batch_size
         self.num_classes = num_classes
 
-    def build_model(self, input_shape, dim, data_dim):
+    def build_model(self, input_shape, dim, data_dim, processor_info: Optional[NamedTuple] = None):
         noise = Input(shape=input_shape, batch_size=self.batch_size)
         label = Input(shape=(1,), batch_size=self.batch_size, dtype='int32')
         label_embedding = Flatten()(Embedding(self.num_classes, 1)(label))
@@ -187,6 +189,8 @@ def build_model(self, input_shape, dim, data_dim):
         x = Dense(dim * 2, activation='relu')(x)
         x = Dense(dim * 4, activation='relu')(x)
         x = Dense(data_dim)(x)
+        if processor_info:
+            x = ActivationInterface(processor_info).call(x)
         return Model(inputs=[noise, label], outputs=x)
 
 

src/ydata_synthetic/synthesizers/regular/cramergan/model.py

@@ -1,6 +1,6 @@
 import os
 from os import path
-from typing import List
+from typing import List, Optional, NamedTuple
 
 import numpy as np
 import tensorflow as tf
@@ -12,6 +12,7 @@
 from ydata_synthetic.synthesizers import TrainParameters
 from ydata_synthetic.synthesizers.gan import BaseModel
 from ydata_synthetic.synthesizers.loss import Mode, gradient_penalty
+from ydata_synthetic.utils.gumbel_softmax import ActivationInterface
 
 
 class CRAMERGAN(BaseModel):
@@ -26,9 +27,10 @@ def __init__(self, model_parameters, gradient_penalty_weight=10):
         self.gradient_penalty_weight = gradient_penalty_weight
         super().__init__(model_parameters)
 
-    def define_gan(self):
+    def define_gan(self, processor_info: Optional[NamedTuple] = None):
         self.generator = Generator(self.batch_size). \
-            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim)
+            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim,
+                        processor_info=processor_info)
 
         self.critic = Critic(self.batch_size). \
             build_model(input_shape=(self.data_dim,), dim=self.layers_dim)
@@ -147,7 +149,7 @@ def train(self, data, train_arguments: TrainParameters, num_cols: List[str],
 
         data = self.processor.transform(data)
         self.data_dim = data.shape[1]
-        self.define_gan()
+        self.define_gan(self.processor.col_transform_info if preprocess else None)
 
         iterations = int(abs(data.shape[0] / self.batch_size) + 1)
 
@@ -192,12 +194,14 @@ def __init__(self, batch_size):
         """Simple generator with dense feedforward layers."""
         self.batch_size = batch_size
 
-    def build_model(self, input_shape, dim, data_dim):
+    def build_model(self, input_shape, dim, data_dim, processor_info: Optional[NamedTuple] = None):
         input_ = Input(shape=input_shape, batch_size=self.batch_size)
         x = Dense(dim, activation='relu')(input_)
         x = Dense(dim * 2, activation='relu')(x)
         x = Dense(dim * 4, activation='relu')(x)
         x = Dense(data_dim)(x)
+        if processor_info:
+            x = ActivationInterface(processor_info)(x)
         return Model(inputs=input_, outputs=x)
 
 class Critic(tf.keras.Model):

src/ydata_synthetic/synthesizers/regular/dragan/model.py

@@ -1,6 +1,7 @@
 import os
 from os import path
 
+from typing import Optional, NamedTuple
 import tensorflow as tf
 import tqdm
 from tensorflow.keras import Model, initializers
@@ -9,6 +10,7 @@
 
 from ydata_synthetic.synthesizers.gan import BaseModel
 from ydata_synthetic.synthesizers.loss import Mode, gradient_penalty
+from ydata_synthetic.utils.gumbel_softmax import ActivationInterface
 
 
 class DRAGAN(BaseModel):
@@ -21,10 +23,11 @@ def __init__(self, model_parameters, n_discriminator, gradient_penalty_weight=10
         self.gradient_penalty_weight = gradient_penalty_weight
         super().__init__(model_parameters)
 
-    def define_gan(self):
+    def define_gan(self, col_transform_info: Optional[NamedTuple] = None):
         # define generator/discriminator
         self.generator = Generator(self.batch_size). \
-            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim)
+            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim,
+                        processor_info=col_transform_info)
 
         self.discriminator = Discriminator(self.batch_size). \
             build_model(input_shape=(self.data_dim,), dim=self.layers_dim)
@@ -118,7 +121,7 @@ def train(self, data, train_arguments, num_cols, cat_cols, preprocess: bool = Tr
 
         processed_data = self.processor.transform(data)
         self.data_dim = processed_data.shape[1]
-        self.define_gan()
+        self.define_gan(self.processor.col_transform_info if preprocess else None)
 
         train_loader = self.get_data_batch(processed_data, self.batch_size)
 
@@ -167,10 +170,12 @@ class Generator(Model):
     def __init__(self, batch_size):
         self.batch_size = batch_size
 
-    def build_model(self, input_shape, dim, data_dim):
+    def build_model(self, input_shape, dim, data_dim, processor_info: NamedTuple = None):
         input = Input(shape=input_shape, batch_size = self.batch_size)
         x = Dense(dim, kernel_initializer=initializers.TruncatedNormal(mean=0., stddev=0.5), activation='relu')(input)
         x = Dense(dim * 2, activation='relu')(x)
         x = Dense(dim * 4, activation='relu')(x)
         x = Dense(data_dim)(x)
+        if processor_info:
+            x = ActivationInterface(processor_info)(x)
         return Model(inputs=input, outputs=x)

src/ydata_synthetic/synthesizers/regular/vanillagan/model.py

@@ -1,11 +1,12 @@
 import os
 from os import path
 import numpy as np
-from typing import List
+from typing import List, Optional, NamedTuple
 from tqdm import trange
 
 from ydata_synthetic.synthesizers.gan import BaseModel
 from ydata_synthetic.synthesizers import TrainParameters
+from ydata_synthetic.utils.gumbel_softmax import ActivationInterface
 
 import tensorflow as tf
 from tensorflow.keras.layers import Input, Dense, Dropout
@@ -19,9 +20,10 @@ class VanilllaGAN(BaseModel):
     def __init__(self, model_parameters):
         super().__init__(model_parameters)
 
-    def define_gan(self):
+    def define_gan(self, processor_info: Optional[NamedTuple]):
         self.generator = Generator(self.batch_size).\
-            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim)
+            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim,
+                        processor_info = processor_info)
 
         self.discriminator = Discriminator(self.batch_size).\
             build_model(input_shape=(self.data_dim,), dim=self.layers_dim)
@@ -77,7 +79,7 @@ def train(self, data, train_arguments: TrainParameters, num_cols: List[str],
 
         processed_data = self.processor.transform(data)
         self.data_dim = processed_data.shape[1]
-        self.define_gan()
+        self.define_gan(self.processor.col_transform_info if preprocess else None)
 
         iterations = int(abs(data.shape[0]/self.batch_size)+1)
 
@@ -131,12 +133,14 @@ class Generator(tf.keras.Model):
     def __init__(self, batch_size):
         self.batch_size=batch_size
 
-    def build_model(self, input_shape, dim, data_dim):
+    def build_model(self, input_shape, dim, data_dim, processor_info: Optional[NamedTuple] = None):
         input= Input(shape=input_shape, batch_size=self.batch_size)
         x = Dense(dim, activation='relu')(input)
         x = Dense(dim * 2, activation='relu')(x)
         x = Dense(dim * 4, activation='relu')(x)
         x = Dense(data_dim)(x)
+        if processor_info:
+            x = ActivationInterface(processor_info)(x)
         return Model(inputs=input, outputs=x)
 
 class Discriminator(tf.keras.Model):

src/ydata_synthetic/synthesizers/regular/wgan/model.py

@@ -1,5 +1,5 @@
 from os import mkdir, path
-from typing import List
+from typing import List, Optional, NamedTuple
 
 import numpy as np
 import tensorflow as tf
@@ -11,6 +11,7 @@
 
 from ydata_synthetic.synthesizers import TrainParameters
 from ydata_synthetic.synthesizers.gan import BaseModel
+from ydata_synthetic.utils.gumbel_softmax import ActivationInterface
 
 
 #Auxiliary Keras backend class to calculate the Random Weighted average
@@ -41,9 +42,10 @@ def __init__(self, model_parameters, n_critic, clip_value=0.01):
     def wasserstein_loss(self, y_true, y_pred):
         return K.mean(y_true * y_pred)
 
-    def define_gan(self):
+    def define_gan(self, processor_info: Optional[NamedTuple] = None):
         self.generator = Generator(self.batch_size). \
-            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim)
+            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim,
+                        processor_info=processor_info)
 
         self.critic = Critic(self.batch_size). \
             build_model(input_shape=(self.data_dim,), dim=self.layers_dim)
@@ -97,7 +99,7 @@ def train(self, data, train_arguments: TrainParameters, num_cols: List[str],
 
         processed_data = self.processor.transform(data)
         self.data_dim = processed_data.shape[1]
-        self.define_gan()
+        self.define_gan(self.processor.col_transform_info if preprocess else None)
 
         #Create a summary file
         iterations = int(abs(data.shape[0]/self.batch_size)+1)
@@ -154,12 +156,14 @@ class Generator(tf.keras.Model):
     def __init__(self, batch_size):
         self.batch_size = batch_size
 
-    def build_model(self, input_shape, dim, data_dim):
+    def build_model(self, input_shape, dim, data_dim, processor_info: Optional[NamedTuple] = None):
         input = Input(shape=input_shape, batch_size=self.batch_size)
         x = Dense(dim, activation='relu')(input)
         x = Dense(dim * 2, activation='relu')(x)
         x = Dense(dim * 4, activation='relu')(x)
         x = Dense(data_dim)(x)
+        if processor_info:
+            x = ActivationInterface(processor_info)(x)
         return Model(inputs=input, outputs=x)
 
 class Critic(tf.keras.Model):

src/ydata_synthetic/synthesizers/regular/wgangp/model.py

@@ -1,6 +1,6 @@
 import os
 from os import path
-from typing import List
+from typing import List, NamedTuple, Optional
 
 import numpy as np
 import tensorflow as tf
@@ -11,6 +11,7 @@
 
 from ydata_synthetic.synthesizers import TrainParameters
 from ydata_synthetic.synthesizers.gan import BaseModel
+from ydata_synthetic.utils.gumbel_softmax import ActivationInterface
 
 
 class WGAN_GP(BaseModel):
@@ -24,9 +25,10 @@ def __init__(self, model_parameters, n_critic, gradient_penalty_weight=10):
         self.gradient_penalty_weight = gradient_penalty_weight
         super().__init__(model_parameters)
 
-    def define_gan(self):
+    def define_gan(self, processor_info: Optional[NamedTuple] = None):
         self.generator = Generator(self.batch_size). \
-            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim)
+            build_model(input_shape=(self.noise_dim,), dim=self.layers_dim, data_dim=self.data_dim,
+                        processor_info=processor_info)
 
         self.critic = Critic(self.batch_size). \
             build_model(input_shape=(self.data_dim,), dim=self.layers_dim)
@@ -141,7 +143,7 @@ def train(self, data, train_arguments: TrainParameters, num_cols: List[str],
 
         processed_data = self.processor.transform(data)
         self.data_dim = processed_data.shape[1]
-        self.define_gan()
+        self.define_gan(self.processor.col_transform_info if preprocess else None)
 
         iterations = int(abs(data.shape[0]/self.batch_size)+1)
 
@@ -176,12 +178,14 @@ class Generator(tf.keras.Model):
     def __init__(self, batch_size):
         self.batch_size = batch_size
 
-    def build_model(self, input_shape, dim, data_dim):
+    def build_model(self, input_shape, dim, data_dim, processor_info: Optional[NamedTuple] = None):
         input = Input(shape=input_shape, batch_size=self.batch_size)
         x = Dense(dim, activation='relu')(input)
         x = Dense(dim * 2, activation='relu')(x)
         x = Dense(dim * 4, activation='relu')(x)
         x = Dense(data_dim)(x)
+        if processor_info:
+            x = ActivationInterface(processor_info)(x)
         return Model(inputs=input, outputs=x)
 
 class Critic(tf.keras.Model):