def test_save_text():
console = Console(record=True, width=100)
console.print("foo")
with tempfile.TemporaryDirectory() as path:
export_path = os.path.join(path, "rich.txt")
console.save_text(export_path)
with open(export_path, "rt") as text_file:
assert text_file.read() == "foo\n"
def output_profiles(
self,
stats: ScaleneStatistics,
pid: int,
profile_this_code: Callable[[Filename, LineNumber], bool],
python_alias_dir_name: Filename,
python_alias_dir: Filename,
profile_memory: bool = True,
reduced_profile: bool = False,
) -> bool:
"""Write the profile out."""
# Get the children's stats, if any.
if not pid:
stats.merge_stats(python_alias_dir_name)
try:
shutil.rmtree(python_alias_dir)
except BaseException:
pass
current_max: float = stats.max_footprint
# If we've collected any samples, dump them.
if (not stats.total_cpu_samples
and not stats.total_memory_malloc_samples
and not stats.total_memory_free_samples):
# Nothing to output.
return False
# Collect all instrumented filenames.
all_instrumented_files: List[Filename] = list(
set(
list(stats.cpu_samples_python.keys()) +
list(stats.cpu_samples_c.keys()) +
list(stats.memory_free_samples.keys()) +
list(stats.memory_malloc_samples.keys())))
if not all_instrumented_files:
# We didn't collect samples in source files.
return False
title = Text()
mem_usage_line: Union[Text, str] = ""
growth_rate = 0.0
if profile_memory:
samples = stats.memory_footprint_samples
if len(samples.get()) > 0:
# Output a sparkline as a summary of memory usage over time.
_, _, spark_str = sparkline.generate(
samples.get()[0:samples.len()], 0, current_max)
# Compute growth rate (slope), between 0 and 1.
if stats.allocation_velocity[1] > 0:
growth_rate = (100.0 * stats.allocation_velocity[0] /
stats.allocation_velocity[1])
# If memory used is > 1GB, use GB as the unit.
if current_max > 1024:
mem_usage_line = Text.assemble(
"Memory usage: ",
((spark_str, "blue")),
(" (max: %6.2fGB, growth rate: %3.0f%%)\n" %
((current_max / 1024), growth_rate)),
)
else:
# Otherwise, use MB.
mem_usage_line = Text.assemble(
"Memory usage: ",
((spark_str, "blue")),
(" (max: %6.2fMB, growth rate: %3.0f%%)\n" %
(current_max, growth_rate)),
)
null = open("/dev/null", "w")
# Get column width of the terminal and adjust to fit.
# Note that Scalene works best with at least 132 columns.
if self.html:
column_width = 132
else:
column_width = shutil.get_terminal_size().columns
console = Console(
width=column_width,
record=True,
force_terminal=True,
file=null,
)
# Build a list of files we will actually report on.
report_files: List[Filename] = []
# Sort in descending order of CPU cycles, and then ascending order by filename
for fname in sorted(
all_instrumented_files,
key=lambda f: (-(stats.cpu_samples[f]), f),
):
fname = Filename(fname)
try:
percent_cpu_time = (100 * stats.cpu_samples[fname] /
stats.total_cpu_samples)
except ZeroDivisionError:
percent_cpu_time = 0
# Ignore files responsible for less than some percent of execution time and fewer than a threshold # of mallocs.
if (stats.malloc_samples[fname] < self.malloc_threshold
and percent_cpu_time < self.cpu_percent_threshold):
continue
report_files.append(fname)
# Don't actually output the profile if we are a child process.
# Instead, write info to disk for the main process to collect.
if pid:
stats.output_stats(pid, python_alias_dir_name)
return True
for fname in report_files:
# Print header.
percent_cpu_time = (100 * stats.cpu_samples[fname] /
stats.total_cpu_samples)
new_title = mem_usage_line + (
"%s: %% of time = %6.2f%% out of %6.2fs." %
(fname, percent_cpu_time, stats.elapsed_time))
# Only display total memory usage once.
mem_usage_line = ""
tbl = Table(
box=box.MINIMAL_HEAVY_HEAD,
title=new_title,
collapse_padding=True,
width=column_width - 1,
)
tbl.add_column("Line", justify="right", no_wrap=True)
tbl.add_column("Time %\nPython", no_wrap=True)
tbl.add_column("Time %\nnative", no_wrap=True)
tbl.add_column("Sys\n%", no_wrap=True)
tbl.add_column("GPU\n%", no_wrap=True)
other_columns_width = 0 # Size taken up by all columns BUT code
if profile_memory:
tbl.add_column("Mem %\nPython", no_wrap=True)
tbl.add_column("Net\n(MB)", no_wrap=True)
tbl.add_column("Memory usage\nover time / %", no_wrap=True)
tbl.add_column("Copy\n(MB/s)", no_wrap=True)
other_columns_width = 72 + 5 # GPU
tbl.add_column(
"\n" + fname,
width=column_width - other_columns_width,
no_wrap=True,
)
else:
other_columns_width = 36 + 5 # GPU
tbl.add_column(
"\n" + fname,
width=column_width - other_columns_width,
no_wrap=True,
)
# Print out the the profile for the source, line by line.
with open(fname, "r") as source_file:
# We track whether we should put in ellipsis (for reduced profiles)
# or not.
did_print = True # did we print a profile line last time?
code_lines = source_file.read()
# Generate syntax highlighted version for the whole file,
# which we will consume a line at a time.
# See https://github.com/willmcgugan/rich/discussions/965#discussioncomment-314233
syntax_highlighted = None
if self.html:
syntax_highlighted = Syntax(
code_lines,
"python",
theme="default",
line_numbers=False,
code_width=None,
)
else:
syntax_highlighted = Syntax(
code_lines,
"python",
theme="vim",
line_numbers=False,
code_width=None,
)
capture_console = Console(
width=column_width - other_columns_width,
force_terminal=True,
)
formatted_lines = [
SyntaxLine(segments) for segments in
capture_console.render_lines(syntax_highlighted)
]
for line_no, line in enumerate(formatted_lines, start=1):
old_did_print = did_print
did_print = self.output_profile_line(
fname,
LineNumber(line_no),
line,
console,
tbl,
stats,
profile_this_code,
profile_memory=profile_memory,
force_print=True,
suppress_lineno_print=False,
is_function_summary=False,
reduced_profile=reduced_profile,
)
if old_did_print and not did_print:
# We are skipping lines, so add an ellipsis.
tbl.add_row("...")
old_did_print = did_print
# Potentially print a function summary.
fn_stats = stats.build_function_stats(fname)
print_fn_summary = False
for fn_name in fn_stats.cpu_samples_python:
if fn_name == fname:
continue
print_fn_summary = True
break
if print_fn_summary:
tbl.add_row(None, end_section=True)
txt = Text.assemble("function summary", style="bold italic")
if profile_memory:
tbl.add_row("", "", "", "", "", "", "", "", "", txt)
else:
tbl.add_row("", "", "", "", "", txt)
for fn_name in sorted(
fn_stats.cpu_samples_python,
key=lambda k: stats.firstline_map[k],
):
if fn_name == fname:
continue
if self.html:
syntax_highlighted = Syntax(
fn_name,
"python",
theme="default",
line_numbers=False,
code_width=None,
)
else:
syntax_highlighted = Syntax(
fn_name,
"python",
theme="vim",
line_numbers=False,
code_width=None,
)
# force print, suppress line numbers
self.output_profile_line(
fn_name,
LineNumber(1),
syntax_highlighted, # type: ignore
console,
tbl,
fn_stats,
profile_this_code,
profile_memory=profile_memory,
force_print=True,
suppress_lineno_print=True,
is_function_summary=True,
reduced_profile=reduced_profile,
)
console.print(tbl)
# Report top K lines (currently 5) in terms of net memory consumption.
net_mallocs: Dict[LineNumber, float] = defaultdict(float)
for line_no in stats.bytei_map[fname]:
for bytecode_index in stats.bytei_map[fname][line_no]:
net_mallocs[line_no] += (stats.memory_malloc_samples[fname]
[line_no][bytecode_index] -
stats.memory_free_samples[fname]
[line_no][bytecode_index])
net_mallocs = OrderedDict(
sorted(net_mallocs.items(), key=itemgetter(1), reverse=True))
if len(net_mallocs) > 0:
console.print("Top net memory consumption, by line:")
number = 1
for net_malloc_lineno in net_mallocs:
if net_mallocs[net_malloc_lineno] <= 1:
break
if number > 5:
break
output_str = ("(" + str(number) + ") " +
("%5.0f" % (net_malloc_lineno)) + ": " +
("%5.0f" %
(net_mallocs[net_malloc_lineno])) + " MB")
console.print(output_str)
number += 1
# Only report potential leaks if the allocation velocity (growth rate) is above some threshold
# FIXME: fixed at 1% for now.
# We only report potential leaks where the confidence interval is quite tight and includes 1.
growth_rate_threshold = 0.01
leak_reporting_threshold = 0.05
leaks = []
if growth_rate / 100 > growth_rate_threshold:
vec = list(stats.leak_score[fname].values())
keys = list(stats.leak_score[fname].keys())
for index, item in enumerate(stats.leak_score[fname].values()):
# See https://en.wikipedia.org/wiki/Rule_of_succession
frees = item[1]
allocs = item[0]
expected_leak = (frees + 1) / (frees + allocs + 2)
if expected_leak <= leak_reporting_threshold:
leaks.append((
keys[index],
1 - expected_leak,
net_mallocs[keys[index]],
))
if len(leaks) > 0:
# Report in descending order by least likelihood
for leak in sorted(leaks, key=itemgetter(1), reverse=True):
output_str = (
"Possible memory leak identified at line " +
str(leak[0]) + " (estimated likelihood: " +
("%3.0f" %
(leak[1] * 100)) + "%" + ", velocity: " +
("%3.0f MB/s" %
(leak[2] / stats.elapsed_time)) + ")")
console.print(output_str)
if self.html:
# Write HTML file.
md = Markdown(
"generated by the [scalene](https://github.com/plasma-umass/scalene) profiler"
)
console.print(md)
if not self.output_file:
self.output_file = "/dev/stdout"
console.save_html(self.output_file, clear=False)
else:
if not self.output_file:
# No output file specified: write to stdout.
sys.stdout.write(console.export_text(styles=True))
else:
# Don't output styles to text file.
console.save_text(self.output_file, styles=False, clear=False)
return True
def hermes(args: Optional[List[str]] = None) -> None:
"""HermesPy Command Line Interface.
Default entry point to execute hermespy `.yml` files via terminals.
Args:
args ([List[str], optional):
Command line arguments.
By default, the system argument vector will be interpreted.
"""
# Recover command line arguments from system if none are provided
if args is None:
args = sys.argv[1:]
parser = argparse.ArgumentParser(
description='HermesPy - The Heterogeneous Mobile Radio Simulator',
prog='hermes')
parser.add_argument(
"-p",
help="settings directory from which to read the configuration",
type=str)
parser.add_argument(
"-o",
help="output directory to which results will be dumped",
type=str)
parser.add_argument("-s", help="style of result plots", type=str)
parser.add_argument('-t',
'--test',
action='store_true',
help='run in test-mode, does not dump results')
parser.add_argument('-l',
'--log',
action='store_true',
help='log the console information to a txt file')
arguments = parser.parse_args(args)
input_parameters_dir = arguments.p
results_dir = arguments.o
style = arguments.s
# Create console
console = Console(record=arguments.log)
console.show_cursor(False)
# Draw welcome header
console.print(
"\n[bold green]Welcome to HermesPy - The Heterogeneous Radio Mobile Simulator\n"
)
console.print(f"Version: {__version__}")
console.print(f"Maintainer: {__maintainer__}")
console.print(f"Contact: {__email__}")
console.print(
"\nFor detailed instructions, refer to the documentation https://barkhausen-institut.github.io/hermespy"
)
console.print(
"Please report any bugs to https://github.com/Barkhausen-Institut/hermespy/issues\n"
)
# Validate command line parameters
if not input_parameters_dir:
input_parameters_dir = os.path.join(os.getcwd(), '_settings')
elif not (os.path.isabs(input_parameters_dir)):
input_parameters_dir = os.path.join(os.getcwd(), input_parameters_dir)
console.log(f"Configuration will be read from '{input_parameters_dir}'")
with console.status("Initializing Environment...", spinner='dots'):
##################
# Import executable from YAML config dump
factory = Factory()
try:
# Load serializable objects from configuration files
serializables: List[Serializable] = factory.load(
input_parameters_dir)
# Filter out non-executables from the serialization list
executables: List[Executable] = [
s for s in serializables if isinstance(s, Executable)
]
# Abort execution if no executable was found
if len(executables) < 1:
console.log(
"No executable routine was detected, aborting execution",
style="red")
exit(-1)
# For now, only single executables are supported
executable = executables[0]
# Configure executable
if results_dir is None:
executable.results_dir = Executable.default_results_dir()
else:
executable.results_dir = results_dir
except ConstructorError as error:
print(
"\nYAML import failed during parsing of line {} in file '{}':\n\t{}"
.format(error.problem_mark.line,
error.problem_mark.name,
error.problem,
file=sys.stderr))
exit(-1)
# Configure console
executable.console = console
# Configure style
if style is not None:
executable.style = style
# Inform about the results directory
console.log("Results will be saved in '{}'".format(
executable.results_dir))
# Dump current configuration to results directory
if not arguments.test:
shutil.copytree(input_parameters_dir,
executable.results_dir,
dirs_exist_ok=True)
##################
# run simulation
executable.execute()
###########
# Goodbye :)
console.log('Configuration executed. Goodbye.')
# Save log
if arguments.log:
console.save_text(os.path.join(executable.results_dir, 'log.txt'))
print_table()
# Get console output as text
file1 = "table_export_plaintext.txt"
text = console.export_text()
with open(file1, "w") as file:
file.write(text)
print(f"Exported console output as plain text to {file1}")
# Calling print_table again because console output buffer
# is flushed once export function is called
print_table()
# Get console output as html
# use clear=False so output is not flushed after export
file2 = "table_export_html.html"
html = console.export_html(clear=False)
with open(file2, "w") as file:
file.write(html)
print(f"Exported console output as html to {file2}")
# Export text output to table_export.txt
file3 = "table_export_plaintext2.txt"
console.save_text(file3, clear=False)
print(f"Exported console output as plain text to {file3}")
# Export html output to table_export.html
file4 = "table_export_html2.html"
console.save_html(file4)
print(f"Exported console output as html to {file4}")
while tmp_threshold < 1.0:
tmp_y_true = np.asarray(tmp_label)
tmp_y_pred = np.squeeze((tmp_pred > tmp_threshold).astype(np.int64))
tn, fp, fn, tp = confusion_matrix(tmp_y_true, tmp_y_pred).ravel()
precision = tp / (tp + fp)
recall = tp / (tp + fn)
f1_score = 2 * (precision * recall) / (precision + recall)
accuracy = (tp + tn) / (tn + fp + fn + tp)
if f1_score > best_f1_score:
best_threshold = tmp_threshold
best_precision = precision
best_recall = recall
best_f1_score = f1_score
best_accuracy = accuracy
tmp_progress_part.update(tmp_task_id, advance=1)
tmp_threshold += 0.01
tmp_model_2_metrics['Threshold'] = round(best_threshold, 2)
tmp_model_2_metrics['Precision'] = round(best_precision * 100, 2)
tmp_model_2_metrics['Recall'] = round(best_recall * 100, 2)
tmp_model_2_metrics['F1'] = round(best_f1_score * 100, 2)
tmp_model_2_metrics['Accuracy'] = round(best_accuracy * 100, 2)
data_2_model[data_type][model_name] = tmp_model_2_metrics
console.log(f"[bold]{models_folder}[/bold] 模型集合评测结果")
# 构建评测统计表格
# print(data_2_model)
for tmp_dataset_name, tmp_data_dict in data_2_model.items():
construct_table(tmp_dataset_name, tmp_data_dict)
console.log(f"Evaluating finished.")
console.save_text(f'./{models_folder}模型集合评测结果.txt')
