def __init__(self, papaiNoel, listaElfo, listaRena, tamanhoGrupoElfos): self.listaRena = listaRena self.listaElfo = listaElfo self.papaiNoel = papaiNoel self.bufferElfo = Buffer(tamanhoGrupoElfos) self.bufferRena = Buffer(len(self.listaRena)) self.contadorElfo = 0 self.contadorRena = 0 self.porta = Lock() self.anel = Lock()
def __init__(self, env_dict, params): """ option_num, state_dim, action_dim, action_bound, gamma, learning_rate, replacement, buffer_capacity, epsilon gamma: (u_gamma, l_gamma) learning_rate: (lr_u_policy, lr_u_critic, lr_option, lr_termin, lr_l_critic) """ # session self.sess = tf.Session() # environment parameters self.sd = env_dict['state_dim'] self.ad = env_dict['action_dim'] a_bound = env_dict['action_scale'] assert a_bound.shape == (self.ad,), 'Action bound does not match action dimension!' # hyper parameters self.on = params['option_num'] epsilon = params['epsilon'] u_gamma = params['upper_gamma'] l_gamma = params['lower_gamma'] u_capac = params['upper_capacity'] l_capac = params['lower_capacity'] u_lrcri = params['upper_learning_rate_critic'] l_lrcri = params['lower_learning_rate_critic'] l_lrpol = params['lower_learning_rate_policy'] l_lrter = params['lower_learning_rate_termin'] # the frequency of training termination function if params['delay'] == 'inf': self.delay = -1 else: self.delay = params['delay'] # Upper critic and buffer self.u_critic = UCritic(session=self.sess, state_dim=self.sd, option_num=self.on, gamma=u_gamma, epsilon=epsilon, learning_rate=u_lrcri) self.u_buffer = Buffer(state_dim=self.sd, action_dim=1, capacity=u_capac) # Lower critic, options and buffer HER self.l_critic = LCritic(session=self.sess, state_dim=self.sd, action_dim=self.ad, gamma=l_gamma, learning_rate=l_lrcri) self.l_options = [Option(session=self.sess, state_dim=self.sd, action_dim=self.ad, ordinal=i, learning_rate=[l_lrpol, l_lrter]) for i in range(self.on)] self.l_buffers = [Buffer(state_dim=self.sd, action_dim=self.ad, capacity=l_capac) for i in range(self.on)] # Initialize all coefficients and saver self.sess.run(tf.global_variables_initializer()) self.saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=100) self.tc = 0 # counter for training termination self.mc = 0 # counter for model
def test_continous_reading_negative_case(my_config): my_config['opcua']['number_of_reconnections'] = -1 my_config['metrics'][0]['interval'] = 500 server_thread = threading.Thread(target=run_simulation_server, args=[20]) server_thread.start() my_buffer = Buffer(my_config) ua_listener = OPCUAListener(my_config, my_buffer) time.sleep(3) ua_listener.connect() time.sleep(10) ua_listener.exit() server_thread.join() time.sleep(5) list_of_metrics = [metric['metric_id'] for metric in my_config['metrics']] metric_values = [[] for _ in range(len(list_of_metrics))] for buffer_entity in my_buffer.buffer: metric_idx = list_of_metrics.index( buffer_entity.data['node'].metric_id) metric_values[metric_idx].append( buffer_entity.data['data_variant'].Value.Value) increments_equal_one = True for metric_value_set in metric_values: for i in range(1, len(metric_value_set), 1): if metric_value_set[i] != metric_value_set[i - 1] + 1: increments_equal_one = False break assert increments_equal_one == False
def analyzation(self): buff = Buffer() stat = State() dict_state = dict_of_states() self.curr_p = -1 self.curr_symbs[1] = self.text[0] while stat.get_state()!=3: self.get_next() print(self.curr_p,' ', self.curr_symbs[0], self.define_symb(self.curr_symbs[0]), stat.get_state() ) if stat.get_state() == 1: next_state = dict_state.find_state( stat.get_state(), self.define_symb(self.curr_symbs[0]), self.define_symb(self.curr_symbs[0])) self.state_act(stat.get_state(),buff, next_state ) stat.set_state( next_state ) print('->' ,stat.get_state()) next_state = dict_state.find_state( stat.get_state(), self.define_symb(self.curr_symbs[0]), self.define_symb(self.curr_symbs[1])) print("BUFFER",buff.get_buff()) self.state_act(stat.get_state(),buff, next_state) stat.set_state( next_state ) print('->' ,stat.get_state()) self.state_act(stat.get_state(),buff, 3) for i in range(len(self.Lexems_arr)): print(self.Lexems_arr[i].get())
def __init__(self,path): self.filePath = path print "Flight initialisation" self.reader = csv.reader(open(self.filePath, 'rb')) self.writer = csv.writer(open('SimulationOutput.csv', 'wb')) flight_initialized = True self.buffer = Buffer()
def __init__(self, symbols,period_start,period_end,mode,CASH_BIAS = 0,WINDOW_SIZE = 48,LR = 2e-5,MODEL_NAME = 'CNN',reward = 'avg_log_cum_return'): tf.compat.v1.disable_eager_execution() # permet l'utilisation complète de Tensorflow 1 self.symbols = symbols self.period_start = period_start self.period_end = period_end self.symbols_num = len(symbols) self.mode = mode self.nb_ep = 0 self.MODEL_NAME = MODEL_NAME #HYPER PARAMETERS self.BUFFER_SIZE = 200 self.BATCH_SIZE = 10 self.SHOW_EVERY = WINDOW_SIZE*7*4 #Affichage des résultats tous les MOIS (30jours) self.WINDOW_SIZE = WINDOW_SIZE # Une journée self.CASH_BIAS = CASH_BIAS self.NB_FEATURES = 9 self.SAMPLE_BIAS = 1.05 self.state_dim = (self.symbols_num,self.WINDOW_SIZE,self.NB_FEATURES) self.action_size = self.symbols_num +1 self.LR_list = {'train':2e-5,'test':9e-5,'valid':9e-5} self.ROLLING_STEPS_dic = {'train':1,'test':0,'valid':0} self.ROLLING_STEPS = self.ROLLING_STEPS_dic[mode] if LR in [2e-5,9e-5]: self.LR = self.LR_list[mode] else: self.LR = LR #Initialisation self.episode_reward = [] self.total_step = 0 self.session = self.tf_session() np.random.seed(4) self.agent = Agent(self.session,self.state_dim,self.action_size,self.BATCH_SIZE,self.LR,reward,MODEL_NAME) self.buffer = Buffer(self.BUFFER_SIZE, self.SAMPLE_BIAS)
def prepare_loaded_data(self, file_name): """ Przygotowuje i wczytuje dane z pliku :param file_name: plik z danymi :return: """ #utworzenie bufora buff = Buffer() data = CsvReader.read_from_file(file_name, 1) #zmiana czasu data = DataOperation.change_time_relative(data) #zmiana wysokosci na metry data = DataOperation.change_altitude_cm_m(data) #stworzenie zapisywacza saver = FileSaver("saved_data/dane.txt") #kazda linijke z pliku csv buforujemy osobno for d in data: buff.set_data(d) buffered_data = buff.get_data() #sprawdzamy czy kazda linijka jest poprawnie zapisana if InputValidator.input_val(buffered_data): #zapisujemy kazda linijke do nowego pliku saver.save_data(buffered_data) #odczyt danych z pliku csv i wizualizacja r_data = CsvReader.read_from_file(saver.get_file_name()) #tworzymy wizualizator, drugi parametr do interwal czasowy self.visualizer = PlotCreator(r_data, 1) self.data_loaded = True print "Dane zaladowane"
def gametick(self, tickrate): while self.running: time.sleep(0.010) # Sleep for 10 milliseconds if (self.host and self.host.new_packet ): # Check if we've received new tick packet from the host new_data = Buffer( 512 ) # Create a new buffer of 512 bytes to hold outgoing packet data new_data.prepare_packet(10) new_data.offset = 150 # Go to start of player data for x in self.clients: new_data.write_real('B', 1, x.id) # write x's uid new_data.write_real('H', 2, x.pos_x) # write x's pos_x new_data.write_real('H', 2, x.pos_y) # write x's pos_y new_data.write_real('B', 1, x.is_alive) # write x's is_alive new_data.write_real('f', 4, x.hull_angle) # write x's hull_angle new_data.write_real( 'f', 4, x.turret_angle) # write x's turret_angle new_data.offset += 16 # Advance to next player's data packet.send_all( self, new_data.data ) # send this packet to all clients! maybe in another thread? self.host.new_packet = False
def Test1(): env=simpy.Environment() B = Buffer() B.capacity=5 Source_Geo(env,"Source",0.5,B) Server_Geo(env,"Server",0.6,B) env.run(until=20)
def __add_buffer(self, log_item): buf = Buffer(log_item, self.handler, maxsize=self.buffer_size) if log_item.channel not in self.buffers: self.buffers[log_item.channel] = {log_item.level: buf} else: if log_item.level not in self.buffers[log_item.channel]: self.buffers[log_item.channel][log_item.level] = buf return buf
def eachSegment(self): length = self.numberOfSegments() for i in range(0, length): samples = self.samplesForSegment(i) buf = Buffer(samples=samples, size=self.sizeForWindow, sampleRate=self.buf.sampleRate) yield (buf, i)
def my_buffer(): cfg_file = '../src_test/config_test.yaml' with open(cfg_file) as config_file: cfg = yaml.safe_load(config_file) test_buffer = Buffer(cfg) for i in range(test_buffer.max_buffer_size - 1): test_buffer.buffer.append(random() * 1000) return test_buffer
def __init__(self, maxSize, alpha=0.6, epsilon=0.000001): self.maxSize = maxSize self.buffer = Buffer(self.maxSize) self.sumTree = SumTree(self.maxSize) self.weights = {} self.alpha = 0.6 self.curSize = 0 self.epsilon = epsilon self.heap = Heap()
def __init__(self, h, w): self.win = Window(top=0, x=w, y=h) self.buffer = Buffer() self.filename = "" self.cursor = Cursor() self.mode = "normal" self.exit = False self.handlers = Handler() self.command = "" self.message = ""
def __init__(self, Env_dim, Nb_action): self.memory = Buffer(Memory_size) self.eval_nn = Network(Env_dim, Nb_action) self.target_nn = Network(Env_dim, Nb_action) self.optimizer = torch.optim.Adam(self.eval_nn.parameters(), lr=Learning_rate) self.criterion = nn.MSELoss(reduction='sum') self.counter = 0 self.target_nn.fc1 = self.eval_nn.fc1 self.target_nn.fc2 = self.eval_nn.fc2 self.target_nn.out = self.eval_nn.out
def connect_online_disconnect_offline(my_config): server_thread = threading.Thread(target=run_simulation_server, args=[15]) server_thread.start() my_buffer = Buffer(my_config) ua_listener = OPCUAListener(my_config, my_buffer) time.sleep(3) ua_listener.connect() time.sleep(30) ua_listener.exit() time.sleep(15) assert my_buffer.len() >= 0
def __init__(self, config): self.myBuffer = Buffer(config) self.out_csv = '' self.in_io_count = 0 self.out_io_count = 0 self.csv_row = ['-', '-', 0, 0, 0, 0, 0, 'hadoop', 'bin/spark'] self.in_ran_io_count = 0 self.in_seq_size_count = 0 self.out_ran_io_count = 0 self.out_seq_size = 0 self.write_seq_threshold = config['write_seq_threshold'] self.print_input_config(config)
def Buffers(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type( self._tab.Offset(12)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 x = self._tab.Indirect(x) from Buffer import Buffer obj = Buffer() obj.Init(self._tab.Bytes, x) return obj return None
def main(): #interface on which capture packets interface = input('interface: ') if len(interface) == 0: print('Not valid interface.') sys.exit() #own ip ipaddress = ni.ifaddresses(interface)[ni.AF_INET][0]['addr'] #-------------------------------------------------------------------------------------------# #two data structure used to analyze packets and store the flows global buff buff = Buffer() pkt_str = PacketsStr() #threads used to analyze the flows and their content dispatcher = Dispatcher(buff, pkt_str, ipaddress) scanner = PortScanner(pkt_str) visual = Visual(pkt_str) dispatcher.start() scanner.start() visual.start() #starting to sniff packets capture = sniff(filter='ip', session=IPSession, prn=traffic_handler, count=0, iface=interface) #at the and of the sniff, when Ctrl+C key is pressed, termination variable is set to notify threads dispatcher.term.set() scanner.term.set() visual.term.set() #to wake the threads which are waiting for new packets time.sleep(1) with buff._mutex: buff._mutex.notify() with pkt_str._lockPkts: pkt_str._lockPkts.notify() dispatcher.join() scanner.join() visual.join() #print some information about the number of unknown and known packets print("\nUnknown packets: %d" % len(pkt_str.unknown)) print("Packets of unknown process: %d" % len(pkt_str.unanalizedPkt)) print("Total packets: %d" % len(capture))
def __init__(self, number: int, gel: "Global Event List"): self.name = f"Host {number}" self.status = "idle" self.buffer = Buffer() self.channel = gel.channel self.GEL = gel self.arrivalRate = 0.8 # lambda self.senseTime = 0.01 # 0.01 ms self.DIFS = 0.1 # 0.10 ms self.SIFS = 0.05 # 0.05 ms self.notACKedDict = {} self.ackId = 0
def __init__(self, connection: socket): self.time_start = time.time() self.connection = connection self.buffer = Buffer(connection) self.step = 0 self.username = None self.stop_event = threading.Event() self.username_wrong = None self.start_time = time.time() t = threading.Timer(30, self.after_done) t.start() super().__init__()
def test_polling_interval(my_config): server_thread = threading.Thread(target=run_simulation_server, args=[20]) server_thread.start() my_buffer = Buffer(my_config) ua_listener = OPCUAListener(my_config, my_buffer) time.sleep(3) ua_listener.connect() time.sleep(5) ua_listener.exit() time.sleep(5) server_thread.join() print('Buffer length=', my_buffer.len()) assert 9 <= my_buffer.len() <= 11
def __init__(self): configs = load_configs("Configs.json") value_configs = load_configs("Configs_ValueNN.json") policy_configs = load_configs("Configs_PolicyNN.json") #logging.basicConfig(format='%(asctime)s %(message)s', filename=configs["log_name"], level=logging.WARNING, #datefmt="%Y-%m-%d %H:%M:%S") #logging.info("Starting Optimizer.") self.width = configs["width"] self.height = configs["height"] self.buffer_size = configs["buffer_size"] self.filename = configs["data_filename"] self.experiment_name = "Deviations/" + configs["val_filename"] self.buffer = Buffer(self.buffer_size) self.env = BlockRelocation(self.height, self.width) #self.model = ValueNetwork(configs=value_configs) #self.policy_network = PolicyNetwork(configs=policy_configs) #self.combined_model = CombinedModel(configs=configs) #self.value_wrapper = EstimatorWrapper(self.model) #self.policy_wrapper = EstimatorWrapper(self.policy_network) self.value_net = ValueNetworkKeras(value_configs) self.policy_net = PolicyNetworkKeras(policy_configs) self.tree_searcher = TreeSearch( self.value_net, BlockRelocation(self.height, self.width), self.policy_net) self.tree_searcher.std_vals = load_obj(self.experiment_name) self.baseline_params = { "search_depth": 5, "epsilon": 0.1, "threshold": 0.01, "drop_percent": 0.25, "factor": 0.01 } self.current_search_params = { "search_depth": 5, "epsilon": 0.1, "threshold": 0.05, "drop_percent": 0.3, "factor": 0.05 } self.dfs_params_hq = {"stop_param": 4, "k": 12} self.dfs_params_fast = {"stop_param": 1, "k": 12}
def __init__(self,maxSize, alpha=0.6): self.maxSize = maxSize self.buffer = Buffer(self.maxSize) self.heap = Heap() self.weights = None #Add two flags to indicate whether alpha or queue size has changed self.prevAlpha = alpha self.prevSize =0 # Variables to store current alpha and exp replay size self.alpha = alpha self.curSize = 0 #Weightings to each experience self.endPoints = []
def __init__(self): # Hyperparameters self.learning_rate = 0.0003 self.betas = (0.9, 0.999) self.gamma = 0.99 self.eps_clip = 0.2 self.buffer_size = 2048 self.batch_size = 256 self.K_epochs = 3 self.max_steps = 100000 self.tau = 0.95 self.entropy_coef = 0.001 self.value_loss_coef = 0.5 self.summary_freq = 1000 # Environment self.env_name = "Environments/env1/Unity Environment" channel = EngineConfigurationChannel() self.env = UnityEnv(self.env_name, worker_id=0, use_visual=False, side_channels=[channel], no_graphics=False, multiagent=True) channel.set_configuration_parameters(time_scale=100) self.action_size, self.state_size = Utils.getActionStateSize(self.env) self.n_agents = self.env.number_agents print("Nº of Agents: ", self.n_agents) # Model self.model = ActorCritic(self.state_size, self.action_size, seed=0).to(device) self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate, betas=self.betas) self.MseLoss = nn.MSELoss() # Buffer memory self.memory = [] for _ in range(self.n_agents): self.memory.append(Buffer()) # Initialize time step (for updating when buffer_size is full) self.t_step = 1
def __init__(self): # Hyperparameters self.learning_rate = 0.0003 self.buffer_size = 10240 self.batch_size = 1024 self.gamma = 0.99 self.update_every = 64 self.max_steps = 100000 self.epsilon = 1.0 self.epsilon_end = 0.01 self.epsilon_decay = 0.995 self.tau = 0.01 self.summary_freq = 1000 # Environment self.env_name = "Environments/env1/Unity Environment" channel = EngineConfigurationChannel() self.env = UnityEnv(self.env_name, worker_id=0, use_visual=False, side_channels=[channel], no_graphics=False, multiagent=False) channel.set_configuration_parameters(time_scale=100) self.action_size, self.state_size = Utils.getActionStateSize(self.env) self.n_agents = self.env.number_agents # Models self.local_model = QNetwork(self.state_size, self.action_size, seed=0).to(device) self.target_model = QNetwork(self.state_size, self.action_size, seed=0).to(device) self.optimizer = optim.Adam(self.local_model.parameters(), lr=self.learning_rate) # Buffer memory self.memory = Buffer(self.buffer_size, self.batch_size, seed=0, device=device) # Initialize time step (for updating every "update_every" time steps) self.t_step = 0
def __init__(self, number: int, gel: "Global Event List"): self.name = f"Host {number}" self.status = "idle" self.buffer = Buffer() self.channel = gel.channel self.GEL = gel self.senseTime = 0.01 # 0.01 ms self.DIFS = 0.1 # 0.10 ms self.SIFS = 0.05 # 0.05 ms self.notACKedArray = [] self.ackId = 0 self.blocking = False self.processing_dataframe = "" config = configparser.ConfigParser() config.read("configuration_file.ini") self.arrivalRate = float(config["DEFAULT"]["ARRIVE_RATE"]) # lambda
def run(cmd, quiet=False, abandon_output=True): proc = Popen(split(cmd), stdout=PIPE, stderr=STDOUT) buf = Buffer(abandon_output=abandon_output) line = proc.stdout.readline() while len(line): buf.put(line) if not quiet: print(line, end='') line = proc.stdout.readline() # Process could probably close the descriptor before exiting. proc.wait() if proc.returncode != 0: raise Exception('Process exited with a non-zero return code. ' + 'Last output of the program:\n\n' + '---------- Start of exception log --\n' + buf.get_short().strip() + '\n---------- End of exception log --\n') return buf.get_long()
def analysis(self): Buff = Buffer() Stat = State() #Buff.add_buff(self.Current) #print(Buff.get_buff()) #print(self.Current) self.Current = self.get_next() while Stat.get_state() != 'final': if Stat.get_state() == 'start': if self.Current in self.Separators: self.Current = self.get_next() elif self.Current.isalpha(): Buff.clear_buff() Buff.add_buff(self.Current) Stat.set_state('ident') self.Current = self.get_next() #print(Buff.get_buff()) elif self.Current.isdigit(): Buff.clear_buff() Buff.add_buff(self.Current) Stat.set_state('numb') self.Current = self.get_next() elif self.Current == '{': #ЗАПИСАТЬ КОММЕНТАРИЙ В БУФЕР Stat.set_state('comment') self.Current = self.get_next() elif self.Current == '.': Lexems_arr.append( Lexer.Lexer(self.get_pos(), 'Разделитель', self.Current, 'имя')) Stat.set_state('final') elif self.Current in self.Delimiters: Stat.set_state('delimit') self.Current = self.get_next()
def __init__(self, episodes, trajectory, alpha_actor, alpha_credit, gamma): states = env.observation_space.shape[0] actions = env.action_space.shape[0] self.low = env.action_space.low[0] self.high = env.action_space.high[0] self.gamma = gamma self.alpha_actor = alpha_actor self.alpha_credit = alpha_credit self.episodes = episodes self.memory = Buffer(trajectory) self.policy = Policy(states, actions).apply(self.weights) self.credit = Credit(states, actions).apply(self.weights) self.policy_optim = optim.Adam(self.policy.parameters(), lr=self.alpha_actor) self.credit_optim = optim.Adam(self.credit.parameters(), lr=self.alpha_credit) self.credit_loss = nn.CrossEntropyLoss()