|
|
| import inspect
|
| import os
|
| import random
|
| import sys
|
| import matplotlib.cm as cmx
|
| import matplotlib.colors as colors
|
| import matplotlib.pyplot as plt
|
| import matplotlib.legend as lgd
|
| import matplotlib.markers as mks
|
| import colorsys
|
|
|
|
|
| def get_log_parsing_script():
|
| dirname = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
|
| return dirname + '/parse_log.sh'
|
|
|
| def get_log_file_suffix():
|
| return '.log'
|
|
|
| def get_chart_type_description_separator():
|
| return ' vs. '
|
|
|
| def is_x_axis_field(field):
|
| x_axis_fields = ['Iters', 'Seconds']
|
| return field in x_axis_fields
|
|
|
| def create_field_index():
|
| train_key = 'Train'
|
| test_key = 'Test'
|
| field_index = {train_key:{'Iters':0, 'Seconds':1, train_key + ' loss':2,
|
| train_key + ' learning rate':3},
|
| test_key:{'Iters':0, 'Seconds':1, test_key + ' accuracy':2,
|
| test_key + ' loss':3}}
|
| fields = set()
|
| for data_file_type in field_index.keys():
|
| fields = fields.union(set(field_index[data_file_type].keys()))
|
| fields = list(fields)
|
| fields.sort()
|
| return field_index, fields
|
|
|
| def get_supported_chart_types():
|
| field_index, fields = create_field_index()
|
| num_fields = len(fields)
|
| supported_chart_types = []
|
| for i in xrange(num_fields):
|
| if not is_x_axis_field(fields[i]):
|
| for j in xrange(num_fields):
|
| if i != j and is_x_axis_field(fields[j]):
|
| supported_chart_types.append('%s%s%s' % (
|
| fields[i], get_chart_type_description_separator(),
|
| fields[j]))
|
| return supported_chart_types
|
|
|
| def get_chart_type_description(chart_type):
|
| supported_chart_types = get_supported_chart_types()
|
| chart_type_description = supported_chart_types[chart_type]
|
| return chart_type_description
|
|
|
| def get_data_file_type(chart_type):
|
| description = get_chart_type_description(chart_type)
|
| data_file_type = description.split()[0]
|
| return data_file_type
|
|
|
| def get_data_file(chart_type, path_to_log):
|
| return os.path.basename(path_to_log) + '.' + get_data_file_type(chart_type).lower()
|
|
|
| def get_field_descriptions(chart_type):
|
| description = get_chart_type_description(chart_type).split(
|
| get_chart_type_description_separator())
|
| y_axis_field = description[0]
|
| x_axis_field = description[1]
|
| return x_axis_field, y_axis_field
|
|
|
| def get_field_indecies(chart_type,x_axis_field, y_axis_field):
|
| data_file_type = get_data_file_type(chart_type)
|
| fields = create_field_index()[0][data_file_type]
|
| return fields[x_axis_field], fields[y_axis_field]
|
|
|
| def load_data(data_file, field_idx0, field_idx1):
|
| data = [[], []]
|
| with open(data_file, 'r') as f:
|
| for line in f:
|
| line = line.strip()
|
| if line[0] != '#':
|
| fields = line.split()
|
| data[0].append(float(fields[field_idx0].strip()))
|
| data[1].append(float(fields[field_idx1].strip()))
|
| return data
|
|
|
| def random_marker():
|
| markers = mks.MarkerStyle.markers
|
| num = len(markers.values())
|
| idx = random.randint(0, num - 1)
|
| return markers.values()[idx]
|
|
|
| def get_data_label(path_to_log):
|
| label = path_to_log[path_to_log.rfind('/')+1 : path_to_log.rfind(
|
| get_log_file_suffix())]
|
| return label
|
|
|
| def get_legend_loc(chart_type):
|
| x_axis, y_axis = get_field_descriptions(chart_type)
|
| loc = 'lower right'
|
| if y_axis.find('accuracy') != -1:
|
| pass
|
| if y_axis.find('loss') != -1 or y_axis.find('learning rate') != -1:
|
| loc = 'upper right'
|
| return loc
|
|
|
| def plot_chart(chart_type, path_to_png, path_to_log_list, ylim = None):
|
| N = len(path_to_log_list)
|
| HSV_tuples = [(x*1.0/N, 0.5, 1) for x in range(N)]
|
| RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples)
|
|
|
| for ind, path_to_log in enumerate(path_to_log_list):
|
| os.system('%s %s' % (get_log_parsing_script(), path_to_log))
|
| data_file = get_data_file(chart_type, path_to_log)
|
| x_axis_field, y_axis_field = get_field_descriptions(chart_type)
|
| x, y = get_field_indecies(chart_type, x_axis_field, y_axis_field)
|
| data = load_data(data_file, x, y)
|
|
|
| label = get_data_label(path_to_log)
|
| linewidth = 2
|
|
|
|
|
| use_marker = True
|
| if not use_marker:
|
| plt.plot(data[0], data[1], label = label, color = color,
|
| linewidth = linewidth)
|
| else:
|
| ok = False
|
|
|
| while not ok:
|
| try:
|
| marker = random_marker()
|
| plt.plot(data[0], data[1], label = label, color = RGB_tuples[ind],
|
| marker = marker, linewidth = linewidth)
|
| ok = True
|
| except:
|
| pass
|
| legend_loc = get_legend_loc(chart_type)
|
|
|
| plt.legend(path_to_log_list, loc='upper center', bbox_to_anchor=(.5, -0.1))
|
| plt.title(get_chart_type_description(chart_type))
|
| plt.xlabel(x_axis_field)
|
| plt.ylabel(y_axis_field)
|
| if ylim:
|
| plt.ylim(ylim)
|
|
|
| plt.show()
|
|
|
| def print_help():
|
| print """This script mainly serves as the basis of your customizations.
|
| Customization is a must.
|
| You can copy, paste, edit them in whatever way you want.
|
| Be warned that the fields in the training log may change in the future.
|
| You had better check the data files and change the mapping from field name to
|
| field index in create_field_index before designing your own plots.
|
| Usage:
|
| ./plot_log.sh chart_type[0-%s] /where/to/save.png /path/to/first.log ...
|
| Notes:
|
| 1. Supporting multiple logs.
|
| 2. Log file name must end with the lower-cased "%s".
|
| Supported chart types:""" % (len(get_supported_chart_types()) - 1,
|
| get_log_file_suffix())
|
| supported_chart_types = get_supported_chart_types()
|
| num = len(supported_chart_types)
|
| for i in xrange(num):
|
| print ' %d: %s' % (i, supported_chart_types[i])
|
| exit
|
|
|
| def is_valid_chart_type(chart_type):
|
| return chart_type >= 0 and chart_type < len(get_supported_chart_types())
|
|
|
| if __name__ == '__main__':
|
| if len(sys.argv) < 4:
|
| print_help()
|
| else:
|
| chart_type = int(sys.argv[1])
|
| if not is_valid_chart_type(chart_type):
|
| print_help()
|
| path_to_png = sys.argv[2]
|
| if not path_to_png.endswith('.png'):
|
| print 'Path must ends with png' % path_to_png
|
| exit
|
| path_to_logs = sys.argv[3:]
|
| for path_to_log in path_to_logs:
|
| if not os.path.exists(path_to_log):
|
| print 'Path does not exist: %s' % path_to_log
|
| exit
|
| if not path_to_log.endswith(get_log_file_suffix()):
|
| print_help()
|
|
|
| plot_chart(chart_type, path_to_png, path_to_logs)
|
|
|
