Example #1
0
def main():
    ctrl = Controller()
    ctrl.load_dataset_from_file(DATASET_FILE_PATH)
    if MODE == MODE_TRAIN:
        from scripts.test_model import BHSMMTestModel
        from hassbrain_algorithm.models.hmm.bhmm_hp import BernoulliHMM_HandcraftedPriors
        from hassbrain_algorithm.models.tads import TADS

        if MODEL_CLASS == BHMM:
            hmm_model = BHMMTestModel(ctrl)
        elif MODEL_CLASS == BHSMM:
            hmm_model = BHSMMTestModel(ctrl)
            hmm_model.set_training_steps(50)
        elif MODEL_CLASS == BHMMPC:
            hmm_model = BernoulliHMM_HandcraftedPriors(ctrl)
        elif MODEL_CLASS == MCTADS:
            hmm_model = TADS(ctrl)
        else:
            raise ValueError

        ctrl.register_model(hmm_model, MODEL_NAME)

        # load domain knowledge
        if MODEL_CLASS == BHMMPC:
            path = '/home/cmeier/code/data/hassbrain/datasets/hass_chris_final/data/domain_knowledge.json'
            act_data, loc_data = load_domain_knowledge(path)
            ctrl.register_location_info(MODEL_NAME, loc_data)
            ctrl.register_activity_info(MODEL_NAME, act_data)

    # load model
    elif MODE == MODE_BENCH:
        ctrl.load_model(MODEL_FILE_PATH, MODEL_NAME)
    else:
        raise ValueError


    ctrl.register_benchmark(MODEL_NAME)
    ctrl.init_model_on_dataset(MODEL_NAME)
    if MODE == MODE_TRAIN:
        ctrl.register_loss_file_path(MD_LOSS_FILE_PATH, MODEL_NAME)
        ctrl.train_model(MODEL_NAME)
        ctrl.save_model(MODEL_FILE_PATH, MODEL_NAME)

    # bench the model
    reports = ctrl.bench_models()

    # save metrics
    ctrl.save_df_metrics_to_file(MODEL_NAME, MD_METRICS_FILE_PATH)
    ctrl.save_df_confusion(MODEL_NAME, MD_CONF_MAT_FILE_PATH)
    ctrl.save_df_act_dur_dists(MODEL_NAME, MD_ACT_DUR_DISTS_DF_FILE_PATH,
                               DATA_ACT_DUR_DISTS_DF_FILE_PATH)
    ctrl.save_df_class_accs(MODEL_NAME, MD_CLASS_ACTS_FILE_PATH)

    # plots
    if MODE == MODE_TRAIN and MODEL_CLASS != MCTADS:
        ctrl.save_plot_trainloss(MODEL_NAME, MD_LOSS_IMG_FILE_PATH)

    ctrl.save_plot_inferred_states(MODEL_NAME, MD_INFST_IMG_FILE_PATH)

    ctrl.save_plot_act_dur_dists([MODEL_NAME], MD_ACT_DUR_DISTS_IMG_FILE_PATH)
Example #2
0
def main():
    ctrl = Controller()
    ctrl.load_dataset_from_file(DATASET_FILE_PATH)
    from scripts.test_model import BHSMMTestModel
    from hassbrain_algorithm.models.hmm.bhmm_hp import BernoulliHMM_HandcraftedPriors
    from hassbrain_algorithm.models.tads import TADS

    if MODEL_CLASS == BHMM:
        hmm_model = BHMMTestModel(ctrl)
        hmm_model.set_training_steps(10)
    elif MODEL_CLASS == BHSMM:
        hmm_model = BHSMMTestModel(ctrl)
        hmm_model.set_training_steps(50)
    elif MODEL_CLASS == BHMMPC:
        hmm_model = BernoulliHMM_HandcraftedPriors(ctrl)
    elif MODEL_CLASS == MCTADS:
        hmm_model = TADS(ctrl)
    else:
        raise ValueError

    ctrl.register_model(hmm_model, MODEL_NAME)

    ctrl.register_benchmark(MODEL_NAME)
    ctrl.init_model_on_dataset(MODEL_NAME)
    ctrl.register_loss_file_path(MD_LOSS_FILE_PATH, MODEL_NAME)
    ctrl.train_model(MODEL_NAME)
    ctrl.save_model(MODEL_FILE_PATH, MODEL_NAME)

    # bench the model
    params = {
        'metrics': False,
        'act_dur_dist': True,
        'feature_importance': False
    }
    reports = ctrl.bench_models(**params)

    # save metrics
    #ctrl.save_df_metrics_to_file(MODEL_NAME, MD_METRICS_FILE_PATH)
    #ctrl.save_df_confusion(MODEL_NAME, MD_CONF_MAT_FILE_PATH)
    #ctrl.save_df_act_dur_dists(MODEL_NAME, MD_ACT_DUR_DISTS_DF_FILE_PATH,
    #                           DATA_ACT_DUR_DISTS_DF_FILE_PATH)
    #ctrl.save_df_class_accs(MODEL_NAME, MD_CLASS_ACTS_FILE_PATH)
    dict = {
        #'feature_importance' : MD_FEATURE_IMP_PLT_FILE_PATH,
        'train_loss': MD_LOSS_IMG_FILE_PATH,
        #'inf_states' : MD_INFST_IMG_FILE_PATH,
        'act_dur': MD_ACT_DUR_DISTS_IMG_FILE_PATH
    }
    ctrl.save_plots(MODEL_NAME, dict)
Example #3
0
def main():

    # set of observations
    ctrl = Controller()
    # todo this is only for testing interpretability
    from scripts.test_model import BHMMTestModel
    from scripts.test_model import BHSMMTestModel
    #hmm_model = BHMMTestModel(ctrl)
    hmm_model = BHSMMTestModel(ctrl)
    ctrl.load_dataset_from_file(DATASET_FILE_PATH)
    ctrl.register_model(hmm_model, MODEL_NAME)
    ctrl.register_benchmark(MODEL_NAME)
    ctrl.init_model_on_dataset(MODEL_NAME)
    #ctrl.register_loss_file_path(MD_LOSS_FILE_PATH, MODEL_NAME)
    ctrl.train_model(MODEL_NAME)
    print(MODEL_FILE_PATH)
    ctrl.save_model(MODEL_FILE_PATH, MODEL_NAME)
    print()
Example #4
0
def main():
    ctrl = Controller()
    ctrl.load_dataset_from_file(DATASET_FILE_PATH)

    #hmm_model = BHMMTestModel(ctrl)
    #hmm_model = BHSMMTestModel(ctrl)
    from hassbrain_algorithm.models.hmm.bhmm_hp import BernoulliHMM_HandcraftedPriors
    hmm_model = BernoulliHMM_HandcraftedPriors(ctrl)

    ctrl.register_model(hmm_model, MODEL_NAME)

    # load domain knowledge
    path = '/home/cmeier/code/data/hassbrain/datasets/hass_chris_final/data/domain_knowledge.json'
    act_data, loc_data = load_domain_knowledge(path)
    ctrl.register_location_info(MODEL_NAME, loc_data)
    ctrl.register_activity_info(MODEL_NAME, act_data)

    # load model
    #ctrl.load_model(MODEL_FILE_PATH, MODEL_NAME)
    from scripts.test_model import BHSMMTestModel

    ctrl.register_benchmark(MODEL_NAME)

    ctrl.init_model_on_dataset(MODEL_NAME)
    ctrl.register_loss_file_path(MD_LOSS_FILE_PATH, MODEL_NAME)
    ctrl.train_model(MODEL_NAME)

    # bench the model
    reports = ctrl.bench_models()

    # save metrics
    ctrl.save_df_metrics_to_file(MODEL_NAME, MD_METRICS_FILE_PATH)
    ctrl.save_df_confusion(MODEL_NAME, MD_CONF_MAT_FILE_PATH)
    ctrl.save_df_act_dur_dists(MODEL_NAME, MD_ACT_DUR_DISTS_DF_FILE_PATH,
                               DATA_ACT_DUR_DISTS_DF_FILE_PATH)

    # plots
    ctrl.save_plot_trainloss(MD_LOSS_IMG_FILE_PATH, MODEL_NAME)
    ctrl.plot_and_save_inferred_states(MD_INFST_IMG_FILE_PATH, MODEL_NAME)
    ctrl.save_plot_act_dur_dists(MODEL_NAME, MD_ACT_DUR_DISTS_IMG_FILE_PATH,
                                 DATA_ACT_DUR_DISTS_IMG_FILE_PATH)
Example #5
0
class TestPendigitsModel(unittest.TestCase):
    def setUp(self):
        self.ctrl = Controller()
        self.ctrl.load_dataset(Dataset.PENDIGITS)
        pd_model = ModelPendigits(self.ctrl, "test")
        self.ctrl.register_model(pd_model)
        self.dset = self.ctrl._dataset  # type: DatasetPendigits
        self.pd_model = self.ctrl._model

    def test_init_hmms(self):
        self.ctrl.init_model_on_dataset()

    def test_save_hmms(self):
        self.ctrl.init_model_on_dataset()
        self.ctrl.save_model()

    def test_load_hmms(self):
        self.ctrl.load_model()
        # attention manually refresh reference
        self.pd_model = self.ctrl._model

    def test_train_hmms(self):
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()

    def test_train_n_save_hmms(self):
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        self.ctrl.save_model()

    def test_pre_bench_hmms(self):
        self.ctrl.load_model()
        self.pd_model = self.ctrl._model
        y_true, y_pred = self.pd_model.create_pred_act_seqs(self.dset)

    def test_bench_hmms(self):
        self.ctrl.load_model()
        self.pd_model = self.ctrl._model
        self.ctrl.register_benchmark()
        rep = self.ctrl.create_report(conf_matrix=True,
                                      accuracy=True,
                                      precision=True,
                                      recall=True,
                                      f1=True)
        print(rep)

    def test_generate_obs(self):
        self.ctrl.load_model()
        self.pd_model = self.ctrl._model
        self.ctrl.generate_observations()

    def test_generate_obs_n_plot(self):
        # numbers that were good in benchmark (desc):
        # [0,8,4,9,3,7]
        self.ctrl.load_model()
        ds = self.ctrl._dataset  # type: DatasetPendigits
        pdmod = self.ctrl._model  # type: ModelPendigits

        num = 1
        zero_start = [8, 1, 1]
        one_start = [8, 2, 1, 1, 1]
        start_seq = one_start

        hmm = pdmod._model_dict[num]
        hmm.set_format_full(True)
        print(hmm)

        pdmod.select_number(num)
        seq = pdmod.generate_observations(start_seq)

        ds.plot_obs_seq(seq, num)

    def tearDown(self):
        pass
Example #6
0
class TestHomeassistantModelHMMLogScaled(unittest.TestCase):

    # Model part
    def setUp(self):
        # set of observations
        self.ctrl = Controller()
        self.ctrl.set_dataset(Dataset.HASS_TESTING)
        self.hass_obj = self.ctrl._dataset  #type: DatasetHomeassistant
        self.hmm_model = HMMForward(self.ctrl)

    def tearDown(self):
        pass

    def test_load_custom_lists_modelHMM(self):
        custom_state_list = ['sleeping', 'cooking']
        custom_obs_list = [
            'binary_sensor.motion_bed', 'binary_sensor.motion_mirror',
            'binary_sensor.motion_pc', 'switch.test_switch_1',
            'light.test_light'
        ]
        hmm_model = self.hmm_model
        self.ctrl.set_custom_state_list(custom_state_list)
        self.ctrl.set_custom_obs_list(custom_obs_list)

        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)

    def test_load_modelHMM(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)
        print(self.hass_obj.get_obs_lbl_hashmap())
        print(self.hass_obj.get_state_lbl_hashmap())

    def test_train_modelHMM(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)

        self.ctrl.train_model()
        print(self.ctrl._model)

    def test_bench_modelHMM(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)

        self.ctrl.register_benchmark()
        self.ctrl.train_model()
        print(self.ctrl._model)
        report = self.ctrl.create_report(conf_matrix=True,
                                         accuracy=True,
                                         precision=True,
                                         recall=True,
                                         f1=True)
        print(report)

    def test_classify(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        hmm_model._hmm.set_format_full(True)
        print(hmm_model)
        print('-' * 10)
        obs_seq = [('binary_sensor.motion_bed', 0),
                   ('binary_sensor.motion_mirror', 1),
                   ('binary_sensor.motion_bed', 0)]
        pred_state = hmm_model.classify(obs_seq)
        print('#' * 100)
        print(pred_state)

    def test_classify_multi(self):
        """
        used to test for classification of multiple labels
        """
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        hmm_model._hmm.set_format_full(True)
        print(hmm_model)
        print('-' * 10)
        obs_seq = [('binary_sensor.motion_bed', 0),
                   ('binary_sensor.motion_mirror', 1)
                   ]  #, ('binary_sensor.motion_bed', 0)]
        act_state_dict = hmm_model.classify_multi(obs_seq)
        print('#' * 100)
        print(act_state_dict)
        #print(act_state_dict)
        #print(hmm_model.get_state_label_list())

    def test_pred_next_obs_single(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        hmm_model._hmm.set_format_full(True)
        #print(hmm_model)
        print('#' * 100)
        obs_seq = [('binary_sensor.motion_bed', 0),
                   ('binary_sensor.motion_mirror', 1),
                   ('binary_sensor.motion_bed', 0)]
        tupel = hmm_model.predict_next_obs(obs_seq)
        print(tupel)

    def test_pred_next_obs_multi(self):
        hmm_model = self.hmm_model
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        hmm_model._hmm.set_format_full(True)
        print(hmm_model)
        print('#' * 100)
        obs_seq = [('binary_sensor.motion_bed', 0),
                   ('binary_sensor.motion_mirror', 1),
                   ('binary_sensor.motion_bed', 0)]
        #arr = hmm_model.predict_next_obs_arr(obs_seq)
        print(hmm_model._obs_lbl_hashmap)
        print(hmm_model._obs_lbl_rev_hashmap)
        res_dict = hmm_model.predict_prob_xnp1(obs_seq)
        print(hmm_model._obs_lbl_hashmap)
        print(hmm_model._obs_lbl_rev_hashmap)
        res_dict = hmm_model.predict_prob_xnp1(obs_seq)
        print(hmm_model._obs_lbl_hashmap)
        print(hmm_model._obs_lbl_rev_hashmap)
        print('#' * 100)
        print(res_dict)
Example #7
0
class TestController(unittest.TestCase):
    def setUp(self):
        # set of observations
        self.ctrl = Controller()  # type: Controller
        #self.hmm_model = ModelHMM(self.ctrl)
        #self.hmm_model = ModelHMM_scaled(self.ctrl)
        #self.hmm_model = ModelHMM_log(self.ctrl)
        self.hmm_model = ModelHMM_log_scaled(self.ctrl)

    def tearDown(self):
        pass

    def test_ctrl_get_bench_metrics(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.load_dataset(dk)
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.register_benchmark()
        self.ctrl.register
        # render
        #dot = self.ctrl.render_model()
        #dot.render('test.gv', view=True)

        self.ctrl.train_model(True)
        print(self.ctrl.get_bench_metrics())

    def test_ctrl_train_seqs(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.set_dataset(dk)
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.register_benchmark()
        # render
        #dot = self.ctrl.render_model()
        #dot.render('test.gv', view=True)

        self.ctrl.train_model()
        report = self.ctrl.create_report(conf_matrix=True,
                                         accuracy=True,
                                         precision=True,
                                         recall=True,
                                         f1=True)

        print(self.ctrl._model)
        print(report)
        #self.ctrl.show_plot()

    def test_ctrl_presentation(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.load_dataset(dk)
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.register_benchmark()
        # render
        #dot = self.ctrl.render_model()
        #dot.render('test.gv', view=True)

        self.ctrl.train_model(True)
        report = self.ctrl.create_report(conf_matrix=True,
                                         accuracy=True,
                                         precision=True,
                                         recall=True,
                                         f1=True)

        print(self.ctrl._model)
        print(report)
        #self.ctrl.show_plot()

        # render
        #dot = self.ctrl.render_model()
        #dot.render('test.gv', view=True)

    def test_generate_visualization(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.set_dataset(dk)
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print('state_label_hm: ', hmm_model._state_lbl_hashmap)
        print('state_label_rev_hm: ', hmm_model._state_lbl_rev_hashmap)
        self.ctrl.save_visualization_to_file(
            '/home/cmeier/code/tmp/visualization.png')

    def test_bench_train_loss(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.set_dataset(dk)
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.register_benchmark()
        self.ctrl.register_loss_file_path(
            '/home/cmeier/code/tmp/kasteren/train_loss.log')
        self.ctrl.train_model()
        self.ctrl.save_model(
            '/home/cmeier/code/tmp/kasteren/kasteren_model.joblib')

    def test_bench_reports_conf_matrix(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.load_dataset(dk)
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.register_benchmark()
        self.ctrl.train_model()
        report = self.ctrl.create_report(conf_matrix=True)
        print(report)

    def test_bench_reports(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.load_dataset(dk)
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.register_benchmark()
        self.ctrl.train_model()
        report = self.ctrl.create_report(conf_matrix=True,
                                         accuracy=True,
                                         precision=True,
                                         recall=True,
                                         f1=True)
        print(report)
        #self.ctrl.show_plot()

    def test_bench_q_fct(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.load_dataset(dk)
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.register_benchmark()
        print(self.ctrl._model)
        # use dataset Kasteren and q_fct
        self.ctrl.train_model(True)
        report = self.ctrl.create_report()
        print(self.ctrl._model)
        print(report)
        #self.ctrl.show_plot()

    def test_om(self):
        #plt.figure(figsize=(10,6))
        #self.pom.plot()
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.load_dataset(dk)
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        dot = self.ctrl.render_model()
        dot.render('test.gv', view=True)

    def test_train_model(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.set_dataset(dk)
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)

        self.ctrl.init_model_on_dataset()

        #print(hmm_model._hmm)
        self.ctrl.train_model()
        print('#' * 200)
        print(hmm_model)
        hmm_model._hmm.set_str_exp(True)
        hmm_model._hmm.set_format_full(True)
        print(hmm_model)
        #print(hmm_model._hmm.verify_transition_matrix())
        #print(hmm_model._hmm.verify_emission_matrix())

        #self._bench._model.draw()
        #self.ctrl.register_benchmark()
        #report = self.ctrl.create_report(True, True, True, True, True)
        #print(report)
        #self._bench.show_plot()

    def test_save_model(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.load_dataset(dk)
        self.ctrl.register_model(hmm_model)

        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)

        self.ctrl.train_model()
        self.ctrl.save_model()

    def test_init_model(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.set_dataset(dk)
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)

        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)

    def test_load_model(self):
        hmm_model = self.hmm_model
        dk = Dataset.KASTEREN
        self.ctrl.set_dataset(dk)
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)

        self.ctrl.load_model()
        print(self.ctrl._model)
Example #8
0
class TestHomeassistantModelHMMLogScaled(unittest.TestCase):

    # Model part
    def setUp(self):
        # set of observations
        self.ctrl = Controller()
        self.ctrl.set_dataset(Dataset.HASS_TESTING)
        self.hass_obj = self.ctrl._dataset #type: DatasetHomeassistant
        self.hmm_model = PreConfHMM(self.ctrl)

    def tearDown(self):
        pass

    def test_load_custom_lists_modelHMM(self):
        custom_state_list = ['sleeping', 'cooking']
        custom_obs_list = [
            'binary_sensor.motion_bed',
            'binary_sensor.motion_mirror',
            'binary_sensor.motion_pc',
            'switch.test_switch_1',
            'light.test_light'
        ]
        hmm_model = self.hmm_model
        self.ctrl.set_custom_state_list(custom_state_list)
        self.ctrl.set_custom_obs_list(custom_obs_list)

        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)

    def test_load_modelHMM(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)
        print(self.hass_obj.get_obs_lbl_hashmap())
        print(self.hass_obj.get_state_lbl_hashmap())

    def test_train_modelHMM(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)

        self.ctrl.train_model()
        print(self.ctrl._model)

    def test_bench_modelHMM(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)
        print(self.ctrl._model)

        self.ctrl.register_benchmark()
        self.ctrl.train_model()
        print(self.ctrl._model)
        report = self.ctrl.create_report(
            conf_matrix=True,
            accuracy=True,
            precision=True,
            recall=True,
            f1=True
        )
        print(report)

    def test_classify(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        hmm_model._hmm.set_format_full(True)
        print(hmm_model)
        print('-'*10)
        obs_seq = [('binary_sensor.motion_bed', 0), ('binary_sensor.motion_mirror', 1), ('binary_sensor.motion_bed', 0)]
        pred_state = hmm_model.classify(obs_seq)
        print('#'*100)
        print(pred_state)

    def test_classify_multi(self):
        """
        used to test for classification of multiple labels
        """
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        hmm_model._hmm.set_format_full(True)
        print(hmm_model)
        print('-'*10)
        obs_seq = [('binary_sensor.motion_bed', 0), ('binary_sensor.motion_mirror', 1)]#, ('binary_sensor.motion_bed', 0)]
        act_state_dict = hmm_model.classify_multi(obs_seq)
        print('#'*100)
        print(act_state_dict)
        #print(act_state_dict)
        #print(hmm_model.get_state_label_list())

    def test_pred_next_obs_single(self):
        self.ctrl.load_dataset()
        hmm_model = self.hmm_model
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        hmm_model._hmm.set_format_full(True)
        #print(hmm_model)
        print('#'*100)
        obs_seq = [('binary_sensor.motion_bed', 0), ('binary_sensor.motion_mirror', 1), ('binary_sensor.motion_bed', 0)]
        tupel = hmm_model.predict_next_obs(obs_seq)
        print(tupel)

    def test_pred_next_obs_multi(self):
        hmm_model = self.hmm_model
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        self.ctrl.train_model()
        hmm_model._hmm.set_format_full(True)
        print(hmm_model)
        print('#'*100)
        obs_seq = [('binary_sensor.motion_bed', 0), ('binary_sensor.motion_mirror', 1), ('binary_sensor.motion_bed', 0)]
        #arr = hmm_model.predict_next_obs_arr(obs_seq)
        print(hmm_model._obs_lbl_hashmap)
        print(hmm_model._obs_lbl_rev_hashmap)
        res_dict = hmm_model.predict_prob_xnp1(obs_seq)
        print(hmm_model._obs_lbl_hashmap)
        print(hmm_model._obs_lbl_rev_hashmap)
        res_dict = hmm_model.predict_prob_xnp1(obs_seq)
        print(hmm_model._obs_lbl_hashmap)
        print(hmm_model._obs_lbl_rev_hashmap)
        print('#'*100)
        print(res_dict)


    def test_encode_loc_data(self):
        loc_data = [ {
            "name" : "loc1",
            "activities" : ['cooking'],
            "devices" : ['binary_sensor.motion_hallway', 'binary_sensor.motion_mirror'],
            },
            {"name" : "loc2",
            "activities" : ['cooking', 'eating'],
            "devices" : [],
            },
            {"name" : "loc3",
            "activities" : ['sleeping'],
            "devices" : ['binary_sensor.motion_bed'],
            },
        ]

        hmm_model = self.hmm_model
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        hmm_model._hmm.set_format_full(True)

        #print('state_hm: ', hmm_model._state_lbl_hashmap)
        #print('obs_hm: ', hmm_model._obs_lbl_hashmap)

        #print('raw_loc_data: \t' + str(loc_data))
        enc_loc_data = hmm_model._encode_location_data(loc_data)
        #print('#'*100)
        #print('enc_loc_data: \t' + str(enc_loc_data))

    def test_encode_act_data(self):
        act_data = [
            {"name" : "cooking",
            "day_of_week" : 2,
            "start" : datetime.time.fromisoformat("06:15:00"),
            "end" : datetime.time.fromisoformat("08:45:00")
            },
            {"name" : "eating",
            "day_of_week" : 1,
            "start" : datetime.time.fromisoformat("06:15:00"),
            "end" : datetime.time.fromisoformat("08:45:00")
            },
            {"name" : "eating",
            "day_of_week" : 1,
            "start" : datetime.time.fromisoformat("08:46:00"),
            "end" : datetime.time.fromisoformat("10:00:00")
            },
        ]

        hmm_model = self.hmm_model
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.init_model_on_dataset()
        print('raw_act_data: \t' + str(act_data))
        print('state_hm: ', hmm_model._state_lbl_hashmap)
        print('obs_hm: ', hmm_model._obs_lbl_hashmap)
        print('#'*100)
        enc_act_data = hmm_model._encode_act_data(act_data)
        print('enc_act_data: \t' + str(enc_act_data))


    def test_init(self):
        loc_data = [ {
            "name" : "loc1",
            "activities" : ['cooking'],
            "devices" : ['binary_sensor.motion_hallway', 'binary_sensor.motion_mirror'],
        },
            {"name" : "loc2",
             "activities" : ['cooking', 'eating'],
             "devices" : [],
             },
            {"name" : "loc3",
             "activities" : ['sleeping'],
             "devices" : ['binary_sensor.motion_bed'],
             },
        ]

        act_data = [
            {"name" : "sleeping",
            "day_of_week" : 0,
            "start" : datetime.time.fromisoformat("04:00:00"),
            "end" : datetime.time.fromisoformat("06:15:00")
            },
            {"name" : "cooking",
            "day_of_week" : 0,
            "start" : datetime.time.fromisoformat("06:15:00"),
            "end" : datetime.time.fromisoformat("08:45:00")
            },
            {"name" : "eating",
            "day_of_week" : 0,
            "start" : datetime.time.fromisoformat("08:46:00"),
            "end" : datetime.time.fromisoformat("10:00:00")
            },
            {"name" : "sleeping",
            "day_of_week" : 0,
            "start" : datetime.time.fromisoformat("12:00:00"),
            "end" : datetime.time.fromisoformat("13:00:00")
            },
            {"name" : "sleeping",
            "day_of_week" : 1,
            "start" : datetime.time.fromisoformat("02:00:00"),
            "end" : datetime.time.fromisoformat("06:30:00")
            },
            {"name" : "cooking",
            "day_of_week" : 1,
            "start" : datetime.time.fromisoformat("12:00:00"),
            "end" : datetime.time.fromisoformat("13:00:00")
            },
            {"name" : "cooking",
            "day_of_week" : 2,
            "start" : datetime.time.fromisoformat("19:00:00"),
            "end" : datetime.time.fromisoformat("00:00:00")
            },
            {"name" : "cooking",
            "day_of_week" : 2,
            "start" : datetime.time.fromisoformat("23:00:00"),
            "end" : datetime.time.fromisoformat("00:00:00")
            },
            {"name" : "sleeping",
            "day_of_week" : 2,
            "start" : datetime.time.fromisoformat("00:00:00"),
            "end" : datetime.time.fromisoformat("03:00:00")
            },
        ]

        hmm_model = self.hmm_model
        self.ctrl.load_dataset()
        self.ctrl.register_model(hmm_model)
        self.ctrl.register_location_info(loc_data)
        print('raw_act_data: \t' + str(act_data))
        print('state_hm: ', hmm_model._state_lbl_hashmap)
        #print('obs_hm: ', hmm_model._obs_lbl_hashmap)
        self.ctrl.register_activity_info(act_data)
        #print('#'*100)
        #enc_act_data = hmm_model._encode_act_data(act_data)
        #print('enc_act_data: \t' + str(enc_act_data))
        self.ctrl.init_model_on_dataset()
        hmm = hmm_model._hmm
        hmm.set_format_full(True)

        self.assertAlmostEqual(1.0, Probs.prob_to_norm(hmm._pi.sum()), 6)
        self.assertTrue(hmm.verify_emission_matrix())
        self.assertTrue(hmm.verify_transition_matrix())