Fbopt_depreciated

domainlab/algos/trainers/fbopt.py

@@ -0,0 +1,95 @@
+"""
+update hyper-parameters during training
+"""
+import copy
+from domainlab.utils.logger import Logger
+
+
+class HyperSchedulerFeedback():
+    """
+    design $\\mu$$ sequence based on state of penalized loss
+    """
+    def __init__(self, trainer, **kwargs):
+        """
+        kwargs is a dictionary with key the hyper-parameter name and its value
+        """
+        self.trainer = trainer
+        self.mmu = kwargs
+        self.mmu = {key: 0.0 for key, val in self.mmu.items()}
+        self.ploss_old_theta_old_mu = None
+        self.ploss_old_theta_new_mu = None
+        self.ploss_new_theta_old_mu = None
+        self.ploss_new_theta_new_mu = None
+        self.delta_mu = 0.01   # FIXME
+        self.dict_theta = None
+        self.budget_mu_per_step = 5  # FIXME
+        self.budget_theta_update_per_mu = 5  # np.infty
+
+    def search_mu(self, dict_theta):
+        """
+        start from parameter dict_theta,
+        enlarge mmu to see if the criteria is met
+        """
+        self.dict_theta = dict_theta
+        mmu = None
+        for miter in range(self.budget_mu_per_step):
+            # FIXME: the same mu is tried two times since miter=0
+            mmu = self.dict_addition(self.mmu, miter * self.delta_mu)
+            print(f"trying mu={mmu} at mu iteration {miter}")
+            if self.search_theta(mmu):
+                print(f"!!!found reg-pareto operator with mu={mmu}")
+                self.mmu = mmu
+                return True
+        logger = Logger.get_logger(logger_name='main_out_logger', loglevel="INFO")
+        logger.warn(f"!!!!!!failed to find mu within budget, mu={mmu}")
+        return False
+
+    def dict_addition(self, dict_base, delta):
+        """
+        increase the value of a dictionary by delta
+        """
+        return {key: val + delta for key, val in dict_base.items()}
+
+    def search_theta(self, mmu_new):
+        """
+        conditioned on fixed $$\\mu$$, the operator should search theta based on
+        the current value of $theta$
+
+        the execution will set the value for mu and theta as well
+        """
+        flag_success = False
+        self.ploss_old_theta_new_mu = self.trainer.eval_loss(mmu_new, self.dict_theta)
+        self.ploss_old_theta_old_mu = self.trainer.eval_loss(self.mmu, self.dict_theta)
+        theta4mu_new = copy.deepcopy(self.dict_theta)
+        for i in range(self.budget_theta_update_per_mu):
+            print(f"update theta at iteration {i} with mu={mmu_new}")
+            theta4mu_new = self.trainer.opt_theta(mmu_new, theta4mu_new)
+            self.ploss_new_theta_new_mu = self.trainer.eval_loss(mmu_new, theta4mu_new)
+            self.ploss_new_theta_old_mu = self.trainer.eval_loss(self.mmu, theta4mu_new)
+            if self.is_criteria_met():
+                self.mmu = mmu_new
+                flag_success = True
+                # FIXME: update theta only if current mu is good enough?
+                self.dict_theta = theta4mu_new
+                return flag_success
+        return flag_success
+
+    def inner_product(self, mmu, v_reg_loss):
+        """
+        - the first dimension of the tensor v_reg_loss is mini-batch
+        the second dimension is the number of regularizers
+        - the vector mmu has dimension the number of regularizers
+        """
+        return mmu * v_reg_loss  #
+
+    def is_criteria_met(self):
+        """
+        if the reg-descent criteria is met
+        """
+        flag_improve = self.ploss_new_theta_new_mu < self.ploss_old_theta_new_mu
+        flag_deteriorate = self.ploss_new_theta_old_mu > self.ploss_old_theta_old_mu
+        return flag_improve & flag_deteriorate
+
+    def __call__(self, epoch):
+        """
+        """

domainlab/algos/trainers/train_fbopt.py

@@ -0,0 +1,99 @@
+"""
+feedback optimization
+"""
+import copy
+
+from domainlab.algos.trainers.a_trainer import AbstractTrainer
+from domainlab.algos.trainers.train_basic import TrainerBasic
+from domainlab.algos.trainers.fbopt import HyperSchedulerFeedback
+
+
+class HyperSetter():
+    """
+    mock object to force hyper-parameter in the model
+    """
+    def __init__(self, dict_hyper):
+        self.dict_hyper = dict_hyper
+
+    def __call__(self, epoch=None):
+        return self.dict_hyper
+
+
+class TrainerFbOpt(AbstractTrainer):
+    """
+    feedback optimization
+    """
+    def set_scheduler(self, scheduler=HyperSchedulerFeedback):
+        """
+        Args:
+            scheduler: The class name of the scheduler, the object corresponding to
+            this class name will be created inside model
+        """
+        # model.hyper_init will register the hyper-parameters of the model to scheduler
+        self.hyper_scheduler = self.model.hyper_init(scheduler, trainer=self)
+
+    def before_tr(self):
+        """
+        before training begins, construct helper objects
+        """
+        self.set_scheduler(scheduler=HyperSchedulerFeedback)
+        self.model.evaluate(self.loader_te, self.device)
+        self.inner_trainer = TrainerBasic()  # look ahead
+        # here we need a mechanism to generate deep copy of the model
+        self.inner_trainer.init_business(
+            copy.deepcopy(self.model), self.task, self.observer, self.device, self.aconf,
+            flag_accept=False)
+
+    def opt_theta(self, dict4mu, dict_theta0):
+        """
+        operator for theta, move gradient for one epoch, then check if criteria is met
+        this method will be invoked by the hyper-parameter scheduling object
+        """
+        self.inner_trainer.model.set_params(dict_theta0)
+        # mock the model hyper-parameter to be from dict4mu
+        self.inner_trainer.model.hyper_update(epoch=None, fun_scheduler=HyperSetter(dict4mu))
+        # hide implementation details of inner_trainer
+        for _, (tensor_x, vec_y, vec_d, *others) in enumerate(self.inner_trainer.loader_tr):
+            self.inner_trainer.train_batch(tensor_x, vec_y, vec_d, others)  # update inner_net
+        dict_par = dict(self.inner_trainer.model.named_parameters())
+        return dict_par
+
+    def eval_loss(self, dict4mu, dict_theta):
+        """
+        evaluate the penalty function value
+        """
+        temp_model = copy.deepcopy(self.model)
+        # mock the model hyper-parameter to be from dict4mu
+        temp_model.hyper_update(epoch=None, fun_scheduler=HyperSetter(dict4mu))
+        temp_model.set_params(dict_theta)
+        epo_reg_loss = 0
+        # FIXME: check if reg is decreasing
+        epo_task_loss = 0
+        epo_p_loss = 0  # penalized loss
+        # FIXME: will loader be corupted? if called at different places? if we do not make deep copy
+        for _, (tensor_x, vec_y, vec_d, *_) in enumerate(self.loader_tr):
+            tensor_x, vec_y, vec_d = \
+                tensor_x.to(self.device), vec_y.to(self.device), vec_d.to(self.device)
+            b_reg_loss = temp_model.cal_reg_loss(tensor_x, vec_y, vec_d).sum()
+            b_task_loss = temp_model.cal_task_loss(tensor_x, vec_y).sum()
+            # sum will kill the dimension of the mini batch
+            b_p_loss = temp_model.cal_loss(tensor_x, vec_y, vec_d).sum()
+            epo_reg_loss += b_reg_loss
+            epo_task_loss += b_task_loss
+            epo_p_loss += b_p_loss
+        return epo_p_loss
+
+    def tr_epoch(self, epoch):
+        self.model.train()
+        flag_success = self.hyper_scheduler.search_mu(
+            dict(self.model.named_parameters()))   # if mu not found, will terminate
+        if flag_success:
+            # only in success case, mu will be updated
+            self.model.set_params(self.hyper_scheduler.dict_theta)
+        else:
+            # if failed to find reg-pareto descent operator, continue training
+            theta = dict(self.model.named_parameters())
+            dict_par = self.opt_theta(self.hyper_scheduler.mmu, copy.deepcopy(theta))
+            self.model.set_params(dict_par)
+        flag_stop = self.observer.update(epoch)  # FIXME: should count how many epochs were used
+        return flag_stop

domainlab/algos/trainers/train_hyper_scheduler.py

@@ -26,6 +26,7 @@ def set_scheduler(self, scheduler, total_steps,
             flag_update_batch: if hyper-parameters should be changed per batch
         """
         self.hyper_scheduler = self.model.hyper_init(scheduler)
+        # let model register its hyper-parameters to the scheduler
         self.flag_update_hyper_per_epoch = flag_update_epoch
         self.flag_update_hyper_per_batch = flag_update_batch
         self.hyper_scheduler.set_steps(total_steps=total_steps)

domainlab/algos/trainers/zoo_trainer.py

@@ -6,6 +6,7 @@
 from domainlab.algos.trainers.train_matchdg import TrainerMatchDG
 from domainlab.algos.trainers.train_mldg import TrainerMLDG
 from domainlab.algos.trainers.train_hyper_scheduler import TrainerHyperScheduler
+from domainlab.algos.trainers.train_fbopt import TrainerFbOpt
 
 
 class TrainerChainNodeGetter(object):
@@ -38,6 +39,7 @@ def __call__(self, lst_candidates=None, default=None, lst_excludes=None):
         chain = TrainerDIAL(chain)
         chain = TrainerMatchDG(chain)
         chain = TrainerMLDG(chain)
-        chain = TrainerHyperScheduler(chain)  # FIXME: change to warmup
+        chain = TrainerHyperScheduler(chain)
+        chain = TrainerFbOpt(chain)
         node = chain.handle(self.request)
         return node

domainlab/models/a_model.py

@@ -11,6 +11,13 @@ class AModel(nn.Module, metaclass=abc.ABCMeta):
     """
     operations that all models (classification, segmentation, seq2seq)
     """
+    def set_params(self, dict_params):
+        """
+        set
+        """
+        # FIXME: net1.load_state_dict(net2.state_dict()) contains more information than model.named_parameters() like optimizer status
+        self.load_state_dict(dict_params, strict=False)
+
     def cal_loss(self, tensor_x, tensor_y, tensor_d=None, others=None):
         """
         calculate the loss

domainlab/models/model_dann.py

@@ -16,7 +16,7 @@ def mk_dann(parent_class=AModelClassif):
         The model is trained to solve two tasks:
         1. Standard image classification.
         2. Domain classification.
-        Here for, a feature extractor is adversarially trained to minimize the loss of the image 
+        Here for, a feature extractor is adversarially trained to minimize the loss of the image
         classifier and maximize the loss of the domain classifier.
         For more details, see:
         Ganin, Yaroslav, et al. "Domain-adversarial training of neural networks."
@@ -66,11 +66,11 @@ def hyper_update(self, epoch, fun_scheduler):
             dict_rst = fun_scheduler(epoch)  # the __call__ method of hyperparameter scheduler
             self.alpha = dict_rst["alpha"]
 
-        def hyper_init(self, functor_scheduler):
+        def hyper_init(self, functor_scheduler, trainer=None):
             """hyper_init.
             :param functor_scheduler:
             """
-            return functor_scheduler(alpha=self.alpha)
+            return functor_scheduler(trainer=trainer, alpha=self.alpha)
 
         def cal_logit_y(self, tensor_x):  # FIXME: this is only for classification
             """

run_fbopt.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+# export CUDA_VISIBLE_DEVICES=""   
+# although garbage collector has been explicitly called, sometimes there is still CUDA out of memory error
+# so it is better not to use GPU to do the pytest to ensure every time there is no CUDA out of memory error occuring
+# pytest -s tests/test_fbopt.py
+python main_out.py --te_d=caltech --task=mini_vlcs --bs=16 --aname=dann --trainer=fbopt --nname=alexnet --epos=20

run_fbopt_pacs.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+# export CUDA_VISIBLE_DEVICES=""   
+# although garbage collector has been explicitly called, sometimes there is still CUDA out of memory error
+# so it is better not to use GPU to do the pytest to ensure every time there is no CUDA out of memory error occuring
+# pytest -s tests/test_fbopt.py
+python main_out.py --te_d=sketch --tpath=examples/tasks/task_pacs_path_list.py --bs=4 --aname=dann --trainer=fbopt --nname=alexnet --epos=20

tests/test_fbopt.py

@@ -0,0 +1,12 @@
+"""
+unit and end-end test for deep all, mldg
+"""
+from tests.utils_test import utils_test_algo
+
+
+def test_deepall_fbopt():
+    """
+    train DeepAll with MLDG
+    """
+    args = "--te_d=caltech --task=mini_vlcs --debug --bs=2 --aname=dann --trainer=fbopt --nname=alexnet --epos=3"
+    utils_test_algo(args)