def __init__(self, refm, disc_rate, sims, depth, horizon, epsilon=0.05, threads=1, memory=32):
Agent.__init__(self, refm, disc_rate)
if epsilon > 1.0:
epsilon = 1.0
if epsilon < 0.0:
epsilon = 0.0
self.refm = refm
self.sims = int(sims)
self.depth = int(depth)
self.horizon = int(horizon)
self.memory = int(memory)
self.epsilon = epsilon
self.threads = int(threads)
self.obs_cells = refm.getNumObsCells()
self.obs_symbols = refm.getNumObsSyms()
self.obs_bits = int(ceil(log(refm.getNumObs(), 2.0)))
self.reward_bits = int(ceil(log(refm.getNumRewards(), 2.0)))
self.num_actions = refm.getNumActions()
print "obs_bits = ", self.obs_bits
print "reward_bits = ", self.reward_bits
self.agent = None
self.reset()
def __init__(self, agentType):
Agent.__init__(self, agentType)
self.R = [[
None, Color.Initial, Color.Green, Color.Yellow, Color.Blue,
Color.Red
], [Color.Initial, None, 10, -1, -1, -1],
[Color.Green, None, None, -1, 10, -1],
[Color.Yellow, None, -1, None, -1, -1],
[Color.Blue, None, -1, -1, None, 10],
[Color.Red, None, -1, 10, -1, None]]
self.Q = [[
None, Color.Initial, Color.Green, Color.Yellow, Color.Blue,
Color.Red
], [Color.Initial, None, 0, 0, 0, 0],
[Color.Green, None, None, 0, 0, 0],
[Color.Yellow, None, 0, None, 0, 0],
[Color.Blue, None, 0, 0, None, 0],
[Color.Red, None, 0, 0, 0, None]]
self.g = 0.8
self.l = 1.0
self.e = 1.0
self.i = 0
def __init__(self, env, config):
Agent.__init__(self, env, config)
self.config = self.config
self.name = "QAgent"
self.Qtable = np.zeros(tuple(self.config.buckets) + (env.action_space.n,))
def __init__(self, g):
Agent.__init__(self)
self.s = 0
self.previous_s = 0
self.nb_steps = 0
self.proba_selfish = 0
self.g = g
def __init__(self,
refm,
disc_rate,
sel_mode,
init_Q,
Lambda,
epsilon=0,
gamma=0):
Agent.__init__(self, refm, disc_rate)
self.num_states = refm.getNumObs(
) # assuming that states = observations
self.obs_symbols = refm.getNumObsSyms()
self.obs_cells = refm.getNumObsCells()
self.sel_mode = sel_mode
self.init_Q = init_Q
self.Lambda = Lambda
self.epsilon = epsilon
# if the internal discount rate isn't set, use the environment value
if gamma == 0:
self.gamma = disc_rate
else:
self.gamma = gamma
if self.gamma >= 1.0:
print "Error: HLQ learning can only handle an internal discount rate ", \
"that is below 1.0"
sys.exit()
self.reset()
def __init__(self, cfg, id, rounds):
Agent.__init__(self, cfg, id, rounds)
self.qTable = np.random.rand(self.rounds, 2, 16) * 0.01
self.fitness = 0
self.q_info = pd.DataFrame(columns=[
'round', 'agent_type', 'agent_id', 'acc_reward', 'q_value'
])
def __init__(self, name=None):
if name is None:
name = "librarian"
Agent.__init__(self, name, "librarian")
return
def __init__(self,
env,
qnet,
memory,
gamma=0.9,
steps_between_train=100,
episodes_between_train=1,
train_sample_size=30,
train_rounds=20,
trains_between_updates=100,
**super_args):
Agent.__init__(self, env, **super_args)
self.Memory = memory # ReplayMemory(memory_size), memory_size = 100000
self.QNet = qnet
assert isinstance(qnet, QNet)
self.reset_states()
self.StepsBetweenTrain = steps_between_train
self.EpisodesBetweenTrain = episodes_between_train
self.StepsToTrain = steps_between_train
self.EpisodesToTrain = episodes_between_train
self.TrainSampleSize = train_sample_size
self.TrainsBetweenUpdates = trains_between_updates
self.TrainsToUpdate = trains_between_updates
self.TrainRoundsPerSession = train_rounds
self.SessionsTrained = 0
self.BatchesTrained = 0
self.SamplesTrained = 0
self.QNetUpdated = 0
#self.StepsToWarmup = steps_to_warmup
self.Gamma = gamma
def __init__( self, refm, disc_rate, init_Q, Lambda, alpha, epsilon, gamma=0 ):
Agent.__init__( self, refm, disc_rate )
self.num_states = refm.getNumObs() # assuming that states = observations
self.obs_symbols = refm.getNumObsSyms()
self.obs_cells = refm.getNumObsCells()
self.init_Q = init_Q
self.Lambda = Lambda
self.epsilon = epsilon
self.alpha = alpha
# if the internal discount rate isn't set, use the environment value
if gamma == 0:
self.gamma = disc_rate
else:
self.gamma = gamma
if self.gamma >= 1.0:
print "Error: Q learning can only handle an internal discount rate ", \
"that is below 1.0"
sys.exit()
self.reset()
def __init__( self, refm, disc_rate, sims, depth, horizon, \
epsilon=0.05, threads=1, memory=32 ):
Agent.__init__(self, refm, disc_rate)
if epsilon > 1.0: epsilon = 1.0
if epsilon < 0.0: epsilon = 0.0
self.refm = refm
self.sims = int(sims)
self.depth = int(depth)
self.horizon = int(horizon)
self.memory = int(memory)
self.epsilon = epsilon
self.threads = int(threads)
self.obs_cells = refm.getNumObsCells()
self.obs_symbols = refm.getNumObsSyms()
self.obs_bits = int(ceil(log(refm.getNumObs(), 2.0)))
self.reward_bits = int(ceil(log(refm.getNumRewards(), 2.0)))
self.num_actions = refm.getNumActions()
print "obs_bits = ", self.obs_bits
print "reward_bits = ", self.reward_bits
self.agent = None
self.reset()
def __init__(self,
g,
system: System.System,
parameters: MDPParameters.MDPParameters,
epsilon=0.50,
learning_rate=0.1):
Agent.__init__(self)
self.g = g
self.system = system
self.parameters = parameters
self.q_values = {}
self.learning_rate = learning_rate
self.decay = self.parameters.decay
self.epsilon = epsilon
self.q_val_init = 1
self.actions = self.parameters.actions_u
self.s = 0
self.a = 0
self.AD = [[[
1 / len(system.actions) for a in range(len(system.actions))
] for s in range(len(system.states))]
for h in range(len(system.agents))]
def __init__(self,errGrowth,unnormalizeDirtRate,unnormalizeDirtSize,accuracy,N) :
Agent.__init__(self,Router.PLANNER)
# define the
# variance growth parameter,
# average dirt fall,
# handle to sensor,
# handle to array of vacuums)
self.setNumber(N)
self.vacuumRange = 3
self.setAccuracy(accuracy)
# Initialize the matrices.
self.worldview = zeros((N,N),dtype=float64);
self.dirtLevels = []
self.wetview = zeros((N,N),dtype=float64);
self.viewPrecision = zeros((N,N),dtype=float64);
self.unnormalizeDirtRate = unnormalizeDirtRate
self.unnormalizeDirtSize = unnormalizeDirtSize
self.errGrowth = errGrowth
self.normalizeDirtRate()
self.vacuumlocation = []
#create distance matrix
self.defineDistanceArray()
self.wDist=0; # default
def __init__(self, gamma, filename):
Agent.__init__(self)
self._fileName = filename + "fortify.pickle"
self.load()
self.gamma = gamma
self.lastState = None
self.lastAction = None
self.lastScore = 0
def __init__(self, name=None):
if name is None:
name = "builder"
Agent.__init__(self, name, "build")
ProjectInspector.__init__(self)
return
def __init__(self,accuracy=0.0) :
Agent.__init__(self,Router.SENSORARRAY)
# constructor (accuracy of measurement)
self.accuracy=accuracy-float(int(accuracy)) #force to be within constraints
self.N = 5
self.array = zeros((self.N,self.N),dtype=float64) # array of values for dirt levels
self.Wet = zeros((self.N,self.N),dtype=float64) # array of values for dirt levels
def __init__(self, name=None):
if name is None:
name = "builder"
Agent.__init__(self, name, "build")
ProjectInspector.__init__(self)
return
def __init__(self, gamma, filename):
Agent.__init__(self)
self._fileName = filename + "startingCountry.pickle"
self.gamma = gamma
self.load()
self.lastState = None
self.lastAction = None
self.stateActionList = []
def __init__( self, refm, disc_rate ):
Agent.__init__( self, refm, disc_rate )
if self.num_actions > 10:
print "Error: Manual agent only handles 10 or less actions!"
sys.exit()
self.mode = MANUAL
self.last_val = 0
def __init__(self, gamma, filename):
Agent.__init__(self)
self._fileName = filename + "placeTroops.pickle"
self.load()
self.gamma = gamma
self.lastState = None
self.lastAction = None
self.lastScore = 0
self.stateActionList = []
def __init__(self, agentType):
Agent.__init__(self, agentType)
self._calibration = {
'b': [(0, 0, 35), (1280, 0, 118), (0, 720, 37), (1280, 720, 115)],
's1': [(0, 0, 125), (1280, 0, 114), (0, 720, 168),
(1280, 720, 163)],
's2': [(0, 0, 158), (1280, 0, 176), (0, 720, 66), (1280, 720, 77)],
's3': [(0, 0, 78), (1280, 0, 85), (0, 720, 60), (1280, 720, 60)],
}
def __init__(self,
agentName,
configfilepointer,
fileType='report',
start=False):
self._diskDataReport = None
Agent.__init__(self, agentName, configfilepointer, fileType, start)
self._records = []
self._record = []
def __init__(self, refm, disc_rate, epsilon):
Agent.__init__(self, refm, disc_rate)
self.obs_symbols = refm.getNumObsSyms()
self.obs_cells = refm.getNumObsCells()
self.epsilon = epsilon
self.reset()
def __init__(self, g, system: System.System, parameters: MDPParameters.MDPParameters):
Agent.__init__(self)
self.g = g
self.system = system
self.parameters = parameters
self.tree: MDPTree.Node = None
self.number_of_agents = len(self.system.agents)
self.number_of_actions_u = len(system.actions_u)
self.AD = [[[1 / len(system.actions) for a in range(len(system.actions))] for s in range(len(system.states))] for h in range(len(system.agents))]
def __init__(self, env, config):
Agent.__init__(env, config)
self.env = env
self.actionSpace = env.action_space
self.observationSpace = env.observation_space
self.name = "QAgent"
self.config = config
self.actionSpaceSize = self.env.action_space.n
self.obsSpaceSize = self.env.observation_space.shape[0]
self.Qtable = np.zeros(self.config.buckets + (self.actionSpaceSize, ))
def __init__( self, refm, disc_rate, epsilon ):
Agent.__init__( self, refm, disc_rate )
self.obs_symbols = refm.getNumObsSyms()
self.obs_cells = refm.getNumObsCells()
self.epsilon = epsilon
self.reset()
def __init__(self,r=1.0,s=1.0,v=1.0,cloudsize=1.0) :
Agent.__init__(self,Router.WORLD)
self.time = 0
self.N=5 # %size of grid
self.expenditure = 0.0 # cummulative funds expended since last reset
self.numberVacuums = 0 # No vacuums assigned yet.
self.vacuumArray = [] # array of object handles
self.intializeVariables(r,s,v,cloudsize)
self.setSensor(None)
self.setPlanner(None)
def __init__(self, agentType):
Agent.__init__(self, agentType)
self._colorRange = {
Color.Red: [(0, 200, 0), (3, 255, 255)],
Color.Green: [(33, 165, 0), (70, 255, 255)],
Color.Blue: [(100, 130, 0), (130, 255, 255)],
Color.Yellow: [(20, 115, 180), (80, 255, 255)],
}
self._camera = cv2.VideoCapture(1)
self._camera.set(3, 1280)
self._camera.set(4, 720)
def __init__(self, name=None, project=None, mode=None):
if name is None:
name = "janitor"
if mode is None:
mode = 'clean'
self.mode = mode
self.project = project
Agent.__init__(self, name, "janitor")
ProjectInspector.__init__(self)
return
def __init__(self, name=None, project=None, mode=None):
if name is None:
name = "janitor"
if mode is None:
mode = 'clean'
self.mode = mode
self.project = project
Agent.__init__(self, name, "janitor")
ProjectInspector.__init__(self)
return
def __init__(self, x, y):
"""
Allocation d'un agent requin.
@param x: position en x
@param y: position en y
@param pasX: le déplacement en x
@param pasY: le déplacement en y
"""
Agent.__init__(self,x,y,0,0)
self.color = 'red'
self.age = 0
self.HUNGER_CYCLE = 6
self.hunger = choice(range(int(self.HUNGER_CYCLE/2.0)))
self.PERIOD = 10
def __init__(self, env, config):
Agent.__init__(env, config)
self.env = env
self.actionSpace = env.action_space
self.observationSpace = env.observation_space
self.name = "DQNAgent"
self.config = config
self.actionSpaceSize = self.env.action_space.n
self.obsSpaceSize = self.env.observation_space.shape[0]
self.memory = deque(maxlen=self.config.memory)
self.replayCount = 0
self.trainingFrameCount = 0
self.model = self.createModel()
def __init__(self,
policy_file=None,
train_prefix=None,
exp_rate=0.3,
learning_rate=0.9,
decay_gamma=0.95):
Agent.__init__(self)
self.states = []
self.exp_rate = exp_rate
self.lr = learning_rate
self.decay_gamma = decay_gamma
self.states_value = {}
self.train_prefix = train_prefix
if policy_file is not None:
self.load_policy(policy_file)
def __init__(self, rounds, legs, Q):
Agent.__init__(self)
self.num_rounds = rounds
self.num_legs = legs
self.num_of_pass = 0
self.pass_per_game = []
self.Q = Q
# discount factor
self.gamma = 0.8
# learning rate
self.alpha = 0.95
# exploration rate
self.epsilon = 0.4
class Guichetier(Agent):
# définition de la méthode spéciale __init__
def __init__(self,nom="",solde=0,prenom="",poste=""):
"""Initialisation du compte avec la valeur soldeInitial."""
# assignation de l'attribut d'instance solde
Agent.__init__(self,nom)
self.solde = float(solde)
def __init__(self, aMessageProcessorFunction, aAgentCount):
Agent.__init__(self)
self.agents = []
self.processedCount = 0
self.receivedCount = 0
self.exitOnDone = False
self.messageDataQueue = []
self.agentIdentifierQueue = []
for index in range(0, aAgentCount):
agent= WorkerBee(aMessageProcessorFunction)
self.agents = self.agents + [agent]
self.agentIdentifierQueue += [agent.identifier]
def __init__(self, params):
"""See documentation in the base class"""
Agent.__init__(self, params)
self.l = int(params['ligne'])
self.c = int(params['colonne'])
#strategie initiale (au depart l'agent ne connait pas les deplacements optimaux a effectuer)
#tableau de taille nombre d'etat * nombre d'actions possibles
self.Q = np.zeros((self.l * self.c, 4))
self.Parcours = (self.c * self.l) * [4 * [[]]
] #liste des recompenses obtenues
#Probabilite d'exploration
self.exploration = 0.05
self.listeParcours = [] #liste du parcours de l'episode
def __init__(self, g, system: System.System, parameters: MDPParameters.MDPParameters, epsilon=0.2):
Agent.__init__(self)
self.g = g
self.system = system
self.parameters = parameters
self.number_of_agents = len(self.system.agents)
self.number_of_actions_u = len(system.actions_u)
self.rep_steps_per_transition = len(self.parameters.directed_transition_models[g][0][0][0])
self.AD = [[[1 / len(system.actions) for a in range(len(system.actions))] for s in range(len(system.states))] for h in range(len(system.agents))]
self.Img = [[0 for i in range(len(system.agents))] for h in range(len(system.agents))]
for i in self.system.agents:
self.Img[i][i] = 1
self.tree: RepNetTree.Node = None
self.epsilon = epsilon # Exploration-exploitation trade-off
self.epsilon = 0
self.eps = 0.1 # Used for ADE correction with deterministic transition models
self.T2 = [[0,2,4,6],[1,3,5,7]]
self.T1 = [[0,1,4,5],[2,3,6,7]]
self.T0 = [[0,1,2,3],[4,5,6,7]]
def __init__(self,IDnum,currentTime=0.0,channel=None) : #class constructor
Agent.__init__(self,Router.VACUUM)
self.xPos = 0
self.yPos = 0
self.setStatus(3) # 1 - moving, 2-cleaning, 3-waiting, 4-repairing
self.initializeTime(currentTime) # time it will be done with current operation
self.setID(IDnum)
self.range = 3 # maximum distance that can be travelled
self.moveQueue = []
self.setChannel(channel) #channel to commander
self.timeToClean=8;
self.timeToRepair=32;
self.odometer=0; # tracks distance travelled
self.missions=0; #number of cells than have been cleaned
self.moveCost=1; #cost to move
self.repairCost=30; # cost to conduct repair
self.repairs=0; # number of repairs - running total
self.time = 0;
self.Moisture = None
def __init__(self,
mission_name,
env,
num_episodes,
gamma=1,
alpha=1,
max_simulation_time=0):
self.alpha = alpha
self.gamma = gamma
self.num_episodes = num_episodes
self.max_simulation_time = max_simulation_time
self.episode_data = []
self.env = env
return Agent.__init__(self, mission_name, env)
def __init__(self,
mission_name,
env,
num_episodes,
gamma=1,
max_simulation_time=0,
alpha=.8):
self.gamma = gamma
self.num_episodes = num_episodes
self.alpha = alpha
# self.n_values = np.zeros((self.gs.map_width, self.gs.map_length,4))
self.max_simulation_time = max_simulation_time
self.episode_data = []
self.directory = 'Alpha_' + str(self.alpha) + '_Gamma_' + str(
self.gamma)
if not os.path.exists(self.directory):
os.makedirs(self.directory)
return Agent.__init__(self, mission_name, env)
def __init__( self, refm, disc_rate ):
Agent.__init__( self, refm, disc_rate )
def __init__(self):
Agent.__init__(self, 'station')
def __init__(self, proxy, agent_id):
Agent.__init__(self, proxy, agent_id)
self.state = AgentState.SEARCH_PAYLOAD
self.saved_state = AgentState.SEARCH_PAYLOAD
self.type = "Scout"
def __init__(self, agentName, configfilepointer, fileType='report', start=False):
self._diskDataReport = None
Agent.__init__(self, agentName, configfilepointer, fileType, start)
self._records = []
self._record = []
def __init__(self):
Agent.__init__(self, 'explorator')
def __init__(self, x, y):
Agent.__init__(self, x, y, 0, 0)
self.PERIOD = 20
self.age = 1
self.color = 'blue'
def __init__(self, actions):
Agent.__init__(self, actions)
self.weights = [[1.0] *
(self.data_to_consider + 1)] * len(self.actions)
print self.weights
def __init__(self):
Agent.__init__(self)
def __init__(self, actions):
Agent.__init__(self, actions)
self.weights = [[1.0] * (self.data_to_consider + 1)] * len(self.actions)
print self.weights
def __init__(self):
Agent.__init__(self)
self.init = False
def __init__(self, x, y):
Agent.__init__(self, x, y, 0, 0)
self.color = 'orange'
def __init__(self, cfg, id, rounds):
Agent.__init__(self, cfg, id, rounds)
self.qTable = np.random.rand(self.rounds, 2) * 0.01
def __init__(self):
Agent.__init__(self)
self.go = False
def __init__(self, x, y):
Agent.__init__(self, x, y, 0, 0)
self.color = 'green'
def __init__(self,channel=None) :
Agent.__init__(self,Router.COMMANDER)
self.setChannel(channel) # handle to planner
def __init__(self):
Agent.__init__(self, 'visualizer', 'list')
ProjectInspector.__init__(self)
Indenter.__init__(self)
return
def __init__(self, x, y):
Agent.__init__(self,x,y,0,0)
# Couleur marron
self.color = '#582900'
def __init__(self):
Agent.__init__(self)
def __init__(self, aMessageProcessorFunction):
Agent.__init__(self)
self.messageProcessor = aMessageProcessorFunction
