Merge pull request #2 from Fraunhofer-AISEC/regularization_control

feat: add regularization type (L1, L2) and regularization strength control

Author: pdebus

app/layout.py

@@ -64,6 +64,38 @@
             multi=False
         ),
         ], className="columnContainer"),
+        html.Div([
+        html.H3("Regularization Type"),
+        dcc.Dropdown(
+            id="select_reg_type",
+            options=[
+                {"value": "none", "label": "None"},
+                {"value": "l1", "label": "L1"},
+                {"value": "l2", "label": "L2"},
+            ],
+            value="none",
+            multi=False
+        ),
+        ], className="columnContainer"),
+        html.Div([
+        html.H3("Regularization Strength"),
+        dcc.Dropdown(
+            id="select_reg_strength",
+            options=[
+                {"value": 0.001, "label": 0.001},
+                {"value": 0.005, "label": 0.005},
+                {"value": 0.01, "label": 0.01},
+                {"value": 0.05, "label": 0.05},
+                {"value": 0.1, "label": 0.1},
+                {"value": 0.5, "label": 0.5},
+                {"value": 1.0, "label": 1.0},
+                {"value": 5.0, "label": 5.0},
+                {"value": 10.0, "label": 10.0},
+            ],
+            value=0.01,
+            multi=False
+        ),
+        ], className="columnContainer"),
     ], className="rowContainer longContainer",
         style={'justify-content': 'space-around',
                'margin': '0px'}

app/logic.py

@@ -299,13 +299,16 @@ def update_circuit_plot(num_qubits: int, num_layers: int, model_parameters: str)
     state=[
         State(component_id="select_lr", component_property="value"),
         State(component_id="select_batch_size", component_property="value"),
+        State(component_id="select_reg_type", component_property="value"),
+        State(component_id="select_reg_strength", component_property="value"),
         State(component_id="train_datastore", component_property="data"),
         State(component_id="model_parameters", component_property="data"),
     ],
 )
 def single_epoch(num_clicks: int, num_intervals: int, reset_clicks: int,
                  num_qubits: int, num_layers: int, selected_data_set: str,
-                 lr: float, batch_size: int, train_data, model_parameters):
+                 lr: float, batch_size: int, reg_type: str, reg_strength: float,
+                 train_data, model_parameters):
     """
     Performs a single training epoch for the quantum model using the provided parameters.
     
@@ -325,6 +328,10 @@ def single_epoch(num_clicks: int, num_intervals: int, reset_clicks: int,
     :type lr: float
     :param batch_size: Size of training batches
     :type batch_size: int
+    :param reg_type: Type of regularization (none, l1, l2)
+    :type reg_type: str
+    :param reg_strength: Strength of regularization
+    :type reg_strength: float
     :param train_data: Training data in JSON format
     :param model_parameters: Current model parameters
     :return: Updated model parameters and current epoch number
@@ -345,7 +352,7 @@ def single_epoch(num_clicks: int, num_intervals: int, reset_clicks: int,
     model_parameters = unserialize_model_dict(model_parameters)
     qcl.load_model(model_parameters)
 
-    qcl.train_single_epoch(df_train[["x", "y"]].values, df_train["label"].values, lr, batch_size)
+    qcl.train_single_epoch(df_train[["x", "y"]].values, df_train["label"].values, lr, batch_size, reg_type, reg_strength)
     model_parameters = qcl.save_model()
 
     return [json.dumps(model_parameters), model_parameters["config"]["epoch"]]

app/models/reuploading_classifier.py

@@ -262,7 +262,7 @@ def evaluate(self, X, y):
 
         return results
 
-    def train_single_epoch(self, X, y, lr=0.1, batch_size=32):
+    def train_single_epoch(self, X, y, lr=0.1, batch_size=32, reg_type="none", reg_strength=0.01):
         """Train the quantum model for a single epoch.
 
         This method performs one epoch of training using mini-batch gradient descent.
@@ -274,16 +274,31 @@ def train_single_epoch(self, X, y, lr=0.1, batch_size=32):
             y (numpy.ndarray): Training labels of shape (n_samples,)
             lr (float, optional): Learning rate for the optimizer. Defaults to 0.1.
             batch_size (int, optional): Size of mini-batches for training. Defaults to 32.
+            reg_type (str, optional): Type of regularization ('none', 'l1', 'l2'). Defaults to "none".
+            reg_strength (float, optional): Strength of regularization. Defaults to 0.01.
 
         Returns:
             None
         """
-        opt = Adam(self.model.parameters(), lr=lr, betas=(0.9, 0.999))
+        # Configure weight decay (L2 regularization) if selected
+        weight_decay = 0.0
+        if reg_type == "l2":
+            weight_decay = reg_strength
+            
+        opt = Adam(self.model.parameters(), lr=lr, betas=(0.9, 0.999), weight_decay=weight_decay)
 
         for Xbatch, ybatch in batch_loader(X, y, batch_size=batch_size):
             opt.zero_grad()
             output_states = self.model(Xbatch)[-1]
             loss = self.loss(output_states, ybatch)
+            
+            # Apply L1 regularization if selected
+            if reg_type == "l1":
+                l1_loss = 0
+                for param in self.model.parameters():
+                    l1_loss += torch.sum(torch.abs(param))
+                loss += reg_strength * l1_loss
+                
             loss.backward()
             opt.step()