def avrstats(listok,b_z):
'''
Parameters
----------
listok : TYPE Array
list of pok_typelist type
d_z : TYPE DataFrame
database of pok_typelist
Returns array
-------
'''
plt.close()
array = []
stats = [0,0,0,0,0,0]
avr = 0
podhodyat = {}
for i in range (0,max_id+1):
j=0
while j<len(listok):
if b_z["Type I"][i]==listok[j] and b_z["Type II"][i]==listok[j+1]:
if podhodyat.get(i) is None:
podhodyat[i]=0
j+=2
for i in list(podhodyat):
stats[0] += b_z["HP"][i]
stats[1] += b_z["Atk"][i]
stats[2] += b_z["Def"][i]
stats[3] += b_z["SpA"][i]
stats[4] += b_z["SpD"][i]
stats[5] += b_z["Spe"][i]
avr +=1
arr = [stats[0]/avr,stats[1]/avr,stats[2]/avr,stats[3]/avr,stats[4]/avr,stats[0]/avr]
arr2 = ["HP","Atk","Def","SpA","SpD","Spe"]
colors = list('rgbkym')
fig = plt.figure()
a_x = fig.add_axes([0,0,1,1])
a_x.bar(arr2,arr,color = colors)
fig.set_figwidth(16)
plt.title("Average Stats")
plt.rc('xtick', labelsize=10)
save("C:/Work/Graphics/Avr_stats")
array.append(fig)
# plt.show()
plt.close()
return array
def raspredelenie(typelist):
'''
Parameters
----------
typelist : TYPE Array
list of type
Returns array
-------
False.
'''
array = []
plt.close()
listochek = pd.read_excel('C:/Work/Data/pdx.test.xlsx',sheet_name='Sheet1',index_col=0)
for i in range(0,max_id+1):
for j in typelist:
if j == data["Type I"][i] or j==data["Type II"][i]:
stats = pd.Series([data["HP"][i],data["Atk"][i],data["Def"][i],
data["SpA"][i],data["SpD"][i],data["Spe"][i]],
index=["HP","Atk","Def","SpA","SpD","Spe"])
listochek = listochek.append(stats,ignore_index=True)
fig, axi = plt.subplots(figsize=(10, 10))
axi.scatter(x = listochek['Atk'], y = listochek['Def'])
plt.xlabel("Attack")
plt.ylabel("Defense")
plt.rc('xtick', labelsize=10)
array.append(fig)
save("C:/Work/Graphics/AtkDef")
# plt.show()
plt.close()
fig, axi = plt.subplots(figsize=(10, 10))
axi.scatter(x = listochek['SpA'], y = listochek['SpD'])
plt.xlabel("SpA")
plt.ylabel("SpD")
plt.rc('xtick', labelsize=10)
array.append(fig)
save("C:/Work/Graphics/SpASpD")
plt.close()
fig, axi = plt.subplots(figsize=(10, 10))
axi.scatter(x = listochek['HP'], y = listochek['Spe'])
plt.xlabel("HP")
plt.ylabel("Spe")
plt.rc('xtick', labelsize=10)
array.append(fig)
save("C:/Work/Graphics/HPSpe")
plt.close()
# plt.show()
return array
#!/usr/bin/python3
import calc as cl
import database as db
import plot as pl
import view as vw
if __name__ == "__main__":
db.connect()
start_addr = db.get_start_address()
stops = db.get_stop_positions()
pos = db.get_unique_positions()
addrs = cl.order_addresses(db.get_all_addresses(), stops)
tot_dist = cl.total_distance(pos)
print("Total route distance:", round(tot_dist, 2), "km")
pl.init()
pl.plot_addresses(start_addr, addrs)
pl.plot_route(pos)
pl.save()
vw.copy_kml_public("/home/hlilje/Dropbox/")
vw.write_kml_url()
vw.view()
db.close()
def train(env_name='PongNoFrameskip-v4',
gamma=0.99,
batch_size=32,
replay_size=1000000,
replay_start_size=50000,
learning_rate=0.00025,
adam_epsilon=0.0000001,
sync_target_frames=10000,
epsilon_decay_last_frame=1000000,
epsilon_start=1.0,
epsilon_final=0.1,
train_frames=50000000,
train_rewards=495,
n_steps=3,
save_checkpoints=True,
run_name=None,
use_double=True,
use_dense=None,
dueling=False,
priority_replay=None,
categorical=None,
record=False,
random_seed=None,
index=0):
n_atoms = v_min = v_max = None
use_categorical = False
if categorical is not None:
use_categorical = True
n_atoms = categorical['n_atoms']
v_min = categorical['v'][0]
v_max = categorical['v'][1]
alpha = beta = None
use_priority_replay = False
if priority_replay is not None:
use_priority_replay = True
alpha = priority_replay['alpha']
beta = priority_replay['beta']
print(f'Training DQN on {env_name} environment')
print(f'Params: gamma:{gamma}, batch_size:{batch_size}, replay_size:{replay_size}')
print(f' replay_start_size: {replay_start_size}, learning_rate:{learning_rate}')
print(f' sync_target_frames: {sync_target_frames}, epsilon_decay_last_frame:{epsilon_decay_last_frame}')
print(f' epsilon_start: {epsilon_start}, epsilon_final: {epsilon_final}, train_frames: {train_frames}')
print(f' train_rewards: {train_rewards}, n_steps: {n_steps}, save_checkpoints: {save_checkpoints}')
print(f' run_name: {run_name}, use_double: {use_double}, use_dense: {use_dense}, dueling: {dueling}')
if use_categorical:
print(f' categorical - n_atoms: {n_atoms}, v_min: {v_min}, v_max: {v_max}')
if use_priority_replay:
print(f' priority buffer - alpha: {alpha} beta: {beta}')
print(f' random_seed: {random_seed}, index: {index}')
f_name = env_name + "_" + run_name if run_name is not None else env_name
env = wrappers.make_env(env_name, record, f_name)
if random_seed is not None:
tf.random.set_seed(random_seed)
env.seed(random_seed)
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate, epsilon=adam_epsilon)
agent = Agent(env, replay_size, optimizer, batch_size, n_steps, gamma, use_double, use_dense, dueling,
use_categorical, n_atoms, v_min, v_max, train_frames if train_frames is not None else 5000000)
if save_checkpoints:
agent.load_checkpoint(f'checkpoints/{f_name}/checkpoint')
total_rewards = []
rewards_mean_std = []
frame_idx = 0
count = 0
update_count = 0
ts_frame = 0
ts = time.time()
best_mean_reward = None
while True:
frame_idx += 1
epsilon = max(epsilon_final, epsilon_start - frame_idx / epsilon_decay_last_frame)
reward = agent.play_step(epsilon)
if reward is not None:
count += 1
total_rewards.append(reward)
speed = (frame_idx - ts_frame) / (time.time() - ts)
ts_frame = frame_idx
ts = time.time()
mean_reward = np.mean(total_rewards[-100:])
print(f'{index}:{frame_idx}: done {count} games, mean reward: {mean_reward}, eps {epsilon}, speed: {speed}')
if best_mean_reward is None or best_mean_reward < mean_reward:
# Save network
if best_mean_reward is not None:
if save_checkpoints:
agent.save_checkpoint(f'./checkpoints/{f_name}/checkpoint')
print(f'Best mean reward updated {best_mean_reward} -> {mean_reward}, model saved')
best_mean_reward = mean_reward
if train_frames is not None:
if frame_idx >= train_frames:
print(f'Trained for {frame_idx} frames. Done.')
break
if train_rewards is not None:
if mean_reward >= train_rewards:
print(f'Reached reward: {mean_reward}. Done.')
break
if agent.buffer_size() < replay_start_size:
continue
if frame_idx % sync_target_frames == 0:
agent.sync_weights()
agent.step(gamma, True if update_count % 1000 == 0 else False)
update_count += 1
rewards_mean_std.append({'reward': total_rewards[-1:][0],
'step': update_count})
env.close()
plot.directory_check('./plots')
plot.plot(rewards_mean_std, f'./plots/{f_name}.png', f_name)
plot.directory_check('./data')
plot.save(rewards_mean_std, f'./data/{f_name}.csv')
def main():
np.random.seed(0)
parser = ArgumentParser()
parser.add_argument('--input_dir', type=str, default='results')
parser.add_argument('--output_dir', type=str, default='plots')
parser.add_argument('--pdf', action='store_true')
args = parser.parse_args()
if not os.path.exists(args.output_dir):
os.mkdir(args.output_dir)
# Get unique runs (ignoring seeds)
keys = set()
for f in os.listdir(args.input_dir):
k = re.sub('_seed-[0-9]+(.txt)?', '', f)
keys.add(k)
# Compute average performance and store in dictionary
bar_dict = defaultdict(dict)
for k in sorted(keys):
mean, std = compute_avg_return(k, args.input_dir)
# print(k, mean, std)
env = fix_env_name(grab('env-()', k))
rmem_type = grab('rmem-()', k)
bar_dict[env].update({rmem_type: (mean, std)})
envs_and_scores_and_errors = []
for env in bar_dict.keys():
print(env)
random_mean, _ = random_baseline(env, n=100)
uniform_mean = bar_dict[env]['ReplayMemory'][0]
uniform_std = bar_dict[env]['ReplayMemory'][1]
stratified_mean = bar_dict[env]['StratifiedReplayMemory'][0]
stratified_std = bar_dict[env]['StratifiedReplayMemory'][1]
# print('A', stratified_mean, stratified_std)
# print('B', uniform_mean, uniform_std)
# print(random_mean)
# Assumes that the random baseline is a deterministic quantity
relative_perf = 100.0 * (stratified_mean -
random_mean) / (uniform_mean - random_mean)
std_dev = 100.0 * std_divide(stratified_mean - random_mean,
stratified_std,
uniform_mean - random_mean, uniform_std)
envs_and_scores_and_errors.append((env, relative_perf, std_dev))
# Plot
plt.style.use('seaborn-darkgrid')
plt.figure()
ax = plt.gca()
envs_and_scores_and_errors = sorted(envs_and_scores_and_errors,
key=lambda x: x[1])
envs, scores, errors = zip(*envs_and_scores_and_errors)
bars = ax.barh(envs, scores, zorder=3)
error_bars = ax.errorbar(scores,
envs,
xerr=errors,
ls='none',
color='black',
capsize=3,
zorder=2)
for i, s in enumerate(scores):
ax.text(s * 0.82,
i - 0.125,
'{:0.2f}%'.format(s),
color='white',
zorder=4)
ylim = [-0.75, 10.75]
plt.ylim(ylim)
plt.vlines(100.,
ymin=ylim[0],
ymax=ylim[1],
linestyles='dashed',
color='slategray',
zorder=0)
save('bar_plot', args.output_dir, args.pdf, bbox_inches='tight')
plt.close()
from package_simulation import simulate_packages
from scheduling import round_robin, fair_queuing
print('# =============== #')
print('# Scheduling Plot #')
print('# =============== #')
print('© Dominic Plein 11/2020')
# Plot
fig, (ax1, ax2, ax3, ax4, ax5) = plot.init_plot()
# Packages
sources, max_end_time = simulate_packages(15, 40, 10)
plot.plot_broken_barh(ax1, 'Eintreffende Pakete', sources, max_end_time)
# Round Robin (abbreviated as rr)
sources_rr, diff_rr, max_end_time_rr, data_rr = round_robin(deepcopy(sources))
plot.plot_broken_barh(ax2, 'Round-Robin', sources_rr, max_end_time_rr, diff_rr)
plot.plot_scatter(ax4, 'Round-Robin (Auswertung)', data_rr)
# Fair Queuing (abbreviated as fq)
sources_fq, diff_fq, max_end_time_fq, data_fq = fair_queuing(deepcopy(sources))
plot.plot_broken_barh(ax3, 'Fair Queuing', sources_fq, max_end_time_fq,
diff_fq)
plot.plot_scatter(ax5, 'Fair Queuing (Auswertung)', data_fq)
# Plot
ax1.set_xlim(0, max(max_end_time_rr, max_end_time_fq))
plot.save(fig)
plot.show_plot()
while y_target == y:
y_target = torch.randint(low=0, high=9, size=(1, ))
success, n_queries, adv, y_hat = attack.attack(model,
x,
y_target,
target=args.target)
else:
success, n_queries, adv, y_hat = attack.attack(model, x, y)
if success and args.save:
# plot.images(x.squeeze(), y, adv.squeeze().detach(), y_hat)
# plot.history(history)
if images_saved < args.n_images:
plot.save(
adv, y_hat, "img_%d_%.2f_%s" %
(i, args.epsilon, attack.__class__.__name__))
images_saved += 1
if success:
t_queries.append(n_queries)
n_success += 1
success_rate = n_success / (i + 1)
pbar.set_description("n_success %d success_rate %.5f" %
(n_success, success_rate))
pbar.update(1)
t_count += 1
if t_count == args.n_samples:
break
pbar.close()