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, 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, 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): 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): 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, aMessageProcessorFunction): Agent.__init__(self) self.messageProcessor = aMessageProcessorFunction