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()
