def get_scores_from_dict(data,stats,road_types):
weights = expert.expert()
scores = {}
counter = 0
distances_total = {}
score_per_metric ={}
for subid in data:
temp_score_dict = {}
distances = {}
for metric in data[subid]:
if metric !="distance":
if metric not in score_per_metric:
score_per_metric[metric] = {}
for i,road_type in enumerate(road_types):
if road_type not in score_per_metric[metric]:
score_per_metric[metric][road_type] = []
distance = data[subid]['distance'][road_type]
if distance!=0.0:
#score_class = get_class(stats[metric][road_type],data[subid][metric][road_type],percentiles)
sum_of_percentiles = get_sum(stats[metric][road_type])
if sum_of_percentiles!=0.0:
score_class = get_class(stats[metric][road_type],data[subid][metric][road_type])
score_weight = weights[metric][score_class]
#score_weight = get_gauss(data[subid][metric][road_type],stats[metric][road_type][75]-stats[metric][road_type][25],stats[metric][road_type][50],weights[metric]['high'],weights[metric]['low'])
score_per_metric[metric][road_type].append(score_weight*100.0)
return score_per_metric
def get_scores_from_dict_with_gauss(data,stats,road_types,percentiles,mad):
weights = expert.expert()
scores = {}
counter = 0
distances_total = {}
for subid in data:
temp_score_dict = {}
distances = {}
for metric in data[subid]:
if metric !="distance":
for i,road_type in enumerate(road_types):
if road_type not in temp_score_dict:
temp_score_dict[road_type] = 0.0
distances[road_type] = 0.0
score_weight = get_gauss(data[subid][metric][road_type],mad[metric][road_type],stats[metric][road_type][50],weights[metric]['high'],weights[metric]['low'])
temp_score_dict[road_type]+=weights['multiply'][metric]*score_weight
distances[road_type] = data[subid]['distance'][road_type]
score = 0.0
total_distance = 0.0
for road_type in temp_score_dict:
score+=temp_score_dict[road_type]*distances[road_type]
total_distance+=distances[road_type]
if total_distance>0.0:
scores[subid] = 100.0*score/total_distance
return scores
def get_scores_from_dict(data,stats,road_types,percentiles):
weights = expert.expert()
scores = {}
counter = 0
distances_total = {}
for subid in data:
temp_score_dict = {}
distances = {}
for metric in data[subid]:
if metric !="distance":
for i,road_type in enumerate(road_types):
if data[subid]['distance'][road_type]!=0.0:
if road_type not in temp_score_dict:
temp_score_dict[road_type] = 0.0
distances[road_type] = 0.0
score_class = get_class(stats[metric][road_type],data[subid][metric][road_type],percentiles)
temp_score_dict[road_type]+=weights['multiply'][metric]*weights[metric][score_class]
distances[road_type] = data[subid]['distance'][road_type]
score = 0.0
total_distance = 0.0
for road_type in temp_score_dict:
score+=temp_score_dict[road_type]*distances[road_type]
total_distance+=distances[road_type]
if total_distance>0.0:
scores[subid] = 100.0*score/total_distance
return scores
def collector(idx, shared_model, shared_dataset, hyperparameters, lock):
try:
writer = SummaryWriter('runs/{}/collector:{:02}'.format(
datetime.now().strftime("%d|%m_%H|%M"), idx))
logging.basicConfig(filename='logs/collector:{:02}.log'.format(idx),
filemode='w',
format='%(message)s',
level=logging.DEBUG)
# allocate a device
n_gpu = t.cuda.device_count()
if n_gpu > 0:
Device.set_device(idx % n_gpu)
local_model = deepcopy(shared_model)
local_model.to(Device.get_device())
local_model.eval()
simulator = SIMULATOR()
for itr in tqdm(count(),
position=idx,
desc='collector:{:02}'.format(idx)):
local_model.load_state_dict(shared_model.state_dict())
state = simulator.reset()
episode_reward = 0
for i in range(50):
# Find the expert action for input belief
expert_action, _ = expert(state, hyperparameters)
lock.acquire()
shared_dataset.append((state, expert_action))
lock.release()
# Simulate the learner's action
action, _ = local_model.search(state, hyperparameters)
state, reward, terminal = simulator.step(action)
episode_reward += reward
if terminal:
break
logging.debug('Episode reward: {:.2f}'.format(episode_reward))
writer.add_scalar('episode_reward', episode_reward, itr)
writer.close()
except KeyboardInterrupt:
print('exiting collector:{:02}'.format(idx))
def get_scores_from_dict_scores_with_counts(data,counts,stats,road_types):
weights = expert.expert()
default_n = 4
distances = {}
scores = {}
score_output = {}
for subid in data:
scores[subid] = {}
for metric in data[subid]:
if metric!="distance":
if metric not in scores[subid]:
scores[subid][metric] = 0.0
distances = {}
total_distances = 0.0
total_counts = 0.0
for road_type in data[subid][metric]:
count_roadtype_metric = counts[subid][metric][road_type]
distance = data[subid]['distance'][road_type]
if distance!=0.0:
if road_type not in distances:
distances[road_type] = distance
total_distances+=distance
score_class = get_class(stats[metric][road_type],data[subid][metric][road_type])
if metric!="pace":
if count_roadtype_metric!=0:
scores[subid][metric]+=(count_roadtype_metric*float(weights[metric][score_class])*distance)
total_counts+=(count_roadtype_metric*distance)
else:
scores[subid][metric]+=(default_n*1.0*distance)
total_counts+=(default_n*distance)
else:
scores[subid][metric]+=(float(weights[metric][score_class])*distance)
if metric!="pace":
scores[subid][metric]/=total_counts
else:
scores[subid][metric]/=total_distances
return scores
def get_scores_from_dict_scores(data,stats,road_types):
weights = expert.expert()
scores = {}
counter = 0
distances_total = {}
score_per_metric ={}
for subid in data:
temp_score_dict = {}
distances = {}
if subid not in score_per_metric:
score_per_metric[subid] = 0.0
for metric in data[subid]:
if metric !="distance":
test_distance = {}
total_distance = 0.0
for i,road_type in enumerate(road_types):
distance = data[subid]['distance'][road_type]
if distance!=0.0:
#score_class = get_class(stats[metric][road_type],data[subid][metric][road_type],percentiles)
sum_of_percentiles = get_sum(stats[metric][road_type])
if sum_of_percentiles!=0.0:
score_class = get_class(stats[metric][road_type],data[subid][metric][road_type])
score_weight = weights[metric][score_class]
if road_type not in test_distance:
test_distance[road_type] = 0.0
total_distance+=distance
#score_weight = get_gauss(data[subid][metric][road_type],stats[metric][road_type][75]-stats[metric][road_type][25],stats[metric][road_type][50],weights[metric]['high'],weights[metric]['low'])
score_per_metric[subid]+=score_weight*weights['multiply'][metric]*distance
score_per_metric[subid]/=total_distance
scores = []
for subid in score_per_metric:
scores.append(100*score_per_metric[subid])
return scores
arr_old_scores.append(int(ares_scores[subid]))
mean_new, std_new = round(np.mean(arr), 3), round(np.std(arr), 3)
mean_old, std_old = round(np.mean(arr_old_scores), 3), round(np.std(arr_old_scores), 3)
# arr = transform_new_scores(arr,mean_new,std_new)
numbins = np.arange(0, 105, 5)
plt.subplot(121)
plt.hist(arr_old_scores, color="c", bins=numbins, label="Mean:{0} Stddev: {1}".format(mean_old, std_old))
plt.xlabel("Expert score")
plt.gca().yaxis.set_major_locator(plt.NullLocator())
plt.legend(loc=0)
plt.subplot(122)
plt.hist(arr, color="c", bins=numbins, label="Mean:{0} Stddev: {1}".format(mean_new, std_new))
plt.xlabel("Expert score")
plt.gca().yaxis.set_major_locator(plt.NullLocator())
plt.legend(loc=0)
plt.show()
paras = {}
paras["low_thres_upper"] = 40 # 5
paras["ideal_thres_upper"] = 60 # 80
paras["average_thres_upper"] = 80 # 95
paras["weights"] = expert.expert()
contract = "axaie_apps_2014-01-27"
ext = "../../sav_files/computed_algorithm_with_percentile_thresholds/"
sav_file = "{0}{1}_1.sav".format(ext, contract)
with open(sav_file, "w") as g:
pickle.dump([paras, ares_comp_scores], g)
