Esempio n. 1
0
 def setUp(self):
     self.model = Model(model_nm="Test model", grp_struct=DEF_GRP_STRUCT)
     self.exec_key = self.model.exec_key
     self.agent = Agent("Test agent", exec_key=self.model.exec_key)
     self.agent2 = Agent("Test agent 2", exec_key=self.model.exec_key)
     self.blue_grp = get_agent(BLUE_GRP_NM, self.exec_key)
     self.red_grp = get_agent(RED_GRP_NM, self.exec_key)
Esempio n. 2
0
 def setUp(self):
     self.exec_key = get_exec_key()
     self.env = Env("test_env", exec_key=self.exec_key)
     (self.space, self.newton) = create_space(self.exec_key)
     self.test_agent = Agent("test agent", exec_key=self.exec_key)
     self.test_agent2 = Agent("test agent 2", exec_key=self.exec_key)
     self.test_agent3 = Agent("test agent 3", exec_key=self.exec_key)
     self.test_agent4 = Agent("test agent 4", exec_key=self.exec_key)
Esempio n. 3
0
 def setUp(self):
     self.ff = ForestFire(MODEL_NAME, grp_struct=ff_grps)
     '''
     self.htree = plant_tree("htree", 1,
                             exec_key=self.ff.exec_key)
     self.oftree = plant_tree("oftree", 1, state=OF,
                              exec_key=self.ff.exec_key)
     '''
     self.htree = Agent(name="htree", exec_key=self.ff.exec_key)
     self.oftree = Agent(name="oftree", exec_key=self.ff.exec_key)
Esempio n. 4
0
    def test_should_only_pickle_once(self, dump, load):
        agent1 = Agent("test_agent1", action=self.agent_action,
                       exec_key=self.exec_key)
        agent2 = Agent("test_agent2", action=self.agent_action,
                       exec_key=self.exec_key)
        registry.save_reg(self.exec_key)
        self.assertTrue(registry[self.exec_key]['functions'] is not None)

        pickle_files = list(
            filter(lambda file: 'agent-agent_action.pkl' in file,
                   [value for value in registry[self.exec_key]
                   ['functions'].values()]))

        self.assertTrue(len(pickle_files) != 0)
        self.assertTrue(len(pickle_files) == 1)
Esempio n. 5
0
def create_littlewood():
    return Agent("Littlewood",
                 exec_key=exec_key,
                 attrs={
                     "friend": 141.0,
                     "number": 1729.0
                 })
Esempio n. 6
0
def create_ramsey():
    return Agent("Ramsey",
                 exec_key=exec_key,
                 attrs={
                     "friend": 282.9,
                     "number": 3.14
                 })
Esempio n. 7
0
    def __json_to_object(self, serial_obj, exec_key):
        """
        Takes a serial JSON object back into a live Python object.
        """
        restored_obj = dict()
        restored_groups = []
        model_deserialized = False
        for obj_name in serial_obj:
            should_restore_object = isinstance(serial_obj[obj_name],
                                               dict) and "type" in serial_obj[
                                        obj_name]
            if should_restore_object:
                if serial_obj[obj_name]["type"] == "TestUser":
                    restored_obj[obj_name] = TermUser(name=obj_name,
                                                      serial_obj=serial_obj[
                                                          obj_name],
                                                      exec_key=exec_key)
                if serial_obj[obj_name]["type"] == "APIUser":
                    restored_obj[obj_name] = APIUser(name=obj_name,
                                                     serial_obj=serial_obj[
                                                         obj_name],
                                                     exec_key=exec_key)
                if serial_obj[obj_name]["type"] == "Agent":
                    restored_obj[obj_name] = Agent(name=obj_name,
                                                   serial_obj=serial_obj[
                                                       obj_name],
                                                   exec_key=exec_key)
                elif serial_obj[obj_name]["type"] == "Model":
                    from lib.model import Model
                    print(f'restoring model for key {exec_key}')
                    restored_obj[obj_name] = Model(exec_key=exec_key,
                                                   serial_obj=serial_obj[
                                                       obj_name])
                    model_deserialized = True
                elif serial_obj[obj_name]["type"] == "Group":
                    from lib.group import Group
                    restored_obj[obj_name] = Group(exec_key=exec_key,
                                                   serial_obj=serial_obj[
                                                       obj_name],
                                                   name=serial_obj[obj_name][
                                                       'name'])
                    restored_groups.append(restored_obj[obj_name])
                elif serial_obj[obj_name]["type"] == "Env":
                    restored_obj[obj_name] = Env(exec_key=exec_key,
                                                 serial_obj=serial_obj[
                                                     obj_name],
                                                 name=serial_obj[obj_name][
                                                     'name'])
            else:
                restored_obj[obj_name] = serial_obj[obj_name]

            self.registries[exec_key][obj_name] = restored_obj[obj_name]

        if model_deserialized:
            restored_obj['model'].groups = restored_groups
            restored_obj['model'].env = restored_obj['env']
            self.registries[exec_key]['model'] = restored_obj['model']
        return restored_obj
Esempio n. 8
0
    def exec_trade():
        """
        本番トレード実行
        """

        # トレード時間のみトレードを実行
        now = datetime.now()
        judge_trade_time = JudgeTradeTime(date_time=now)
        if judge_trade_time.is_trade_time():

            # webから現在価格を取得(ついでにDBに格納)
            price = ScrapeRate().get_rate()

            # agent, chart_monitorを初期化
            chart_monitor = ChartMonitor()
            chart_monitor.get_saved_data()  # 最新のデータで更新
            agent = Agent(price)
            agent.get_saved_data()  # 最新のデータで更新

            # 取引の実行
            date_time = datetime.now()
            if chart_monitor.identify_chart(price, date_time):
                has_trade = agent.monitor_transition(
                    chart_monitor.current_rate, chart_monitor.prev_top,
                    chart_monitor.prev_bottom, chart_monitor.has_over_top,
                    chart_monitor.has_bellow_bottom)

                # 取引記録をデータベースに保存
                agent.save_log(date_time=chart_monitor.datetime,
                               has_trade=has_trade)

            chart_monitor.save_log()
Esempio n. 9
0
def create_other_leibniz():
    return Agent("Leibniz",
                 attrs={
                     "place": 1.0,
                     "time": LEIBBYEAR
                 },
                 action=leib_action,
                 exec_key=exec_key,
                 duration=20)
Esempio n. 10
0
def create_wine(name, i, action=None, **kwargs):
    return Agent(WINE_AGENT,
                 action=seek_a_trade,
                 attrs={
                     GOODS: wine_goods,
                     UTIL: 0,
                     PRE_TRADE_UTIL: 0,
                     TRADE_WITH: "Cheese holders"
                 },
                 **kwargs)
Esempio n. 11
0
def create_tsetter(name, i, props=None, color=RED_SIN, action=None,
                   exec_key=0):
    """
    Create a trendsetter: all RED to start.
    """
    return Agent(TSETTER_PRENM + str(i),
                 action=action,
                 exec_key=exec_key,
                 attrs={COLOR_PREF: color,
                        DISPLAY_COLOR: color})
Esempio n. 12
0
def create_follower(name, i, props=None, color=BLUE_SIN, action=None,
                    exec_key=0):
    """
    Create a follower: all BLUE to start.
    """
    return Agent(FOLLOWER_PRENM + str(i),
                 action=action,
                 exec_key=exec_key,
                 attrs={COLOR_PREF: color,
                        DISPLAY_COLOR: color})
Esempio n. 13
0
def create_cheese(name, i, action=None, **kwargs):
    return Agent(CHEESE_AGENT,
                 action=seek_a_trade,
                 attrs={
                     GOODS: cheese_goods,
                     UTIL: 0,
                     PRE_TRADE_UTIL: 0,
                     TRADE_WITH: "Wine holders"
                 },
                 **kwargs)
Esempio n. 14
0
def create_newton():
    return Agent("Newton",
                 attrs={
                     "place": 0.0,
                     "time": 1658.0,
                     "achieve": 43.9
                 },
                 action=newt_action,
                 exec_key=exec_key,
                 duration=30)
Esempio n. 15
0
def create_bb(name, **kwargs):
    """
    Create a big box store.
    """
    return Agent(name=name,
                 attrs={
                     "expense": bb_expense,
                     "capital": bb_capital
                 },
                 action=bb_action)
Esempio n. 16
0
def create_bb(name, mbr_id, bb_capital, action=None, **kwargs):
    """
    Create a big box store.
    """
    return Agent(name=name + str(mbr_id),
                 action=retailer_action,
                 attrs={
                     EXPENSE: bb_expense,
                     CAPITAL: bb_capital
                 },
                 **kwargs)
Esempio n. 17
0
def create_mp(store_grp, i, **kwargs):
    """
    Create a mom and pop store.
    """
    return Agent(name=str(store_grp) + " " + str(i),
                 attrs={
                     "expense": mp_stores[store_grp]["per_expense"],
                     "capital": mp_stores[store_grp]["init_capital"]
                 },
                 action=mp_action,
                 **kwargs)
Esempio n. 18
0
def place_agent(agent, state=CM, **kwargs):
    """
    Place a new agent.
    By default, they start out calm.
    """
    name = AGENT_PREFIX
    if(state == CM):
        agent = Agent(name,
                      action=agent_action,
                      attrs={"state": state,
                             "save_neighbors": True})
        return agent
    agent = Agent(name,
                  action=agent_action,
                  attrs={"state": state,
                         "save_neighbors": True})
    for x in range(grid_width):
        for y in range(grid_height):
            dist = random.random()
            if per_panic > dist:
                agent = Agent(name=("(%d,%d)" % (x, y)),
                              action=agent_action,
                              attrs={"state": PN,
                              "save_neighbors": True},
                              execution_key=execution_key)
                loc = eval(agent.name)
                panic += agent
                get_env().place_member(agent, xy=loc)
                # place_agent(agent, state=PN)
            else:
                agent = Agent(name=("(%d,%d)" % (x, y)),
                              action=agent_action,
                              attrs={"state": CM,
                              "save_neighbors": True},
                              execution_key=execution_key)
                loc = eval(agent.name)
                calm += agent
                get_env().place_member(agent, xy=loc)
                # place_agent(agent)
    return agent
Esempio n. 19
0
def create_drinker(name, i, exec_key=None, action=drinker_action):
    """
    Create a drinker, who starts with a random motivation.
    """
    rand_motive = random.random()
    recent_crowds = [HALF_FULL] * mem_capacity
    return Agent(name + str(i),
                 attrs={
                     MOTIV: rand_motive,
                     MEMORY: recent_crowds
                 },
                 action=action,
                 exec_key=exec_key)
Esempio n. 20
0
def create_consumer(name, i, action=None, **kwargs):
    """
    Create consumers
    """
    spending_power = random.randint(MIN_CONSUMER_SPENDING,
                                    MAX_CONSUMER_SPENDING)
    return Agent(name + str(i),
                 action=consumer_action,
                 attrs={
                     SPENDING_POWER: spending_power,
                     LAST_UTIL: 0.0,
                     ITEM_NEEDED: get_rand_good()
                 },
                 **kwargs)
Esempio n. 21
0
def create_trader(name, i, action=None, **kwargs):
    """
    A func to create a trader.
    """
    return Agent(
        name + str(i),
        action=action,
        # goods will now be a dictionary like:
        # goods["cow"] = [cowA, cowB, cowC, etc.]
        attrs={
            GOODS: {},
            "util": 0,
            "pre_trade_util": 0
        },
        **kwargs)
Esempio n. 22
0
def create_consumer(name, i, props=None, **kwargs):
    """
    Create consumers
    """
    spending_power = random.randint(MIN_CONSUMER_SPENDING,
                                    MAX_CONSUMER_SPENDING)
    consumer_books = {
        "spending power": spending_power,
        "last util": 0.0,
        "item needed": get_rand_good()
    }
    return Agent(name + str(i),
                 attrs=consumer_books,
                 action=consumer_action,
                 **kwargs)
Esempio n. 23
0
def create_mp(store_grp, i, action=None, **kwargs):
    """
    Create a mom and pop store.
    """
    store_num = i % len(mp_stores)
    store = mp_stores[mp_stores_type[store_num]]
    return Agent(name=str(store_grp) + " " + str(i),
                 action=retailer_action,
                 attrs={
                     EXPENSE: store[PER_EXPENSE],
                     CAPITAL: store[INIT_CAPITAL],
                     GOODS_SOLD: cons_goods[store_num],
                     UTIL_ADJ: store[UTIL_ADJ]
                 },
                 **kwargs)
Esempio n. 24
0
def create_entr(name, i, action=None, **kwargs):
    """
    Create an agent.
    """
    # TO BE FIXED
    starting_cash = DEF_ENTR_CASH
    resources = copy.deepcopy(DEF_CAP_WANTED)
    return Agent(name + str(i),
                 action=entr_action,
                 attrs={
                     "cash": starting_cash,
                     "wants": resources,
                     "have": {}
                 },
                 **kwargs)
Esempio n. 25
0
def create_rholder(name, i, action=None, **kwargs):
    """
    Create an agent.
    """
    # TO BE FIXED
    # k_price = DEF_K_PRICE
    resources = copy.deepcopy(DEF_CAP_WANTED)
    # num_resources = len(resources)
    price_list = copy.deepcopy(DEF_EACH_CAP_PRICE)
    starting_cash = DEF_RHOLDER_CASH
    return Agent(name + str(i),
                 action=rholder_action,
                 attrs={
                     "cash": starting_cash,
                     "resources": resources,
                     "price": price_list
                 },
                 **kwargs)
Esempio n. 26
0
 def from_json(self, serial_obj):
     # from registry.run_dict import mbr_creator_dict
     super().from_json(serial_obj)
     self.color = serial_obj["color"]
     self.num_mbrs_ever = serial_obj["num_mbrs_ever"]
     # we loop through the members of this group
     for nm in serial_obj["members"]:
         member = serial_obj["members"][nm]
         if member["type"] == "Agent":
             self.members[nm] = Agent(name=nm,
                                      serial_obj=member,
                                      exec_key=member['exec_key'])
         elif member["type"] == "Group":
             self.members[nm] = Group(name=nm,
                                      serial_obj=member,
                                      exec_key=member['exec_key'])
     mem_create_nm = serial_obj["mbr_creator"]
     self.mbr_creator = mem_create_nm
Esempio n. 27
0
 def from_json(self, serial_obj):
     """
     Turn a serilaized JSON stream back into a group:
     """
     super().from_json(serial_obj)
     self.mbr_creator = self._restore_func(serial_obj, "mbr_creator")
     self.color = serial_obj["color"]
     self.num_mbrs_ever = serial_obj["num_mbrs_ever"]
     # we loop through the members of this group
     for nm in serial_obj["members"]:
         member = serial_obj["members"][nm]
         if member["type"] == "Agent":
             self.members[nm] = Agent(name=nm,
                                      serial_obj=member,
                                      exec_key=member['exec_key'])
         elif member["type"] == "Group":
             self.members[nm] = Group(name=nm,
                                      serial_obj=member,
                                      exec_key=member['exec_key'])
Esempio n. 28
0
def create_ramanujan():
    return Agent("Ramanujan", exec_key=exec_key, duration=5, action=ram_action)
Esempio n. 29
0
def create_hardy():
    return Agent("Hardy", attrs={ANM: AGE}, exec_key=exec_key, duration=10)
Esempio n. 30
0
from lib.agent import Agent
from lib.stats import Statistics
from lib.snake import Environment
import pygame
from lib.config import EPISODE
"""
Train the agent and neural network for a number of episodes.
"""

agent = Agent()
stat = Statistics()
episode = 0

while True:
    if episode > EPISODE: break
    episode += 1
    print(f'Episode:{episode}')
    # pylint: disable=no-member
    pygame.init()
    env = Environment(stat, episode, agent, True, False)
    env.run()
    env.agent.model.save_weights('weights/weights.hdf5')
    del env
    pygame.quit()