Esempio n. 1
0
    def test_check_completed_ps__return_false_when_no_callback_executed(self):
        sim = self.build_simulator()
        self.build_ps(sim, 1)
        ps = sim.parameter_sets().first()
        self.build_run(ps, 1, 0)

        w = oacis.OacisWatcher()
        w.watch_ps(ps, lambda x: None)
        ret = w._check_completed_ps()
        self.assertFalse(ret)
Esempio n. 2
0
    def test_watch_ps(self):
        sim = self.build_simulator()
        self.build_ps(sim, 1)
        ps = sim.parameter_sets().first()
        w = oacis.OacisWatcher()
        self.assertEqual(len(w._observed_parameter_sets), 0)
        w.watch_ps(ps, lambda x: None)
        self.assertEqual(len(w._observed_parameter_sets), 1)

        w.watch_ps(ps, lambda x: None)
        self.assertEqual(len(w._observed_parameter_sets[ps.id().to_s()]), 2)
Esempio n. 3
0
 def test_completed_ps_ids(self):
     sim = self.build_simulator()
     self.build_ps(sim, 2)
     ps1 = sim.parameter_sets().asc('id').first()
     ps2 = sim.parameter_sets().asc('id').last()
     self.build_run(ps1, 0, 2)
     self.build_run(ps2, 1, 1)
     w = oacis.OacisWatcher()
     psids = [ps1.id().to_s(), ps2.id().to_s()]
     finished = w._completed_ps_ids(psids)
     self.assertEqual(finished, [ps1.id().to_s()])
Esempio n. 4
0
    def test_watch_all_ps(self):
        sim = self.build_simulator()
        self.build_ps(sim, 2)
        ps = sim.parameter_sets().first()
        w = oacis.OacisWatcher()

        self.assertEqual(len(w._observed_parameter_sets_all), 0)
        w.watch_all_ps(sim.parameter_sets(), lambda pss: None)
        self.assertEqual(len(w._observed_parameter_sets_all), 1)
        w.watch_all_ps(sim.parameter_sets(), lambda pss: None)
        psids = tuple(sorted([ps.id().to_s() for ps in sim.parameter_sets()]))
        self.assertEqual(len(w._observed_parameter_sets_all[psids]), 2)
Esempio n. 5
0
    def test_check_completed_ps_all__callback(self):
        sim = self.build_simulator()
        self.build_ps(sim, 2)
        for ps in sim.parameter_sets():
            self.build_run(ps, 0, 2)

        mock1 = MagicMock()
        w = oacis.OacisWatcher()
        w.watch_all_ps(sim.parameter_sets(), mock1)
        ret = w._check_completed_ps_all()
        mock1.assert_called_with(sim.parameter_sets().asc('id'))
        self.assertTrue(ret)
Esempio n. 6
0
def map_agents(agents):
    parameter_sets = []
    for x in agents:
        ps = sim.find_or_create_parameter_set( {'p1':x[0], 'p2':x[1]} )
        runs = ps.find_or_create_runs_upto(1, submitted_to=host)
        print("Created a new PS: %s" % str(ps.id()) )
        parameter_sets.append(ps)
    w = oacis.OacisWatcher()
    w.watch_all_ps( parameter_sets, lambda x: None )  # Wait until all parameter_sets complete
    print("loop is called")
    w.loop()
    results = [ps.runs().first().result()['f'] for ps in parameter_sets]
    return results
Esempio n. 7
0
    def test_completed(self):
        sim = self.build_simulator()
        self.build_ps(sim, 1)
        ps = sim.parameter_sets().first()
        self.build_run(ps, 1, 2)
        assert ps.runs().count() == 3
        assert ps.runs().where(status='created').count() == 1
        assert ps.runs().where(status='finished').count() == 2
        w = oacis.OacisWatcher()
        self.assertFalse(w._completed(ps))

        ps.runs().where(status='created').first().update_attribute(
            'status', 'finished')
        self.assertTrue(w._completed(ps))
Esempio n. 8
0
    def test_check_completed_ps_all__not_called(self):
        sim = self.build_simulator()
        self.build_ps(sim, 2)
        ps1 = sim.parameter_sets().asc('id').first()
        self.build_run(ps1, 0, 2)
        ps2 = sim.parameter_sets().asc('id').last()
        self.build_run(ps2, 1, 1)

        mock1 = MagicMock()
        w = oacis.OacisWatcher()
        w.watch_all_ps([ps1, ps2], mock1)
        ret = w._check_completed_ps_all()
        mock1.assert_not_called()
        self.assertFalse(ret)
Esempio n. 9
0
    def test_check_completed_ps__callback(self):
        sim = self.build_simulator()
        self.build_ps(sim, 2)
        ps1 = sim.parameter_sets().asc('id').first()
        ps2 = sim.parameter_sets().asc('id').last()
        self.build_run(ps1, 0, 2)
        self.build_run(ps2, 1, 1)

        mock1 = MagicMock()
        mock2 = MagicMock()

        w = oacis.OacisWatcher()
        w.watch_ps(ps1, mock1)
        w.watch_ps(ps2, mock2)
        w._check_completed_ps()
        mock1.assert_called_with(ps1)
        mock2.assert_not_called()
Esempio n. 10
0
    def test_check_completed_ps__stop_calling(self):
        sim = self.build_simulator()
        self.build_ps(sim, 1)
        ps = sim.parameter_sets().first()
        self.build_run(ps, 0, 1)

        mock1 = MagicMock()
        mock2 = MagicMock()

        def callback1(ps):
            mock1()
            h = ps.simulator().executable_on().first()
            ps.runs().create(submitted_to=h)

        w = oacis.OacisWatcher()
        w.watch_ps(ps, callback1)
        w.watch_ps(ps, mock2)
        ret = w._check_completed_ps()
        mock1.assert_called_with()
        mock2.assert_not_called()
        self.assertTrue(ret)
Esempio n. 11
0
    def test_check_completed_ps__recursive_call(self):
        sim = self.build_simulator()
        self.build_ps(sim, 2)
        ps1 = sim.parameter_sets().asc('id').first()
        self.build_run(ps1, 0, 1)
        ps2 = sim.parameter_sets().asc('id').last()
        self.build_run(ps2, 0, 1)

        mock1 = MagicMock()
        w = oacis.OacisWatcher()

        def callback(ps_list):
            w.watch_all_ps([ps2], mock1)

        w.watch_all_ps([ps1], callback)
        ret = w._check_completed_ps_all()
        self.assertTrue(ret)
        mock1.assert_not_called()

        ret = w._check_completed_ps_all()
        self.assertTrue(ret)
        mock1.assert_called()
        'p2': (4, 9)
    },
                              random_state=1234)

    def _set_init_points():
        query = {"v." + k: v for k, v in base_param.items()}
        pss = sim.parameter_sets().where(query)
        p1_list = []
        p2_list = []
        #target_list = []
        for ps in pss:
            p1_list.append(math.log2(ps.v()["dense1_size"]))
            p2_list.append(math.log2(ps.v()["dense2_size"]))
            #target_list.append( ps.average_result("test_loss")[0] )
        print(p1_list, p2_list)  #, target_list)
        #bo.initialize( {'target': target_list, "p1": p1_list, "p2": p2_list} )
        bo.explore({"p1": p1_list, "p2": p2_list})

    _set_init_points()
    #bo.maximize(n_iter=1, kappa=2)
    bo.maximize(init_points=0, n_iter=10, kappa=2)
    opt_dense1_size = int(2**bo.res['max']['max_params']['p1'])
    opt_dense2_size = int(2**bo.res['max']['max_params']['p2'])
    print(bo.res['max'], opt_dense1_size, opt_dense2_size)
    print(bo.res['all'])


w = oacis.OacisWatcher()
w. async (search_optimum)
w.loop()