move model creation back into models package

models/__init__.py

@@ -1,14 +1,24 @@
 import keras.backend as K
+from keras.models import Model
 
 from models import deep1
 from models.renes_networks import selu
 from . import flat_2, pauls_networks, renes_networks
 
 
+def create_model(model, output_type):
+    if output_type == "both":
+        return Model(inputs=[model.in_domains, model.in_flows], outputs=(model.out_client, model.out_server))
+    elif output_type == "client":
+        return Model(inputs=[model.in_domains, model.in_flows], outputs=(model.out_client,))
+    else:
+        raise Exception("unknown model output")
+    
+
 def get_models_by_params(params: dict):
     # decomposing param section
     # mainly embedding model
-    # network_type = params.get("type")
+    network_type = params.get("type")
     network_depth = params.get("depth")
     embedding_size = params.get("embedding")
     filter_embedding = params.get("filter_embedding")
@@ -33,23 +43,40 @@ def get_models_by_params(params: dict):
     elif network_depth == "deep2":
         networks = renes_networks
     else:
-        raise Exception("network not found")
-    embedding_model = networks.get_embedding(embedding_size, domain_length, filter_embedding, kernel_embedding,
+        raise ValueError("network not found")
+
+    domain_cnn = networks.get_embedding(embedding_size, domain_length, filter_embedding, kernel_embedding,
                                              hidden_embedding, 0.5)
 
-    final = networks.get_model(0.25, flow_features, hidden_embedding, window_size, domain_length,
-                               filter_main, kernel_main, dense_dim, embedding_model, model_output)
+    if network_type == "final":
+        model = networks.get_model(0.25, flow_features, window_size, domain_length,
+                                   filter_main, kernel_main, dense_dim, domain_cnn)
+        model = create_model(model, model_output)
+    elif network_type in ("inter", "staggered"):
+        model = networks.get_new_model(0.25, flow_features, window_size, domain_length,
+                                       filter_main, kernel_main, dense_dim, domain_cnn)
+        model = create_model(model, model_output)
+    elif network_type == "long":
+        model = networks.get_new_model2(0.25, flow_features, window_size, domain_length,
+                                        filter_main, kernel_main, dense_dim, domain_cnn)
+        model = create_model(model, model_output)
+    elif network_type == "soft":
+        model = networks.get_new_soft(0.25, flow_features, window_size, domain_length,
+                                      filter_main, kernel_main, dense_dim, domain_cnn)
+        model = create_model(model, model_output)
+        conv_server = model.get_layer("conv_server").trainable_weights
+        conv_client = model.get_layer("conv_client").trainable_weights
+        l1 = [0.001 * K.sum(K.abs(x - y)) for (x, y) in zip(conv_server, conv_client)]
+        model.add_loss(l1)
+    
+        dense_server = model.get_layer("dense_server").trainable_weights
+        dense_client = model.get_layer("dense_client").trainable_weights
+        l2 = [0.001 * K.sum(K.abs(x - y)) for (x, y) in zip(dense_server, dense_client)]
+        model.add_loss(l2)
+    else:
+        raise ValueError("network type not found")
 
-    inter = networks.get_new_model(0.25, flow_features, hidden_embedding, window_size, domain_length,
-                                   filter_main, kernel_main, dense_dim, embedding_model, model_output)
-
-    long = networks.get_new_model2(0.25, flow_features, hidden_embedding, window_size, domain_length,
-                                   filter_main, kernel_main, dense_dim, embedding_model, model_output)
-
-    soft = networks.get_new_soft(0.25, flow_features, hidden_embedding, window_size, domain_length,
-                                 filter_main, kernel_main, dense_dim, embedding_model, model_output)
-
-    return embedding_model, final, inter, long, soft
+    return model
 
 
 def get_server_model_by_params(params: dict):

models/pauls_networks.py

@@ -42,8 +42,8 @@ def get_embedding(embedding_size, input_length, filter_size, kernel_size, hidden
     return KerasModel(x, y)
 
 
-def get_model(cnnDropout, flow_features, domain_features, window_size, domain_length, cnn_dims, kernel_size,
-              dense_dim, cnn, model_output="both") -> Model:
+def get_model(cnnDropout, flow_features, window_size, domain_length, cnn_dims, kernel_size,
+              dense_dim, cnn) -> Model:
     ipt_domains = Input(shape=(window_size, domain_length), name="ipt_domains")
     encoded = TimeDistributed(cnn, name="domain_cnn")(ipt_domains)
     ipt_flows = Input(shape=(window_size, flow_features), name="ipt_flows")
@@ -51,8 +51,7 @@ def get_model(cnnDropout, flow_features, domain_features, window_size, domain_le
     # CNN processing a small slides of flow windows
     y = Conv1D(cnn_dims,
                kernel_size,
-               activation='relu',
-               input_shape=(window_size, domain_features + flow_features))(merged)
+               activation='relu')(merged)
     # remove temporal dimension by global max pooling
     y = GlobalMaxPooling1D()(y)
     y = Dropout(cnnDropout)(y)
@@ -63,8 +62,8 @@ def get_model(cnnDropout, flow_features, domain_features, window_size, domain_le
     return Model(ipt_domains, ipt_flows, out_client, out_server)
 
 
-def get_new_model(dropout, flow_features, domain_features, window_size, domain_length, cnn_dims, kernel_size,
-                  dense_dim, cnn, model_output="both") -> Model:
+def get_new_model(dropout, flow_features, window_size, domain_length, cnn_dims, kernel_size,
+                  dense_dim, cnn) -> Model:
     ipt_domains = Input(shape=(window_size, domain_length), name="ipt_domains")
     ipt_flows = Input(shape=(window_size, flow_features), name="ipt_flows")
     encoded = TimeDistributed(cnn, name="domain_cnn")(ipt_domains)
@@ -105,8 +104,8 @@ def get_server_model(flow_features, domain_length, dense_dim, cnn):
     return KerasModel(inputs=[ipt_domains, ipt_flows], outputs=out_server)
 
 
-def get_new_model2(dropout, flow_features, domain_features, window_size, domain_length, cnn_dims, kernel_size,
-                   dense_dim, cnn, model_output="both") -> Model:
+def get_new_model2(dropout, flow_features, window_size, domain_length, cnn_dims, kernel_size,
+                   dense_dim, cnn) -> Model:
     ipt_domains = Input(shape=(window_size, domain_length), name="ipt_domains")
     ipt_flows = Input(shape=(window_size, flow_features), name="ipt_flows")
     encoded = TimeDistributed(cnn, name="domain_cnn")(ipt_domains)
@@ -137,19 +136,8 @@ def get_new_model2(dropout, flow_features, domain_features, window_size, domain_
     return Model(ipt_domains, ipt_flows, out_client, out_server)
 
 
-import keras.backend as K
-
-
-def get_new_soft(dropout, flow_features, domain_features, window_size, domain_length, cnn_dims, kernel_size,
-                 dense_dim, cnn, model_output="both") -> Model:
-    def dist_reg(distant_layer):
-        def dist_reg_h(weights):
-            print("REG FUNCTION")
-            print(weights)
-            print(distant_layer)
-            return 0.01 * K.sum(K.abs(weights - distant_layer))
-        
-        return dist_reg_h
+def get_new_soft(dropout, flow_features, window_size, domain_length, cnn_dims, kernel_size,
+                 dense_dim, cnn) -> Model:
     
     ipt_domains = Input(shape=(window_size, domain_length), name="ipt_domains")
     ipt_flows = Input(shape=(window_size, flow_features), name="ipt_flows")
@@ -177,7 +165,5 @@ def get_new_soft(dropout, flow_features, domain_features, window_size, domain_le
               name="dense_client")(y)
     
     out_client = Dense(1, activation='sigmoid', name="client")(y)
-    # model = KerasModel(inputs=(ipt_domains, ipt_flows), outputs=(out_client, out_server))
-    
     
     return Model(ipt_domains, ipt_flows, out_client, out_server)