def tab_printer(args):
args = vars(args)
keys = sorted(args.keys())
t = Texttable()
t.set_precision(10)
t.add_rows([["Parameter", "Value"]] + [[k.replace("_"," ").capitalize(),args[k]] for k in keys])
print(t.draw())
def __str__(self):
table = Texttable()
table.set_precision(20)
table.add_row(self._weights)
auxRow = []
outputRow = []
if self._noOfInputs % 2 == 1:
for i in range(floor(self._noOfInputs / 2)):
auxRow.append('\\')
outputRow.append(' ')
auxRow.append('|')
outputRow.append(self._output)
for i in range(floor(self._noOfInputs / 2)):
auxRow.append('/')
outputRow.append(' ')
else:
for i in range(floor(self._noOfInputs / 2)):
auxRow.append('\\')
outputRow.append(' ')
outputRow.append(self._output)
for i in range(floor(self._noOfInputs / 2)):
auxRow.append('/')
outputRow.append(' ')
auxRow2 = ['|' for i in range(self._noOfInputs)]
table.add_row(auxRow2)
table.add_row(auxRow)
table.add_row(outputRow)
return table.draw()
def print_price_data(data):
# Current BTC Price
# --------------------
print '\n%s' % colorize('CaVirtex Market\n---------------', colors.CYAN)
status_color = colors.GREEN if data['net'] > 0 else colors.RED
print '\n%s' % colorize('Price', colors.BLUE)
print '\n%s' % colorize('$%.2f CAD/BTC' % data['current_price'], status_color)
# Latest Trades
# ----------------
print '\n%s\n' % colorize('Latest Trades', colors.BLUE)
trades_table = Texttable()
trades_table.set_deco(Texttable.HEADER)
trades_table.set_precision(2)
trades_table.set_cols_dtype(['f', 'f', 'f', 't'])
trades_table.add_rows(data['latest_trades'])
print trades_table.draw()
# Investment Returns
# ---------------------
print '\n%s' % colorize('Your Investment', colors.BLUE)
print '\nNet: %s' % colorize('$%.2f CAD' % data['net'], status_color)
print '\nVOI: %s' % colorize('$%.2f CAD' % data['voi'], status_color)
print '\nROI: %s' % colorize('%.2f%%' % data['roi'], status_color)
def print_table(final_results, sizes, scale):
traffic_unit = scale["traffic_unit"]
pkt_unit = scale["pkt_unit"]
table = Texttable(max_width=0)
table.set_chars(['', '|', '', ''])
table.set_precision(2)
table.set_deco(Texttable.VLINES)
rows = [[
"| Packet size", "Line Utilization (%)",
"Total L1 {}".format(traffic_unit), "Total L2 {}".format(traffic_unit),
"CPU Util (%)", "Total {}".format(pkt_unit),
"BW per core {} <1>".format(traffic_unit),
"{} per core <2>".format(pkt_unit), "Multiplier"
]]
for size in sizes:
pkt_result = final_results[size]
pkt_str = "| " + str(pkt_result["Packet size"])
row = [
pkt_str, pkt_result["Line Utilization (%)"],
pkt_result["Total L1 {}".format(traffic_unit)],
pkt_result["Total L2 {}".format(traffic_unit)],
pkt_result["CPU Util (%)"],
pkt_result["Total {}".format(pkt_unit)],
pkt_result["BW per core {}".format(traffic_unit)],
pkt_result["{} per core".format(pkt_unit)],
pkt_result["Multiplier"]
]
rows.append(row)
table.add_rows(rows)
print(table.draw())
def _dataframe_to_texttable(df, align=None):
"""Convert data frame to texttable. Sets column widths to the
widest entry in each column."""
ttab = Texttable()
ttab.set_precision(1)
h = [[x for x in df]]
h.extend([x for x in df.to_records(index=False)])
if align:
colWidths = [max(len(x), len(".. class:: {}".format(y))) for x,y in izip(df.columns, align)]
else:
colWidths = [len(x) for x in df.columns]
for row in h:
for i in range(0, len(row)):
if type(row[i]) == str:
colWidths[i] = max([len(str(x)) for x in row[i].split("\n")] + [colWidths[i]])
colWidths[i] = max(len(str(row[i])), colWidths[i])
table_data = []
if align:
for row in h:
table_row = []
i = 0
for col, aln in izip(row, align):
table_row.append(".. class:: {}".format(aln) + " " * colWidths[i] + "{}".format(col))
i = i + 1
table_data.append(table_row)
else:
table_data = h
ttab.add_rows(table_data)
ttab.set_cols_width(colWidths)
# Note: this does not affect the final pdf output
ttab.set_cols_align(["r"] * len(colWidths))
return ttab
def __init__(self):
'''Shows a table Integrate Numerically the Student’s t-distribution
'probability density 'function ( t-distribution pdf) using Simpson’s'
'rule. The total' 'probability' is the area of the function (the integral)'
'from -t to t. The total probability is p'
'''
calculate = Calculate('history.txt')
values = calculate.get_total_probability_p()
table = Texttable()
table.set_cols_align(["l", "c", "c"])
table.set_cols_valign(["m", "m", "m"])
table.set_cols_dtype(['t', 'i', 'f'])
table.set_precision(5)
label = [
color(bcolors.GREEN,"Test"),'',
color(bcolors.GREEN,"Expected Values")]
head = [
color(bcolors.GREEN,"t"),
color(bcolors.GREEN,"dof"),
color(bcolors.GREEN,"p")]
rows = []
rows.append(label)
rows.append(head)
[rows.append(element) for element in values]
table.add_rows(rows)
print(table.draw() + "\n")
def _write_output_table(writer, table, write_table_name=False):
tt = Texttable()
tt.set_deco(Texttable.HEADER)
tt.set_precision(10)
if table.columns_type:
tt.set_cols_dtype(table.columns_type)
tt.header(table.columns_name)
ids = table.columns_id
for raw_row in table.rows:
row = [raw_row[i] for i in ids]
tt.add_row(row)
drawn_table = tt.draw()
writer.write('\n')
if write_table_name:
line_length = len(drawn_table.split('\n')[0])
spacing = (line_length - len(table.name)) // 2
writer.write(' ' * spacing)
writer.write(table.name)
writer.write('\n')
writer.write(tt.draw())
def test_file(name) -> None:
print(f">>>>>>>>>> {name} <<<<<<<<<<")
print()
t = Texttable(max_width=100)
t.set_deco(Texttable.BORDER | Texttable.HEADER | Texttable.VLINES)
t.set_precision(3)
t.header(["Encoder", "Size", "Diff", "Diff%"])
t.set_cols_align(["l", "r", "r", "r"])
rows = []
for encoder, encode in ENCODERS.items():
nintendo_len = len(TEST_FILE_DATA[name])
encoder_len = len(encode(TEST_FILE_DATA_UNCOMP[name]))
diff = encoder_len - nintendo_len
ratio = encoder_len / nintendo_len
percentage = (ratio - 1) * 100.0
rows.append([encoder, encoder_len, diff, percentage])
# Sort by diff.
rows.sort(key=lambda row: row[2])
t.add_rows(rows, header=False)
print(t.draw())
print()
def __init__(self):
'''Show results
'''
calculate = Requeriments()
values = calculate.calculate_all_values()
labels = ["r","r^2","Significance","B0","B1","P","Range","UPI(70%)","LIP(70%)"]
table = Texttable()
table.set_cols_align(["c", "c","c"])
table.set_cols_valign(["m","m","m"])
table.set_cols_dtype(['t','t','f'])
table.set_cols_width([15 for i in range(3)])
table.set_precision(9)
label = [
color(bcolors.GREEN,"Test"),
color(bcolors.GREEN,"Parameter"),
color(bcolors.GREEN,"Expected Value")]
rows = []
rows.append(label)
number = 0
for item in values:
number += 1
text = 'Test%d' % number
for pos in range(9):
rows.append([text, labels[pos], item[pos]])
table.add_rows(rows)
print(table.draw() + "\n")
def cmd_list():
imap = connectIMAP(CONFIG.accounts[0])
# open readonly b/c otherwise messages will be marked as read '\\Seen'
imap.select_folder(ARGS.mailbox, readonly=True)
imap = connectIMAP(CONFIG.accounts[0])
# open readonly b/c otherwise messages will be marked as read '\\Seen'
imap.select_folder(ARGS.mailbox, readonly=True)
try:
msgs = iterMessages(imap)
msgs = sorted(msgs, key=lambda m: m.date)
ids = [m.id for m in msgs]
table = Texttable()
table.set_deco(Texttable.HEADER | Texttable.HLINES)
table.header(
['Date', 'ID', 'Score', 'From', 'Subject', 'Flags', 'age (mins)'])
table.set_cols_width([20, 10, 6, 30, 30, 12, 10])
table.set_precision(1)
for m in msgs:
if m.score is not None and m.score < ARGS.score:
if ARGS.verbose:
verbose(
'skipping message id=%d date=%s score=%s below threshold of %s'
% (m.id, m.date, m.scoreStr(), str(ARGS.score)))
continue
table.add_row([
m.date, m.id,
m.scoreStr(),
m.headers.get('From', None),
m.headers.get('Subject', None), m.flags,
m.ageMinutes()
])
info(table.draw())
finally:
imap.logout()
def test_chaining():
table = Texttable()
table.reset()
table.set_max_width(50)
table.set_chars(list('-|+='))
table.set_deco(Texttable.BORDER)
table.set_header_align(list('lll'))
table.set_cols_align(list('lll'))
table.set_cols_valign(list('mmm'))
table.set_cols_dtype(list('ttt'))
table.set_cols_width([3, 3, 3])
table.set_precision(3)
table.header(list('abc'))
table.add_row(list('def'))
table.add_rows([list('ghi')], False)
s1 = table.draw()
s2 = (Texttable()
.reset()
.set_max_width(50)
.set_chars(list('-|+='))
.set_deco(Texttable.BORDER)
.set_header_align(list('lll'))
.set_cols_align(list('lll'))
.set_cols_valign(list('mmm'))
.set_cols_dtype(list('ttt'))
.set_cols_width([3, 3, 3])
.set_precision(3)
.header(list('abc'))
.add_row(list('def'))
.add_rows([list('ghi')], False)
.draw())
assert s1 == s2
def __str__(self):
table = Texttable(max_width=0)
table.set_deco(Texttable.HEADER)
table.set_precision(1)
header_row = ['Place', 'Name', 'Games', 'Points']
for v in self.tiebreaks.values():
header_row.append(v[0])
table.header(header_row)
col_alignments = []
cols = len(self.table[0]) + 1
for c in range(cols):
col_alignments.append('c')
table.set_cols_align(col_alignments)
col_dtypes = ['i', 't', 'i', 't']
for tiebreak in self.tiebreaks.values():
col_dtypes.append(tiebreak[2])
table.set_cols_dtype(col_dtypes)
for rank, player in enumerate(self.table):
cur_row = [rank + 1]
for entry in player.values():
cur_row.append(entry)
table.add_row(cur_row)
return table.draw()
def createTable(headers, rows):
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_precision(2)
table.set_max_width(32)
table.header(headers)
for row in rows:
table.add_row(row)
return table
def create_result_table(scores):
t = Texttable()
t.set_precision(6)
t.add_row(['']+scores_names)
for task, score in scores.items():
if len(score)<len(scores_names):
score += ['N/A'] * (len(scores_names)-len(score))
t.add_row([task]+score)
return t.draw()
def print_rating_questions_averages(self):
questions = self.survey.get_all_questions()
output_table = Texttable()
output_table.set_precision(2)
output_table.add_row(['Survey Question', 'Average Response'])
for question in questions:
if question.type == SurveyQuestionType.RATING.value:
output_table.add_row(
[question.text,
question.get_average_response()])
self.out.write(output_table.draw())
self.out.write('\n')
def render_expense(self, expense):
"""Displays a single Expense in a table"""
table = Texttable()
table.set_cols_align(["l", "l"])
table.set_precision(2)
table.set_deco(Texttable.HLINES)
table.add_row(["Id:", expense.get_expense_id()])
table.add_row(["Name:", expense.get_name()])
table.add_row(["Cost:", expense.get_cost()])
table.add_row(["Deadline:", expense.get_deadline_string()])
table.add_row(["Done:", expense.is_done_string()])
print(table.draw())
def draw_processes_table(processes):
t = Texttable()
t.set_precision(4)
t.add_rows([
list(Process._fields), *[list(x) for x in processes],
[
'Avg.', '', '', '',
sum(p.T for p in processes) / len(processes),
sum(p.E for p in processes) / len(processes),
sum(p.I for p in processes) / len(processes)
]
])
return t.draw()
def render_expenses(self, expenses):
"""Displays a list of Expenses in a table"""
table = Texttable()
table.set_cols_align(["r", "l", "r", "r"])
table.header(["#", "Name", "Cost", "Deadline"])
table.set_cols_dtype(["i", "t", "f", "t"])
table.set_precision(2)
table.set_deco(Texttable.HEADER | Texttable.HLINES)
for index, expense in enumerate(expenses):
table.add_row([index + 1, expense.get_name(), expense.get_cost(),
expense.get_deadline_string()])
print(table.draw())
def PrintRow(self, size, row, right):
table = Texttable()
table.set_precision(5)
title = [[]]
arr = [10 for i in range(size)]
table.set_cols_width(arr)
left = right
for i in range(size):
title[0].append(f'R({left},{right})')
left += 1
title.append(list(row))
table.add_rows(title)
print(table.draw())
def tab_printer(args):
"""
Function to print the logs in a nice tabular format.
:param args: Parameters used for the model.
"""
args = vars(args)
keys = args.keys()
# keys = sorted(args.keys())
t = Texttable()
t.set_precision(5)
t.set_deco(Texttable.VLINES)
t.set_cols_align(["r", "l"])
# t.header(("Parameter", "Value"))
t.add_rows([[k.replace("_", " ").capitalize(), args[k]] for k in keys],
header=False)
print(t.draw())
def arguments_to_tables(args):
"""
util function to print the logs in table format
:param args: parameters
:return:
"""
args = vars(args)
keys = sorted(args.keys())
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_precision(width=10)
table.set_cols_dtype(['t', 't'])
table.set_cols_align(['l', 'l'])
table.add_rows([["Parameter", "Value"]])
for k in keys:
table.add_row([k, args[k]])
return table.draw()
def report_evaluation(y_hat, y, yhat_raw=None):
"""
Calculates evaluation metrics, logs them and saves them to a results file.
:param y_hat: binary predictions matrix
:param y: binary ground truth matrix
:param yhat_raw: prediction scores matrix (floats)
:return: None
"""
eval_metrics = evaluation.all_metrics(y_hat, y, yhat_raw=yhat_raw)
eval_keys = sorted(eval_metrics.keys())
ordered_eval_metrics = OrderedDict()
for metric in eval_keys:
ordered_eval_metrics[metric] = eval_metrics[metric]
logging.info(str(ordered_eval_metrics))
config_dict = OrderedDict()
classes = inspect.getmembers(constants, inspect.isclass)
for class_ in classes:
for vars_, val in vars(class_[1]).items():
if "__" not in vars_ and \
class_[0] != "Keys" and \
class_[0] != "Tables":
config_dict[class_[0] + "_" + vars_] = val
t = Texttable()
t.set_precision(5)
t.add_rows([["Configuration", "Value"]] + list(config_dict.items()))
t2 = Texttable()
t2.set_precision(5)
t2.add_rows([["Evaluation Metric", "Value"]] +
list(ordered_eval_metrics.items()))
out = t.draw() + "\n" + t2.draw()
ts_now = 'results-{:%Y-%m-%d--%H:%M:%S}.txt'.format(
datetime.datetime.now())
res_path = os.path.join(constants.LOGS_DIR, ts_now)
out_file = open(res_path, "w+")
out_file.write(out)
out_file.close()
def print_node_probabilities(node_probabilities,
data_manager,
confidence,
detailed=False):
color_nodes = dict()
color_nodes['green'] = set()
color_nodes['yellow'] = set()
color_nodes['red'] = set()
lt = (1 - confidence) * 0.5
rt = 1 - lt
confidence_interval = (lt, rt)
for i, p in enumerate(node_probabilities):
if i > 0:
if p >= confidence_interval[1]:
color_nodes['red'].add((i, p))
elif p <= confidence_interval[0]:
color_nodes['green'].add((i, p))
else:
color_nodes['yellow'].add((i, p))
n_green = len(color_nodes['green'])
n_yellow = len(color_nodes['yellow'])
n_red = len(color_nodes['red'])
print("\nNODE PROBABILITIES\n")
print("Number of red nodes {}".format(n_red))
print("Number of yellow nodes {}".format(n_yellow))
print("Number of green nodes {}".format(n_green))
node_qual = {'red': 'LY', 'green': 'LN', 'yellow': 'UN'}
if detailed:
my_table = Texttable()
my_table.set_precision(6)
header = ['Node', 'Probability', 'Classification']
list_rows = list()
list_rows.append(header)
for key, val in color_nodes.iteritems():
for nodeid, prob in val:
name = data_manager.idx_to_node_name[nodeid]
list_rows.append([name, prob, node_qual[key]])
my_table.add_rows(list_rows)
print my_table.draw()
def eval_dir(path, markdown=False, dprefix=False,
evalmethod=None, numlabel=False):
""" Evaluate the results in the dir by MRR
Argument:
dirname -- the path to the diretory containing evaluation results
"""
if evalmethod is None:
ef = mrr
else:
ef = globals()[evalmethod]
files = sorted(os.listdir(path))
names = sorted(set([n.rsplit('.', 1)[0][3:] for n in files
if n.endswith('.res')]),
key=lambda item: (len(item), item))
if dprefix:
prefices = sorted(set([n[:2] for n in files]))
else:
prefices = PREFICES
table = Texttable(max_width=0)
if markdown:
table.set_asmarkdown()
else:
table.set_deco(0)
table.set_cols_dtype(['t'] + ['f'] * len(prefices))
table.set_cols_align(['l'] + ['r'] * len(prefices))
table.set_precision(4)
table.add_rows([['', ] + prefices])
for n in names:
scores = list()
for prefix in prefices:
try:
eva = NP.array([v for v in iterrank(
os.path.join(path, '%s_%s.res' % (prefix, n)))],
dtype=NP.float64)
scores.append(ef(eva))
except IOError:
scores.append('N/A')
if numlabel:
n = ' '.join([m.group() for m in NUMBER.finditer(n)])
table.add_row([n, ] + scores)
print table.draw()
def cmd_stats():
msgs = iterMessages(CONFIG.accounts[0])
months = {}
for m in msgs:
month = months.get(m.month(), [])
month.append(m)
months[m.month()] = month
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_cols_dtype(['t', 'i', 'f', 'f', 'f', 'f'])
table.set_cols_align(['l', 'r', 'r', 'r', 'r', 'r'])
table.set_precision(1)
table.add_row(['month', 'count', 'min', 'max', 'median', 'mean'])
for month in sorted(months.keys()):
msgs = months[month]
count, minval, maxval, med, avg = stats(msgs)
table.add_row([month, count, minval, maxval, med, avg])
info('monthly spam score stats on %s\n%s' % (ARGS.mailbox, table.draw()))
def print_config(filename, default=None, mode="json"):
if mode == "json":
print("reading config file:", filename)
with open(filename, "r") as f:
config = json.load(f)
table = Texttable()
table.set_precision(6)
table.set_deco(Texttable.BORDER | Texttable.VLINES | Texttable.HEADER)
# for general infomation
table.set_cols_dtype(['a', 'a'])
table.set_cols_align(['c', 'c'])
table.add_rows([["key", "value"]])
for name_idx, name in enumerate(config.keys()):
if name == "data info":
continue
table.add_row([name, config[name]])
print(table.draw())
# for data info
if "data info" in config.keys():
data_info = config["data info"]
table = Texttable()
table.set_deco(Texttable.BORDER | Texttable.VLINES
| Texttable.HEADER)
table.set_cols_dtype(['t', 't', 'a', "a", "a", "a"])
table.set_cols_align(['c', 'c', 'c', 'c', 'c', 'c'])
table.add_rows(
[["name", "format", "number", "dim", "active", "default"]])
for item in data_info:
if default is not None:
item["default"] = (default and item["default"])
table.add_row([
item["name"], item["format"], item["num"], item["dim"],
item["active"], item["default"]
])
print(table.draw())
return config, data_info
else:
return config
return -1
def print_scenarios_probability(scenarios_container,
data_manager,
limit=20,
sorted=True,
confidence=1.0):
my_table = Texttable()
my_table.set_precision(6)
#print "\nNUMBER OF SCENARIOS", len(scenarios_container)
probabilities = [s.probability for s in scenarios_container]
if sorted:
scenario_ids = get_sorted_ids(scenarios_container)
else:
scenario_ids = range(len(scenarios_container))
header = [
'HID', 'SOURCE', 'START (min)', 'STOP (min)', 'PROBABILITY', 'MATCHES'
]
list_rows = list()
list_rows.append(header)
accum = 0.0
for j, scenario_id in enumerate(scenario_ids):
if j < limit:
scenario = scenarios_container[scenario_id]
source = data_manager.idx_to_node_name[scenario.injection.source]
hid = scenario.hid
n_matches = scenario.matches
n_unmatches = scenario.miss_matches
probability = scenario.probability
inj_start = int(scenario._injection.start_sec / 60)
inj_end = int(scenario._injection.end_sec / 60)
list_rows.append(
[hid, source, inj_start, inj_end, probability, n_matches])
accum += probability
if sorted and accum > confidence:
break
else:
break
my_table.add_rows(list_rows)
print my_table.draw()
def print_evaluation(topk_list, recalls=None, ndcgs=None):
n_cols = len(topk_list)
cols_align = ["c"] + ["r"] * n_cols
cols_name = ["dataset"]
for k in topk_list:
cols_name.append("@{}".format(k))
if len(recalls) < 2 * n_cols:
recalls + [0] * (2 * n_cols - len(recalls))
if len(ndcgs) < 2 * n_cols:
ndcgs + [0] * (2 * n_cols - len(ndcgs))
table = Texttable(0)
table.set_precision(6)
table.set_deco(Texttable.HEADER | Texttable.BORDER)
table.set_cols_align(cols_align)
table.add_rows([
cols_name,
["val_recall"] + recalls[:n_cols],
["test_recall"] + recalls[n_cols:],
["val_ncdg"] + ndcgs[:n_cols], # update at 2018/4/15/14:49
["test_ncdg"] + ndcgs[n_cols:]
])
print(table.draw())
return table.draw()
def __init__(self):
'''Shows a table in console with the output of relatives sizes ranges
'''
calculate = Calculate()
values = calculate.get_relative_size_ranges()
table = Texttable()
table.set_cols_align(["l", "l", "l","l", "l", "l"])
table.set_cols_valign(["m", "m", "m","m", "m", "m"])
table.set_cols_dtype(['t', 'f', 'f', 'f', 'f','f'])
table.set_precision(4)
head = ['',
color(bcolors.GREEN,"VS"),
color(bcolors.GREEN,"S"),
color(bcolors.GREEN,"M"),
color(bcolors.GREEN,"L"),
color(bcolors.GREEN,"VL")
]
rows = []
rows.append(head)
[rows.append(element) for element in values]
table.add_rows(rows)
print(table.draw() + "\n")
by_status['none'].append(c)
offset += per_page
total_monthly_revenue = []
for type, customers in by_status.iteritems():
print '*' * 80
print 'Subscriptions: ', type, ' - ', len(customers)
print '*' * 80
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_cols_align(['l', 'r', 'l', 'r'])
table.header(['Customer', 'Plan', 'Coupon', 'Monthly'])
table.set_precision(2)
for c in customers:
row = []
row.append(c.description or c.email)
monthly = 0
if c.subscription:
amount = '$%d' % (c.subscription.quantity *
c.subscription.plan.amount / 100)
if c.subscription.plan.interval == 'month':
monthly = c.subscription.quantity * c.subscription.plan.amount
elif c.subscription.plan.interval == 'year':
amount += ' ANNUAL'
else:
amount += ' %s!!!' % c.subscription.plan.interval
def main():
parser = buildArgsParser()
args = parser.parse_args()
sort_by = args.sort
names = []
results_files = []
hyperparams_files = []
status_files = []
for f in args.results:
exp_folder = f
if os.path.isfile(f):
exp_folder = os.path.dirname(f)
result_file = pjoin(exp_folder, "result.json")
hyperparams_file = pjoin(exp_folder, "hyperparams.json")
status_file = pjoin(exp_folder, "status.json")
if not os.path.isfile(result_file):
print 'Skip: {0} is not a file!'.format(result_file)
continue
if not os.path.isfile(hyperparams_file):
print 'Skip: {0} is not a file!'.format(hyperparams_file)
continue
if not os.path.isfile(status_file):
print 'Skip: {0} is not a file!'.format(status_file)
continue
name = os.path.basename(exp_folder)
if 'hyperparams.json' in os.listdir(os.path.abspath(pjoin(exp_folder, os.path.pardir))):
name = os.path.basename(os.path.abspath(pjoin(exp_folder, os.path.pardir)))
names.append(name)
results_files.append(result_file)
hyperparams_files.append(hyperparams_file)
status_files.append(status_file)
if len([no for no in sort_by if no == 0]) > 0:
parser.error('Column ID are starting at 1!')
# Retrieve headers from hyperparams
headers_hyperparams = set()
headers_results = set()
headers_status = set()
for hyperparams_file, status_file, results_file in zip(hyperparams_files, status_files, results_files):
hyperparams = load_dict_from_json_file(hyperparams_file)
results = load_dict_from_json_file(results_file)
status = load_dict_from_json_file(status_file)
headers_hyperparams |= set(hyperparams.keys())
headers_results |= set(results.keys())
headers_status |= set(status.keys())
headers_hyperparams = sorted(list(headers_hyperparams))
headers_status = sorted(list(headers_status))
# TODO: when generating result.json split 'trainset' scores in two key:
# 'trainset' and 'trainset_std' (same goes for validset and testset).
headers_results |= set(["trainset_std", "validset_std", "testset_std"])
headers_results = sorted(list(headers_results))
headers = headers_hyperparams + headers_status + ["name"] + headers_results
# Build results table
table = Texttable(max_width=0)
table.set_deco(Texttable.HEADER)
table.set_precision(8)
table.set_cols_dtype(['a'] * len(headers))
table.set_cols_align(['c'] * len(headers))
# Headers
table.header([str(i) + "\n" + h for i, h in enumerate(headers, start=1)])
if args.only_header:
print table.draw()
return
# Results
for name, hyperparams_file, status_file, results_file in zip(names, hyperparams_files, status_files, results_files):
hyperparams = load_dict_from_json_file(hyperparams_file)
results = load_dict_from_json_file(results_file)
status = load_dict_from_json_file(status_file)
# Build results table row (hyperparams columns)
row = []
for h in headers_hyperparams:
value = hyperparams.get(h, '')
row.append(value)
for h in headers_status:
value = status.get(h, '')
row.append(value)
row.append(name)
for h in headers_results:
if h in ["trainset", "validset", "testset"]:
value = results.get(h, '')[0]
elif h in ["trainset_std", "validset_std", "testset_std"]:
value = results.get(h[:-4], '')[1]
else:
value = results.get(h, '')
row.append(value)
table.add_row(row)
# Sort
for col in reversed(sort_by):
table._rows = sorted(table._rows, key=sort_nicely(abs(col) - 1), reverse=col < 0)
if args.out is not None:
import csv
results = []
results.append(headers)
results.extend(table._rows)
with open(args.out, 'wb') as csvfile:
w = csv.writer(csvfile)
w.writerows(results)
else:
print table.draw()
counterFF86 = counterFF86 + end - start
mFF86 = float(counterFF86)/max_times
so_times.append(mFF86)
if pcap == pcapAnd:
aux = ['Android']
for i in range(0,len(so_times)):
aux = aux + [so_times[i]]
t_data.append(aux)
if pcap == pcapIph:
aux = ['iPhone']
for i in range(0,len(so_times)):
aux = aux+[so_times[i]]
t_data.append(aux)
if pcap == pcapWP:
aux = ['WindowsPhone']
for i in range(0,len(so_times)):
aux = aux+[so_times[i]]
t_data.append(aux)
####Decode the following packet
(hdr, data) = pcap.next()
except pcapy.PcapError as pcap_error:
(hdr, data) = (None, None)
t.set_precision(6)
t.add_rows(t_data)
print t.draw()
except IOError as err:
print('File error: '+str(err))
def main():
# create command-line argument parser object
parser = argparse.ArgumentParser(description="Execute the prescribed iterative methods")
# add accepted positional arguments
parser.add_argument("methods",
nargs='*', type=str, default='bisection',
choices=['bisection','halley','newton','secant','secant_swap','steffenson'],
help="Iterative methods to run")
# add accepted optional arguments
parser.add_argument("-c", "--csv",
metavar='CSVFILE', nargs=1, type=str,
default=None,
help="Output iterations to CSV file.")
parser.add_argument("-f", "--func_vals", action='store_true',
help="Show function values for the iterates of each methods")
parser.add_argument("-v", "--verbosity", action='count',
help="Increase output verbosity")
# parse arguments
args = parser.parse_args()
# method parameters
f = lambda x: x**2-20.0
fp = lambda x: 2.0*x
M = 1000
a = 3
b = 3.5
x_0 = 3.0
x_1 = 5.0
eps = 0.0001
delta = 0.0001
#f = lambda x: 0.0005*exp(x) + tan(x) - cos(x**2-2.0)
#fp = lambda x: 0.0005*exp(x) + 1.0/(cos(sqrt(x))**2) + 2.0*x*sin(x**2-2.0)
#M = 1000
#a = 3
#b = 3.5
#x_0 = 3.0
#x_1 = 5.0
#eps = 0.0001
#delta = 0.0001
#f = lambda x: (4.4*x**5 - exp(cos(x - 5.0)))/sqrt(5.0*pi*x)
#fp = lambda x: (0.126257*exp(cos(5.0-x)-0.252313*x*sin(5.0-x)*exp(cos(5.0-x))+4.9958*x**5)/(x**(3.0/2.0)))
#fpp = lambda x: 2.0
#M = 1000
#a = 0.1
#b = 5.0
#x_0 = 0.1
#x_1 = 1.0
#eps = 0.0001
#delta = 0.0001
#f = lambda x: (x*(x*(x*(x*(x+200)+275)+312)+380)+400)-1750
#M = 1000
#x_0 = 0.0
#x_1 = 1.0
#eps = 0.0001
#delta = 0.0001
# list of lists of iterates produced by the methods
iterates = [ ]
# texttable attributes
header = [ 'Iteration' ]
if 'bisection' in args.methods:
a_n, b_n = rm.bisection_method(M,eps,delta,f,a,b)
if args.verbosity >= 1:
print "Bisection method:"
print "\tNumber of iterations: " + str(len(a_n))
print "\ta_"+str(len(a_n)-1)+"= "+str(a_n[-1])
print "\tb_"+str(len(b_n)-1)+"= "+str(b_n[-1])
print "\tf(a_"+str(len(a_n)-1)+") = "+str(f(a_n[-1]))
print "\tf(b_"+str(len(a_n)-1)+") = "+str(f(b_n[-1]))
iterates.append(a_n)
iterates.append(b_n)
header.append('Bisection: a_n')
header.append('Bisection: b_n')
if args.func_vals:
# TODO: fix method to store lists of function values
pass
# iterates.append(fa_n)
# iterates.append(fb_n)
# header.append('Bisection: f(a_n)')
# header.append('Bisection: f(b_n)')
if 'newton' in args.methods:
x_n, f_n = rm.newtons_method(M,eps,delta,f,fp,x_0)
if args.verbosity >= 1:
print "\nNewton's method:"
print "\tNumber of iterations: " + str(len(x_n))
print "\tx_"+str(len(x_n)-1)+" = "+str(x_n[-1])
print "\tf(x_"+str(len(f_n)-1)+") = "+str(f_n[-1])
iterates.append(x_n)
header.append("Newton's: x_n")
if args.func_vals:
iterates.append(f_n)
header.append("Newton's: f(x_n)")
if 'halley' in args.methods:
x_n, f_n = rm.halleys_method(M,eps,delta,f,fp,fpp,x_0)
if args.verbosity >= 1:
print "\nHalley's method:"
print "\tNumber of iterations: " + str(len(x_n))
print "\tx_"+str(len(x_n)-1)+" = "+str(x_n[-1])
print "\tf(x_"+str(len(f_n)-1)+") = "+str(f_n[-1])
iterates.append(x_n)
header.append("Halley's: x_n")
if args.func_vals:
iterates.append(f_n)
header.append("Halley's: f(x_n)")
if 'steffenson' in args.methods:
x_n, f_n = rm.steffensons_method(M,eps,delta,f,x_0)
if args.verbosity >= 1:
print "\nSteffenson's method:"
print "\tNumber of iterations: " + str(len(x_n))
print "\tx_"+str(len(x_n)-1)+" = "+str(x_n[-1])
print "\tf(x_"+str(len(f_n)-1)+") = "+str(f_n[-1])
iterates.append(x_n)
header.append("Steffenson's: x_n")
if args.func_vals:
iterates.append(f_n)
header.append("Steffenson's: f(x_n)")
if 'secant' in args.methods:
x_n, f_n = rm.secant_method(M,eps,delta,f,x_0,x_1)
if args.verbosity >= 1:
print "\nSecant method:"
print "\tNumber of iterations: " + str(len(x_n))
print "\tx_"+str(len(x_n)-1)+" = "+str(x_n[-1])
print "\tf(x_"+str(len(f_n)-1)+") = "+str(f_n[-1])
iterates.append(x_n)
header.append('Secant: x_n')
if args.func_vals:
iterates.append(f_n)
header.append('Secant: f(x_n)')
if 'secant_swap' in args.methods:
x_n, f_n = rm.secant_method_swap(M,eps,delta,f,x_0,x_1)
if args.verbosity >= 1:
print "\nSecant method (swap):"
print "\tNumber of iterations: " + str(len(x_n))
print "\tx_"+str(len(x_n)-1)+" = "+str(x_n[-1])
print "\tf(x_"+str(len(f_n)-1)+") = "+str(f_n[-1])
iterates.append(x_n)
header.append('Secant swap: x_n')
if args.func_vals:
iterates.append(f_n)
header.append('Secant swap: f(x_n)')
# create a texttable and add the records
table = Texttable()
# set the table style
table.set_deco(Texttable.HEADER)
# set precision of floating point data type
table.set_precision(7)
# set column data types in table
table.set_cols_dtype(['i']+['f' for i in iterates])
# set the table column alignment
table.set_cols_align(['r']+['r' for i in iterates])
# add table column headers
table.header(header)
# add the records to the table
i = 0
for ROW in izip_longest(*iterates):
table.add_row([i]+list(ROW))
i=i+1
# draw table
print table.draw()
if args.csv != None:
# create CSV writer
with open(args.csv, 'wb') as csvfile:
writer = csv.writer(csvfile, delimiter=',',
quotechar='|', quoting=csv.QUOTE_MINIMAL)
writer.writerow(header)
for RECORD in records:
writer.writerow(RECORD)
offset += per_page
total_monthly_revenue = []
for type, customers in by_status.iteritems():
print '*' * 80
print 'Subscriptions: ', type, ' - ', len(customers)
print '*' * 80
table = Texttable()
table.set_deco(Texttable.HEADER)
table.set_cols_align(['l', 'r', 'l', 'r'])
table.header(['Customer', 'Plan', 'Coupon', 'Monthly'])
table.set_precision(2)
for c in customers:
row = []
row.append(c.description or c.email)
monthly = 0
if c.subscription:
amount = '$%d' % (c.subscription.quantity * c.subscription.plan.amount / 100)
if c.subscription.plan.interval == 'month':
monthly = c.subscription.quantity * c.subscription.plan.amount
elif c.subscription.plan.interval == 'year':
if c.subscription.status == 'active':
monthly = c.subscription.quantity * c.subscription.plan.amount / 12
amount += ' ANNUAL'
else:
names.append(name)
params = [float(i) for i in row[1:]]
matrix.append(params)
n = len(matrix)
results_matrix = [[0]*n for i in range(n)]
for j in range(n-1):
for i in range(j+1, n):
row1 = matrix[i]
row2 = matrix[j]
score = [0, 0]
for func in lpr:
score[func([row1, row2])[2]] += 1
if score[0] != score[1]:
bigger = (i, j)[score.index(max(score))]
smaller = (i, j)[score.index(min(score))]
results_matrix[smaller][bigger] = 1
table = Texttable(max_width=150)
table.set_deco(Texttable.HEADER)
table.set_precision(1)
table.add_rows([['']+names])
for i in range(n):
table.add_rows([[names[i]]+results_matrix[i]], header=False)
print table.draw()
print 'Best solutions:',
for i in range(n):
if max(zip(*results_matrix)[i]) == 0:
print names[i],
