def load_event_scalars(log_path):
feature = log_path.split(os.sep)[-1]
print(f"Processing logfile: {os.path.abspath(log_path)}")
if feature.find("_") != -1:
feature = feature.split("_")[-1]
df = pd.DataFrame()
try:
event_acc = EventAccumulator(log_path, DEFAULT_SIZE_GUIDANCE)
event_acc.Reload()
tags = event_acc.Tags()["scalars"]
env_list = event_acc.Scalars
use_tensorflow = False
if not tags:
tags = event_acc.Tags()["tensors"]
env_list = event_acc.tensors.Items
use_tensorflow = True
for tag in tags:
event_list = env_list(tag)
if use_tensorflow:
values = list(
map(lambda x: float(tf.make_ndarray(x.tensor_proto)),
event_list))
step = list(map(lambda x: x.step, event_list))
df[tag] = values
else:
values = list(map(lambda x: x.value, event_list))
step = list(map(lambda x: x.step, event_list))
df = pd.DataFrame({feature: values}, index=step)
# Dirty catch of DataLossError
except:
print("Event file possibly corrupt: {}".format(
os.path.abspath(log_path)))
traceback.print_exc()
return df
def gatherData(path, trainlax, trainAax, vallax, valAax, name, alpha):
event_acc = EventAccumulator(path)
event_acc.Reload()
# Show all tags in the log file
print(event_acc.Tags()['scalars'])
if len(event_acc.Tags()['scalars']) == 0:
return
# E. g. get wall clock, number of steps and value for a scalar 'Accuracy'
_, trainlstp, trainLoss = zip(*event_acc.Scalars('train_loss'))
_, trainvstp, trainAcc = zip(*event_acc.Scalars('train_acc'))
_, vallstp, valLoss = zip(*event_acc.Scalars('val_loss'))
_, trainvstp, valAcc = zip(*event_acc.Scalars('val_acc'))
trainLoss = np.array(trainLoss)
trainAcc = np.array(trainAcc)
valAcc = np.array(valAcc)
valLoss = np.array(valLoss)
trainLoss = numpy_ewma_vectorized_v2(trainLoss, alpha)
trainLoss = numpy_ewma_vectorized_v2(trainAcc, alpha)
valAcc = numpy_ewma_vectorized_v2(valAcc, alpha)
valLoss = numpy_ewma_vectorized_v2(valLoss, alpha)
trainlax.plot(trainlstp, trainLoss, label=name)
trainAax.plot(trainvstp, trainAcc, label=name)
vallax.plot(vallstp, valLoss, label=name)
valAax.plot(trainvstp, valAcc, label=name)
def _load_algo_results(algo_dir: Path, expected_size: int) -> AlgoResults:
res = AlgoResults(algo_dir.name)
for run_dir in algo_dir.glob("*"):
summary = EventAccumulator(str(run_dir)).Reload()
if ("Top1_Acc_Stream/eval_phase/test_stream"
not in summary.Tags()["scalars"] or
len(summary.Scalars("Top1_Acc_Stream/eval_phase/test_stream"))
< expected_size):
print(
f"Skipping incomplete run {run_dir.parent.name}/{run_dir.name}"
)
continue
for metric_name in summary.Tags()["scalars"]:
summary.Scalars(metric_name)
res.metric_name2results[metric_name].append(
RunResult(
seed=run_dir.name,
steps=array([
event.step for event in summary.Scalars(metric_name)
]),
values=array([
event.value for event in summary.Scalars(metric_name)
]),
))
return res
def plot_tensorflow_log(log_paths):
figure = plt.figure(figsize=(8, 8))
for net, path in log_paths.items():
event_acc = EventAccumulator(path)
event_acc.Reload()
print("Available metrics: ", event_acc.Tags())
parsed_metrics = list()
for metric in event_acc.Tags()["scalars"]:
if (metric in LOGGING_METRIC) and (metric not in parsed_metrics):
metric_values = event_acc.Scalars(metric)
steps = len(metric_values)
x = np.arange(steps)
y = np.zeros([steps, 2])
y_smooth = np.zeros([steps, 2])
for i in range(steps):
y[i] = metric_values[i][2] # value
if i > SMOOTH_NUM:
y_smooth[i] = np.average(y[i - SMOOTH_NUM:i])
else:
y_smooth[i] = np.average(y[0:i])
if ("validation" in path) or ("mAP" in metric):
# validation folder is the last which is parsed so show the plot and save it
plt.plot(
x,
y_smooth[:],
label=
f'validation Accuracy for {net[:net.find("validation")]}'
)
parsed_metrics.append(metric)
handles, labels = plt.gca().get_legend_handles_labels()
by_label = dict(zip(labels, handles))
plt.legend(by_label.values(), by_label.keys())
plt.ylabel(Y_LABEL)
plt.xlabel("epoch")
plt.show()
# figure.savefig(f'./plot_metrics/pcds_bestvalidations_{LOGGING_METRIC}.png', type='png', dpi=2400)
mpl.use("pgf")
mpl.rcParams.update({
"pgf.texsystem": "pdflatex",
"font.family": "serif",
"text.usetex": True,
"pgf.rcfonts": False,
})
figure.savefig(f"./plot_metrics/pcds_bestvalidations_{LOGGING_METRIC}.pgf",
type="pgf")
def plot_tensorflow_log(log_paths):
figure = plt.figure(figsize=(8, 8))
for net, path in log_paths.items():
event_acc = EventAccumulator(path)
event_acc.Reload()
print('Available metrics: ', event_acc.Tags())
parsed_metrics = list()
for metric in event_acc.Tags()['scalars']:
if (metric in LOGGING_METRIC) and (metric not in parsed_metrics):
metric_values = event_acc.Scalars(metric)
steps = len(metric_values)
x = np.arange(steps)
y = np.zeros([steps, 2])
y_smooth = np.zeros([steps, 2])
for i in range(steps):
y[i] = metric_values[i][2] # value
if i > SMOOTH_NUM:
y_smooth[i] = np.average(y[i - SMOOTH_NUM:i])
else:
y_smooth[i] = np.average(y[0:i])
if ('validation' in path) or ('mAP' in metric):
#validation folder is the last which is parsed so show the plot and save it
plt.plot(x,
y_smooth[:],
label=f'validation {metric} {net.split()[0]}')
parsed_metrics.append(metric)
handles, labels = plt.gca().get_legend_handles_labels()
by_label = dict(zip(labels, handles))
plt.legend(by_label.values(), by_label.keys())
plt.ylabel(LOGGING_METRIC)
plt.xlabel('epoch')
plt.show()
figure.savefig(f'pcds_bestvalidations_{LOGGING_METRIC}.png',
type='png',
dpi=2400)
mpl.use("pgf")
mpl.rcParams.update({
"pgf.texsystem": "pdflatex",
'font.family': 'serif',
'text.usetex': True,
'pgf.rcfonts': False,
})
figure.savefig(f'pcds_bestvalidations_{LOGGING_METRIC}.pgf', type='pgf')
def get_tensorboard_scalars(logdir: str,
metrics: Optional[List[str]],
step: str) -> Dict[str, List]:
event_acc = EventAccumulator(str(logdir))
event_acc.Reload()
if metrics is not None:
scalar_names = [n for n in event_acc.Tags()["scalars"] if step in n
and any(m in n for m in metrics)]
else:
scalar_names = [n for n in event_acc.Tags()["scalars"] if step in n]
scalars = {sn: event_acc.Scalars(sn) for sn in scalar_names}
return scalars
def loggs_to_json(loggs_dir_path):
"""
Write the results from logs folder as .json format
:param loggs_dir_path: path to loggs folder
"""
os.makedirs(os.path.join("results", "json"), exist_ok=True)
all_results = {"Train/Loss": dict(), "Train/Acc": dict(), "Test/Loss": dict(),
"Test/Acc": dict(), "Consensus": dict(), "Round": dict()}
for dname in os.listdir(loggs_dir_path):
ea = EventAccumulator(os.path.join(loggs_dir_path, dname)).Reload()
tags = ea.Tags()['scalars']
for tag in tags:
tag_values = []
steps = []
for event in ea.Scalars(tag):
tag_values.append(event.value)
steps.append(event.step)
all_results[tag][dname] = tag_values
all_results["Round"][dname] = steps
json_path = os.path.join("results", "json", "{}.json".format(os.path.split(loggs_dir_path)[1]))
with open(json_path, "w") as f:
json.dump(all_results, f)
def save_log_to_csv(log_path, session_id):
# csv path
tb_log_path = os.path.join(log_path, session_id)
log_data_path = os.path.join(log_path, session_id, 'data')
os.makedirs(log_data_path, exist_ok=True)
csv_file_path = os.path.join(log_data_path, 'data.csv')
# tabulate sclars
summary_iterators = list()
for dname in os.listdir(tb_log_path):
it = EventAccumulator(os.path.join(tb_log_path, dname)).Reload()
if len(it.Tags()['scalars']) > 0:
summary_iterators.append(it)
break
assert len(summary_iterators) == 1
tags = summary_iterators[0].Tags()['scalars']
dfx = list()
for tag in tags:
scalars = summary_iterators[0].Scalars(tag)
df = pd.DataFrame(scalars)
df = df.loc[:, ('step', 'value')]
df = df.groupby('step').mean()
dfx.append(df)
dfx = pd.concat(dfx, axis=1)
dfx.columns = tags
dfx.to_csv(csv_file_path)
def get_tensorflow_log(path, scores={}, score_names=[]):
"""Print every event that has 'eval' in csv format to the screen.
"""
# Loading too much data is slow...
tf_size_guidance = {
'compressedHistograms': 0,
'images': 0,
'scalars': 1000,
'histograms': 0
}
event_acc = EventAccumulator(path, tf_size_guidance)
event_acc.Reload()
tags = event_acc.Tags()
event_tags = tags['scalars'] if 'scalars' in tags else []
event_tags = [et for et in event_tags if 'eval' in et]
for event_tag in event_tags:
score_name = event_tag.split('/')[-1]
if score_name not in score_names:
score_names.append(score_name)
events = event_acc.Scalars(event_tag)
for event in events:
if event.step not in scores:
scores[event.step] = {}
scores[event.step][score_name] = event.value
return scores, score_names
def extract_data(d, category, name):
# Grab all of the accuracy results for each model and put into Pandas dataframe
event_acc = EventAccumulator(d)
event_acc.Reload()
# Show all tags in the log file
print(event_acc.Tags())
s = event_acc.Scalars(
'PASCAL/PerformanceByCategory/[email protected]/{0}'.format(category))
df = pd.DataFrame(s)
if df.empty:
raise ('No {0} data available in {1}'.format(category, d))
time_start = df.wall_time[0]
# convert wall time and value to rounded values
df['wall_time'] = df['wall_time'].apply(wallToGPUTime, args=(time_start, ))
df['value'] = df['value'].apply(valueTomAP)
# rename columns
df.columns = ['GPU Time', 'step', 'Overall mAP']
df['model'] = np.full(len(df), name)
#print(df)
return df
class TensorboardLogs:
def __init__(self,
filepath: Union[Path, str],
num_scalars=0,
num_images=0):
size_guidance = {
SCALARS: num_scalars,
IMAGES: num_images,
}
self._event_acc = EventAccumulator(str(filepath),
size_guidance=size_guidance)
self._event_acc.Reload()
self.tags = self._event_acc.Tags()
self.all_tags = [
tag for _, some_tags in self.tags.items()
if isinstance(some_tags, list) for tag in some_tags
]
if len(self.all_tags) == 0:
warnings.warn(
'No tags detected, the path might not contain any logs')
def images(self, tag: str) -> List[Image.Image]:
return [
Image.open(io.BytesIO(img_event.encoded_image_string))
for img_event in self._event_acc.Images(tag)
]
def scalars(self, tag: str) -> torch.Tensor:
return torch.tensor([
scalar_event.value for scalar_event in self._event_acc.Scalars(tag)
])
def get_scores(self, name, path_file):
"""指定されたファイルからスコアの系列を取得して返す
parameters
----------
name : result directory
path_file : event path
returns
----------
"""
accumulator = EventAccumulator(path_file)
accumulator.Reload()
tag_dict = accumulator.Tags() #'images', 'audio', 'histograms', 'scalars', 'distributions', 'tensors', 'graph', 'meta_graph', 'run_metadata'
scalars_key = tag_dict['scalars']
assert scalars_key is not None
for key in scalars_key:
key_name = key.replace('/','_')
if not key_name in self.result_dic:
self.result_dic.setdefault(key_name,{})
if not name in self.result_dic[key_name]:
self.result_dic.setdefault(name,{})
value = accumulator.Scalars(key)
self.result_dic[key_name][name] = np.array([tmp.value for tmp in value])
return
def parse_summary(self, tfefile):
metric_logs = []
event_accumulator = EventAccumulator(tfefile,
size_guidance={'tensors': 0})
event_accumulator.Reload()
for tag in event_accumulator.Tags()['tensors']:
for m in self.metric_names:
tfefile_parent_dir = os.path.dirname(m) if len(
m.split("/")) >= 2 else os.path.dirname(tfefile)
basedir_name = os.path.dirname(tfefile)
if not tag.startswith(
m.split("/")[-1]) or not basedir_name.endswith(
tfefile_parent_dir):
continue
for wall_time, step, tensor in event_accumulator.Tensors(tag):
ml = api_pb2.MetricLog(time_stamp=rfc3339.rfc3339(
datetime.fromtimestamp(wall_time)),
metric=api_pb2.Metric(
name=m,
value=str(
tf.make_ndarray(tensor))))
metric_logs.append(ml)
return metric_logs
def load_data(args):
run = {"SGD": 0, "Adam": 0, "K-FAC (one-level)": 0, "K-FAC (two-level)": 0}
ind = {"SGD": 0, "Adam": 1, "K-FAC (one-level)": 2, "K-FAC (two-level)": 3}
df_list = [[] for _ in range(len(run))]
for root, _, files in os.walk(args.logdir):
for file in files:
event_acc = EventAccumulator(root)
event_acc.Reload()
optimizer = get_optimizer(root)
print(optimizer)
print(root)
data = {}
data['optimizer'] = optimizer
data['run'] = run[optimizer]
run[optimizer] += 1
for (i, scalar) in enumerate(event_acc.Tags()['scalars']):
if scalar == 'train/lr':
continue
times, epochs, values = zip(*event_acc.Scalars(scalar))
if (i == 1):
data['times'] = np.asarray(times)[:args.stop]
data['epochs'] = np.asarray(epochs)[:args.stop]
data[scalar] = np.asarray(values)[:args.stop]
if run[optimizer] == 1:
df = pd.DataFrame(data)
df_list[ind[optimizer]] = df
else:
df = pd.DataFrame(data)
df_list[ind[optimizer]] = pd.concat(
[df_list[ind[optimizer]], df])
df = pd.concat(df_list)
return df
def _accumulate_logs(subject, exp_id):
# extract name of logfile
stats_folder = os.path.join(PROBLEM, EXP_FOLDER.format(exp_id), "stats")
log_files = os.listdir(stats_folder)
assert(len(log_files) == 1)
log_file = os.path.join(stats_folder, log_files[0])
# get eventaccumulator
ea = EventAccumulator(log_file)
ea.Reload()
# load data file
name_addon = f"data_S{subject:02}"
data_file = os.path.join(PROBLEM, EXPORT_FILE.format(name_addon))
if os.path.exists(data_file):
with np.load(data_file) as data_loader:
data = dict(data_loader)
else:
data = {'num_trials': 0}
# update the data dictionary to keep the mean value
num_trials = data['num_trials']
for key in ea.Tags()['scalars']:
new_arr = _prepare_scalar_array_from_tensorboard(ea, key)
if num_trials == 0:
# just add the data
data[key] = new_arr
else:
assert(key in data)
data[key] = (data[key] * num_trials + new_arr) / (num_trials + 1)
data['num_trials'] += 1
# store data back into the same file
np.savez(data_file, **data)
class TensorUtils(object):
def __init__(self, engine_id):
self.eacc = None
engine = Engine.query.filter_by(id=engine_id).first()
if engine.model_path:
tensor_path = os.path.join(engine.model_path, "tensorboard")
else:
tensor_path = os.path.join(engine.path, "model/tensorboard")
files = glob.glob(os.path.join(tensor_path, "*"))
if len(files) > 0:
log = files[0]
self.eacc = EventAccumulator(log)
self.eacc.Reload()
def is_loaded(self):
return self.eacc is not None
def get_tag(self, tag):
if self.eacc:
tags = self.eacc.Tags()
if tag in tags.get('scalars'):
return self.eacc.Scalars(tag)
return []
def plot_tb(filename, export=None, act_quant_line=None):
from eegnet_run import _prepare_scalar_array_from_tensorboard as prepare_tb_array
from tensorboard.backend.event_processing.event_accumulator import EventAccumulator
ea = EventAccumulator(filename)
ea.Reload()
data = {key: prepare_tb_array(ea, key) for key in ea.Tags()['scalars']}
plot_data(data, export, act_quant_line)
def parseTrainLogs(logs):
log_tensors = {}
if len(glob.glob(str(logs / "events.out.tfevents*"))) != 0:
from tensorboard.backend.event_processing.event_accumulator import EventAccumulator
event_acc = EventAccumulator(str(logs))
event_acc.Reload()
if 'scalars' in event_acc.Tags():
for tag in event_acc.Tags()['scalars']:
wall_time, steps, value = zip(*event_acc.Scalars(tag))
log_tensors[tag] = [{
'wall_time': w,
'step_num': s,
'value': v
} for w, s, v in zip(wall_time, steps, value)]
return log_tensors
def tflog2pandas(path: str) -> pd.DataFrame:
"""convert single tensorflow log file to pandas DataFrame
Parameters
----------
path : str
path to tensorflow log file
Returns
-------
pd.DataFrame
converted dataframe
"""
DEFAULT_SIZE_GUIDANCE = {
"compressedHistograms": 1,
"images": 1,
"scalars": 0, # 0 means load all
"histograms": 1,
}
runlog_data = pd.DataFrame({"metric": [], "value": [], "step": []})
try:
event_acc = EventAccumulator(path, DEFAULT_SIZE_GUIDANCE)
event_acc.Reload()
tags = event_acc.Tags()["scalars"]
# tags = event_acc.Tags()["images"]
for tag in tags:
event_list = event_acc.Scalars(tag)
values = list(map(lambda x: x.value, event_list))
step = list(map(lambda x: x.step, event_list))
r = {"metric": [tag] * len(step), "value": values, "step": step}
r = pd.DataFrame(r)
runlog_data = pd.concat([runlog_data, r])
# Dirty catch of DataLossError
except Exception:
print("Event file possibly corrupt: {}".format(path))
traceback.print_exc()
return runlog_data
def tabulate_events(dpath):
final_out = {}
for dname in os.listdir(dpath):
print(f"Converting run {dname}", end="")
ea = EventAccumulator(os.path.join(dpath, dname)).Reload()
tags = ea.Tags()['scalars']
out = {}
for tag in tags:
tag_values = []
wall_time = []
steps = []
for event in ea.Scalars(tag):
tag_values.append(event.value)
wall_time.append(event.wall_time)
steps.append(event.step)
out[tag] = pd.DataFrame(data=dict(
zip(steps,
np.array([tag_values, wall_time]).transpose())),
columns=steps,
index=['value', 'wall_time'])
if len(tags) > 0:
df = pd.concat(out.values(), keys=out.keys())
df.to_csv(f'{dname}.csv')
print("- Done")
final_out[dname] = df
else:
print('- Not scalers to write')
return final_out
def check_practical_complete(job_list):
log_path = '/scratch/li.baol/tsrbrd_log/job_runs/' + testcase + '/'
threshold = 0.01
global pc_job
global PJCT
for job in job_list:
# only check for job outside of practical complete job list
if job not in pc_job and job != 'idle':
log_dir = log_path + 'job' + job + '/*'
dirs = glob.glob(log_dir)
dirs.sort()
loss_combine = []
for tc in dirs:
iterator = EventAccumulator(tc).Reload()
if len(iterator.Tags()['scalars']) > 0:
tag = 'loss' #iterator.Tags()['scalars'][2] # this is tag for loss
loss = [item.value for item in iterator.Scalars(tag)]
loss_combine += loss
# now that we have the loss at each epoch, we can check if it has reached practical complete
if len(loss_combine) >= 4:
latest_loss = loss_combine[-4:]
finished = True
for i in range(3):
# if the difference is >= 0.01, the job has not reached practical complete yet
if latest_loss[i] - latest_loss[i+1] >= threshold:
finished = False
break
if finished:
print('job' + job + ' has reached practical complete, the last 4 loss values are')
print(str(latest_loss))
pc_job.append(job)
PJCT[job] = int(time.time() - job_start[job])
def load_tensorboard(path):
'''Function to load tensorboard file from a folder.
Assumes one file per folder!'''
event_paths = [
file for file in os.walk(path, topdown=True)
if file[2][0][:len('events')] == 'events'
]
df = pd.DataFrame()
steps = None # steps are the same for all files
for event_idx, path in enumerate(event_paths):
summary_iterator = EventAccumulator(os.path.join(path[0],
path[2][0])).Reload()
tags = summary_iterator.Tags()['scalars']
data = [[event.value for event in summary_iterator.Scalars(tag)]
for tag in tags]
if steps is None:
steps = [event.step for event in summary_iterator.Scalars(tags[0])]
# Adding to dataframe
tags = [tag.replace('/', '_') for tag in tags] # for name consistency
if event_idx > 0: # We have one file in the top level, so after we need to use folder name
tags = [path[0].split('/')[-1]]
for idx, tag in enumerate(tags):
df[tag] = data[idx]
df.index = steps
return df
def sum_log(path: str):
"""Extract values from path to log file"""
default_size_guidance = {
'compressedHistograms': 1,
'images': 1,
'scalars': 0, # 0 means load all
'histograms': 1
}
runlog = pd.DataFrame({"metric": [], "value": [], "step": []})
event_acc = EventAccumulator(path, default_size_guidance)
event_acc.Reload()
tags = event_acc.Tags()["scalars"]
for tag in tags:
event_list = event_acc.Scalars(tag)
values = list(map(lambda x: x.value, event_list))
step = list(map(lambda x: x.step, event_list))
r = {"metric": [tag] * len(step), "value": values, "step": step}
r = pd.DataFrame(r)
runlog = pd.concat([runlog, r])
# Extract additional tags from path
description, run_type = path.split('/')[-3:-1]
embedding = description.split('_')
embedding, architecture, fold = embedding[0], embedding[1], embedding[-1]
runlog['embedding'] = embedding
runlog['architecture'] = architecture
runlog['fold'] = fold
runlog['run_type'] = run_type
return runlog
def plot_tensorflow_log():
# Loading too much data is slow...
tf_size_guidance = {
'compressedHistograms': 10,
'images': 0,
'scalars': 100,
'histograms': 1
}
has_range = "xrange" in config
if has_range:
cfg_range = config["xrange"]
if len(cfg_range) > 1:
data_range = range(cfg_range[0], cfg_range[1])
else:
data_range = range(cfg_range[0])
for cfg in config["scalar_data"]:
event_acc = EventAccumulator(cfg["path"], tf_size_guidance)
event_acc.Reload()
# Show all tags in the log file
if debug_events:
print(event_acc.Tags())
events = event_acc.Scalars(cfg["tag"])
steps = len(events)
if not has_range:
x = np.arange(steps)
else:
x = data_range
y = np.zeros(len(x))
for i in range(len(x)):
y[i] = events[i][2]
plt.plot(x[:], y[:], label=cfg["plot_label"])
for cfg in config["manual_data"]:
events = cfg["data"]
steps = len(events)
if not has_range:
x = np.arange(steps)
else:
x = data_range
y = np.zeros(len(x))
for i in range(len(x)):
y[i] = events[i]
plt.plot(x[:], y[:], label=cfg["plot_label"])
plt.xlabel(config["xlabel"])
plt.ylabel(config["ylabel"])
plt.ylim(bottom=98.9, top=99.4)
plt.legend(loc=config["legend_loc"], frameon=True)
plt.show()
def parse_progress(path, tf_size_guidance):
event_acc = EventAccumulator(path, tf_size_guidance)
event_acc.Reload()
tags = event_acc.Tags()['scalars']
print(tags)
# Show all tags in the log file
tags = event_acc.Tags()['scalars']
runtimes_scalar = event_acc.Scalars('runtime_ms')
runtimes = [runtimes_scalar[i].value for i in range(len(runtimes_scalar))]
loss_scalar = event_acc.Scalars('loss')
loss = [loss_scalar[i].value for i in range(len(loss_scalar))]
assert len(runtimes) == len(loss)
return runtimes, loss
def extract_scalar_from_event(path):
event_acc = EventAccumulator(path, size_guidance={'scalars': 0})
event_acc.Reload() # ログファイルのサイズによっては非常に時間がかかる
target_key = ['step', 'value', 'wall_time']
scalars = {}
for tag in event_acc.Tags()['scalars']:
events = event_acc.Scalars(tag)
scalars[tag] = [{k: event.__getattribute__(k) for k in target_key} for event in events]
return scalars
def read_tf_event_file(tfevent_file):
# Read in tensorflow summary file
event_acc = EventAccumulator(path=tfevent_file)
event_acc.Reload()
run_config = {}
for scalar_summary_key in event_acc.Tags()['scalars']:
_, step_nums, values = zip(*event_acc.Scalars(scalar_summary_key))
run_config[scalar_summary_key] = values
return run_config
def parse_runtime(path, tf_size_guidance):
event_acc = EventAccumulator(path, tf_size_guidance)
event_acc.Reload()
# Show all tags in the log file
tags = event_acc.Tags()['scalars']
al = event_acc.Scalars('alpha_1_2')
runtime_row = []
for i in range(len(al)):
runtime_row.append(al[i].value)
print(runtime_row)
def tabulate_events(event):
data = {}
event_acc = EventAccumulator(event)
event_acc.Reload()
for tag in sorted(event_acc.Tags()["scalars"]):
x = []
for scalar_event in event_acc.Scalars(tag):
x.append(scalar_event.value)
data[tag] = (np.array(x))
return data
def gatherData(path, alpha):
event_acc = EventAccumulator(path)
event_acc.Reload()
# Show all tags in the log file
print(event_acc.Tags()['scalars'])
if len(event_acc.Tags()['scalars']) == 0:
return
# E. g. get wall clock, number of steps and value for a scalar 'Accuracy'
_, stp, bestMeanRwd = zip(*event_acc.Scalars('Best_mean_reward'))
_, stp, mean100ep = zip(*event_acc.Scalars('Mean_reward__100_episodes_'))
_, stp, loss = zip(*event_acc.Scalars('Train_loss'))
bestMeanRwd = np.array(bestMeanRwd)
mean100ep = np.array(mean100ep)
loss = np.array(loss)
stp = np.array(stp)
print(path)
# bestMeanRwd = numpy_ewma_vectorized_v2(bestMeanRwd, alpha)
# loss = numpy_ewma_vectorized_v2(loss, alpha)
# mean100ep = numpy_ewma_vectorized_v2(mean100ep, alpha)
return (stp, bestMeanRwd, mean100ep, loss)
