risk_learning/agent.py at master · okreng/risk_learning · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
"""
This file contains the agent object for holding multiple q functions
"""

# import all existing policies
from q_funcs.allot import random_allot, amass
from q_funcs.attack import linear_attack_net, max_success, three_layer_attack_net, random_attack, army_difference, two_layer_attack_net, manual_attack
from q_funcs.fortify import random_fortify, skip_fortify
from q_funcs.reinforce import reinforce_all

import sys, argparse

class Agent():
    """
    This class holds three q_func objects
    One for each action type
    """
    def __init__(self, player_id, territories, act_list, allot_q_func, attack_q_func, fortify_q_func, verbose=True):
        """
        Constructor for agent
        :param territories: int number of territories on the board
        :param allot_policy: string q_func to enact for allot
        :param attack_policy: string q_func to enact for attack
        :param fortify_policy: string q_func to enact for fortify
        :return none:
        """
        self.player_id = player_id
        self.territories = territories
        self.act_list = act_list

        if allot_q_func is "random_allot":
            self.allot_q_func = random_allot.RandomAllot(self.territories, self.act_list)
        elif allot_q_func is "amass":
            self.allot_q_func = amass.Amass(self.territories, self.act_list)
        else:
            print("No valid allot Q function specified")
            exit()

        if attack_q_func is "max_success":
            self.attack_q_func = max_success.MaxSuccess(self.territories, self.act_list)
        elif attack_q_func is "random_attack":
            self.attack_q_func = random_attack.RandomAttack(self.territories, self.act_list)
        elif attack_q_func is "linear_attack_net":
            self.attack_q_func = linear_attack_net.LinearAttackNet(self.territories, self.act_list, '0', 0, verbose=verbose)
        elif attack_q_func is "two_layer_attack_net":
            self.attack_q_func = two_layer_attack_net.TwoLayerAttackNet(self.territories, self.act_list, '0', 0, verbose=verbose, learning_rate=1e-4)
        elif attack_q_func is "three_layer_attack_net":
            self.attack_q_func = three_layer_attack_net.ThreeLayerAttackNet(self.territories, self.act_list, '0', 0, verbose=verbose, learning_rate=1e-5)
        elif attack_q_func is "army_difference":
            self.attack_q_func = army_difference.ArmyDifference(self.territories, self.act_list)
        elif attack_q_func is "manual":
            self.attack_q_func = manual_attack.ManualAttack(self.territories, self.act_list)
        else:
            print("No valid attack Q function specified")
            exit()

        ############ TODO: Change default reinforce q function ###################
        reinforce_q_func = "reinforce_all"
        self.reinforce_q_func = reinforce_all.ReinforceAll(self.territories, self.act_list)

        if fortify_q_func is "random_fortify":
            self.fortify_q_func = random_fortify.RandomFortify(self.territories, self.act_list)
        if fortify_q_func is "skip_fortify":
            self.fortify_q_func = skip_fortify.SkipFortify(self.territories, self.act_list)
        else:
            print("No valid attack Q function specified")
            exit()

        if verbose:
            print("Player {} successfully instantiated with Q functions:".format(player_id))
            print("\tallot: {}".format(allot_q_func))
            print("\tattack: {}".format(attack_q_func))
            print("\treinforce: {}".format(reinforce_q_func))
            print("\tfortify: {}".format(fortify_q_func))

        return


def parse_arguments():
    parser = argparse.ArgumentParser(description='Agent Argument Parser')
    parser.add_argument('--train',dest='train',type=bool,default=False)
    parser.add_argument('--territories',dest='territories',type=int, default=2)
    parser.add_argument('--player',dest='player_id',type=int,default=0)
    return parser.parse_args()

def main(args):

    args = parse_arguments()
    isTraining = args.train
    territories = args.territories
    player_id = args.player_id

    act_list = [[0,1],[-1]]

    agent = Agent(player_id, territories, act_list, "random_allot", "linear_attack_net", "random_fortify")


if __name__ == '__main__':
    main(sys.argv)