def print_tables(vi):
print "\n"
for en in vi.ensemble:
t = PrettyTable(["Method", "Weight", "Value"])
t.float_format = ".2"
t.align["Method"] = "l"
# adjust valuation weights if necessary
weight_sum = sum([k.weight for k in vi.ensemble[en].valuation])
weight_mult = 1.0/weight_sum
for v in vi.ensemble[en].valuation:
v.weight *= weight_mult
# hack: run valuations to get inferred values for notes
map(lambda x: x.value(vi.data), vi.ensemble[en].valuation)
# get weighted valuations
vals = map(lambda x: [x.method + " (%s)" % x.notes(vi.data), x.weight, x.value(vi.data)],
vi.ensemble[en].valuation)
total = sum(map(lambda x: x[1]*x[2], vals))
map(lambda x: t.add_row(x), vals)
t.add_row(["Total", 1.0, total])
# PrettyTable voodoo to get a line above the "Total" row
t._compute_widths(t._format_rows(t._rows, t._get_options({})), t._get_options({}))
t.del_row(-1)
t.add_row(map(lambda x: "-"*x, t._widths))
t.add_row(["Total", 1.0, total])
# Print table
print "Valuation: %s" % en
print t
print "\n"
def main():
global DF, PTABLE, OPTIONS
parser = argparse.ArgumentParser()
parser.add_argument("glob")
parser.add_argument("--period", type=int)
parser.add_argument("--bb-low", type=float)
parser.add_argument("--bb-high", type=float)
parser.add_argument("--lo-zone", type=float)
parser.add_argument("--hi-zone", type=float)
parser.add_argument("--lo-sigma", type=float)
parser.add_argument("--hi-sigma", type=float)
parser.add_argument("--protect-loss", type=bool)
parser.add_argument("--method", default="dual_annealing")
parser.add_argument("--finish", default=None)
args = parser.parse_args()
DF = pd.DataFrame(columns=["time", "mark", "ask", "bid"])
for csvfile in glob.glob(args.glob):
csvdf = pd.read_csv(csvfile, index_col=0)
csvdf["time"] = csvdf.apply(timefunc, axis=1)
csvdf["mark"] = pd.to_numeric(csvdf["mark"])
csvdf["ask"] = pd.to_numeric(csvdf["ask"])
csvdf["bid"] = pd.to_numeric(csvdf["bid"])
if DF.shape[0] > 0:
prev_time = DF.iloc[DF.shape[0] - 1]["time"]
prev_mark = DF.iloc[DF.shape[0] - 1]["mark"]
dt = csvdf.iloc[0]["time"] - prev_time
scale = csvdf.iloc[0]["mark"] - prev_mark
csvdf["time"] = csvdf["time"] - dt
csvdf["mark"] = csvdf["mark"] - scale
csvdf["ask"] = csvdf["ask"] - scale
csvdf["bid"] = csvdf["bid"] - scale
DF = DF.append(csvdf, ignore_index=True)
bounds_dict = {
"period": (12, 48 * 3600 / 5),
"bb_low": (0.25, 4),
"bb_high": (0.25, 4),
"lo_zone": (-0.1, 0.5),
"hi_zone": (0.5, 1.1),
"lo_sigma": (0, 4),
"hi_sigma": (0, 4),
"protect_loss": (0, 1),
}
abs_dict = {
"period": 1,
"bb_low": 0.1,
"bb_high": 0.1,
"lo_zone": 0.01,
"hi_zone": 0.01,
"lo_sigma": 0.1,
"hi_sigma": 0.1,
"protect_loss": 1,
}
PTABLE = PrettyTable([
"Iteration",
"Time",
"Period",
"BB Low",
"BB High",
"Low Zone",
"High Zone",
"Low Sigma",
"High Sigma",
"Protect",
"Return",
])
PTABLE.float_format = ".4"
bounds = []
bounds.append((0, 100))
bounds.append((
f"{datetime(2021, 1, 1, 0, 0, 0):%X}",
f"{datetime(2021, 1, 1, 23, 59, 59):%X}",
))
bounds.append([int(v) for v in bounds_dict["period"]])
bounds.append([float(v) for v in bounds_dict["bb_low"]])
bounds.append([float(v) for v in bounds_dict["bb_high"]])
bounds.append([float(v) for v in bounds_dict["lo_zone"]])
bounds.append([float(v) for v in bounds_dict["hi_zone"]])
bounds.append([float(v) for v in bounds_dict["lo_sigma"]])
bounds.append([float(v) for v in bounds_dict["hi_sigma"]])
bounds.append((False, True))
bounds.append((-99.0, 99.0))
for i in product([0, 1], repeat=len(bounds)):
PTABLE.add_row([bounds[j][i[j]] for j in range(len(bounds))])
OPTIONS = PTABLE._get_options({})
frows = PTABLE._format_rows(PTABLE._get_rows(OPTIONS), OPTIONS)
PTABLE._compute_widths(frows, OPTIONS)
PTABLE._hrule = PTABLE._stringify_hrule(OPTIONS)
print(PTABLE._stringify_header(OPTIONS))
fixed = []
bounds = []
abs_diff = []
for arg in [
"period",
"bb_low",
"bb_high",
"lo_zone",
"hi_zone",
"lo_sigma",
"hi_sigma",
"protect_loss",
]:
if getattr(args, arg) is not None:
fixed.append(getattr(args, arg))
else:
fixed.append(None)
bounds.append(bounds_dict[arg])
abs_diff.append(abs_dict[arg])
res = None
if args.method == "brute":
x0, fval, grid, Jout = optimize.brute(
func=run,
args=tuple(fixed),
ranges=bounds,
full_output=True,
finish=args.finish,
)
if grid.ndim == 1:
plt.plot(grid, -np.log(Jout))
plt.title(args.glob)
plt.show()
elif grid.ndim == 3:
fig = plt.figure(figsize=(10, 6))
ax1 = fig.add_subplot(111, projection="3d")
mycmap = plt.get_cmap("gist_earth")
surf1 = ax1.plot_surface(grid[0, :],
grid[1, :],
-np.log(Jout),
cmap=mycmap)
fig.colorbar(surf1, ax=ax1, shrink=0.5, aspect=5)
plt.title(args.glob)
plt.show()
elif args.method == "basinhopping":
res = optimize.basinhopping(
func=run,
x0=tuple(fixed),
minimizer_kwargs={"args": tuple(7 * [None])},
)
elif args.method == "shgo-sobol":
constraints = []
if args.period is None:
constraints.append({
"type": "eq",
"fun": lambda x: np.array([x[0] - int(x[0])])
})
if args.protect_loss is None:
constraints.append({
"type": "eq",
"fun": lambda x: np.array([x[7] - int(x[7])])
})
res = optimize.shgo(
func=run,
args=tuple(fixed),
bounds=bounds,
constraints=constraints,
options={"disp": True},
sampling_method="sobol",
minimizer_kwargs={"options": {
"eps": np.array(abs_diff)
}},
)
tbl = PrettyTable([
"Period",
"BB Low",
"BB High",
"Low Zone",
"High Zone",
"Low Sigma",
"High Sigma",
"Protect",
"Return",
])
tbl.float_format = ".4"
for minim in res.xl:
row = []
i = 0
for val in fixed:
if val is None:
row.append(minim[i])
i += 1
else:
row.append(val)
score = run(minim, *fixed)
row.append(-np.log(score))
tbl.add_row(row)
print(PTABLE._hrule)
print()
print(tbl)
elif args.method == "hyperopt":
space = [
hp.quniform("period", 12, 48 * 3600 / 5, 1),
hp.uniform("bb_low", 0.25, 4),
hp.uniform("bb_high", 0.25, 4),
hp.uniform("lo_zone", -0.1, 0.5),
hp.uniform("hi_zone", 0.5, 1.1),
hp.uniform("lo_sigma", 0, 4),
hp.uniform("hi_sigma", 0, 4),
hp.quniform("protect_loss", 0, 1, 1),
]
res = fmin(run, space, algo=tpe.suggest, max_evals=200)
print(run(space_eval(space, res)))
elif len(bounds) == 0:
run([], *fixed)
elif len(bounds) == 1:
x0 = [(bounds[0][0] + bounds[0][1]) / 2]
constraints = ()
options = {"disp": True}
if args.period is None:
constraints = [{
"type": "eq",
"fun": lambda x: np.array([x[0] - int(x[0])])
}]
options["finite_diff_rel_step"] = (1 / x0[0], )
res = optimize.minimize(
fun=run,
x0=x0,
method="trust-constr",
args=tuple(fixed),
bounds=Bounds(bounds[0][0], bounds[0][1]),
constraints=constraints,
options=options,
)
else:
res = getattr(optimize, args.method)(
func=run,
args=tuple(fixed),
bounds=bounds,
maxiter=1000000,
local_search_options={
"options": {
"disp": True
}
},
)
if res is not None:
print(res)
print(f"Glob = {args.glob}")
print(f"Default = {DF.iloc[DF.shape[0] - 1]['mark']/DF.iloc[0]['mark']}")
