This script shows how to use the hdf5 database structure, including saving,
loading, renaming, and deleting data
'''
import numpy as np
from abr_analyze import DataHandler
from download_examples_db import check_exists as examples_db
examples_db()
save_location = 'data_handling'
recorded_time = np.linspace(0, 1, 100)
recorded_data = np.random.rand(100, 3)
data_dict = {'trajectory': recorded_data, 'time': recorded_time}
# instantiate a database with your desired name
dat = DataHandler(db_name='abr_analyze_examples')
# save our data
dat.save(data=data_dict, save_location=save_location, overwrite=True)
# load our data
# we can specify what parameters to load
data = dat.load(parameters=['trajectory', 'time'], save_location=save_location)
trajectory = data['trajectory']
time = data['time']
# we can rename our save_location as well
new_save_location = 'data_handling_rename'
dat.rename(old_save_location=save_location,
new_save_location=new_save_location,
delete_old=True)
def plot_performance(ax=None):
test_group = "weighted_tests"
main_db = "abr_neurorobotics2020_adaptation_data"
test_list = [
["pd_no_weight", "", "k", main_db, test_group, "-"],
["pd", "", "tab:grey", main_db, test_group, "-"],
["pid", "PID", "tab:brown", main_db, test_group, "-"],
["nengo_cpu1k", "Adaptive CPU", "g", main_db, test_group, "-"],
["nengo_gpu1k", "Adaptive GPU", "r", main_db, test_group, "-"],
["nengo_loihi1k", "Adaptive Loihi", "b", main_db, test_group, "-"],
]
pd_dat = DataHandler(db_name=main_db)
# load in PD mean performance with and without weight for normalizing
pd_no_weight_mean = pd_dat.load(
parameters=["mean"],
save_location="%s/pd_no_weight/statistical_error_0" % (test_group),
)["mean"]
pd_weight_mean = pd_dat.load(parameters=["mean"],
save_location="%s/pd/statistical_error_0/" %
(test_group))["mean"]
n_sessions = 5
n_runs = 50
interpolated_samples = 400
if ax is None:
_, ax = plt.subplots(1, 1, figsize=(5, 5))
for ii, test in enumerate(test_list):
print("Processing test %i/%i: %s" % (ii + 1, len(test_list), test[0]))
save_location = "%s/%s" % (test[4], test[0])
errors = []
for session in range(n_sessions):
session_error = []
for run in range(n_runs):
print(
"%.3f processing complete..." %
(100 * ((run + 1) + (session * n_runs)) /
(n_sessions * n_runs)),
end="\r",
)
loc = "%s/session%03d/run%03d" % (save_location, session, run)
session_error.append(
np.mean(
pd_dat.load(parameters=["error"],
save_location=loc)["error"]))
errors.append(session_error)
n = 3000 # use 3000 sample points
p = 0.95 # calculate 95% confidence interval
sample = []
upper_bound = []
lower_bound = []
sets = np.array(errors).shape[0]
data_pts = np.array(errors).shape[1]
print("Mean and CI calculation found %i sets of %i data points" %
(sets, data_pts))
errors = np.array(errors)
for i in range(data_pts):
data = errors[:, i]
index = int(n * (1 - p) / 2)
samples = np.random.choice(data, size=(n, len(data)))
r = [np.mean(s) for s in samples]
r.sort()
ci = r[index], r[-index]
sample.append(np.mean(data))
lower_bound.append(ci[0])
upper_bound.append(ci[1])
ci_errors = {
"mean": sample,
"lower_bound": lower_bound,
"upper_bound": upper_bound,
}
ci_errors["time_derivative"] = 0
data = pd_dat.load(
parameters=["mean", "upper_bound", "lower_bound"],
save_location="%s/statistical_error_0" % save_location,
)
# subtract the PD performance with no weight
data["mean"] = data["mean"] - pd_no_weight_mean
data["upper_bound"] = data["upper_bound"] - pd_no_weight_mean
data["lower_bound"] = data["lower_bound"] - pd_no_weight_mean
# normalize by the PD performance with a weight
data["mean"] = data["mean"] / (pd_weight_mean - pd_no_weight_mean)
data["upper_bound"] = data["upper_bound"] / (pd_weight_mean -
pd_no_weight_mean)
data["lower_bound"] = data["lower_bound"] / (pd_weight_mean -
pd_no_weight_mean)
ax.fill_between(
range(np.array(data["mean"]).shape[0]),
data["upper_bound"],
data["lower_bound"],
color=test[2],
alpha=0.5,
)
ax.plot(data["mean"], color=test[2], label=test[1], linestyle=test[5])
ax.set_title("Performance")
ax.set_ylabel("Percent error")
ax.set_xlabel("Trial")
ax.legend()
ax.grid()
f for f in listdir(database_dir) if isfile(join(database_dir, f))
]
print(
f"No database passed in, the following are available in the repo database direction: {database_dir}"
)
for ii, fname in enumerate(onlyfiles):
print(f"{ii}) {fname}")
index = input("Which databse would you like to view?")
db = onlyfiles[int(index)].split(".")[0]
# else:
# db = sys.argv[1]
# if len(sys.argv)>2:
# folder = sys.argv[2]
dat = DataHandler(db_name=db, database_dir=folder)
class bcolors:
HEADER = "\033[95m"
BLUE = "\033[94m"
GREEN = "\033[92m"
YELLOW = "\033[93m"
RED = "\033[91m"
ENDC = "\033[0m"
BOLD = "\033[1m"
UNDERLINE = "\033[4m"
# set some constants
LARGE_FONT = ("Verdana", 20)
This script shows how to use the hdf5 database structure, including saving,
loading, renaming, and deleting data
"""
import numpy as np
from download_examples_db import check_exists as examples_db
from abr_analyze import DataHandler
examples_db()
save_location = "data_handling"
recorded_time = np.linspace(0, 1, 100)
recorded_data = np.random.rand(100, 3)
data_dict = {"trajectory": recorded_data, "time": recorded_time}
# instantiate a database with your desired name
dat = DataHandler(db_name="abr_analyze_examples")
# save our data
dat.save(data=data_dict, save_location=save_location, overwrite=True)
# load our data
# we can specify what parameters to load
data = dat.load(parameters=["trajectory", "time"], save_location=save_location)
trajectory = data["trajectory"]
time = data["time"]
# we can rename our save_location as well
new_save_location = "data_handling_rename"
dat.rename(
old_save_location=save_location,
new_save_location=new_save_location,
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
import os
from abr_analyze import DataHandler
from abr_analyze.nengo import network_utils
from abr_control.controllers import signals
from abr_analyze.paths import cache_dir, figures_dir
from download_examples_db import check_exists as examples_db
import nengo
examples_db()
dat = DataHandler('abr_analyze_examples')
fig = plt.figure(figsize=(8, 12))
ax_list = [fig.add_subplot(311), fig.add_subplot(312), fig.add_subplot(313)]
runs = 10
for ii in range(0, runs):
data = dat.load(parameters=['input_signal'],
save_location='test_1/session000/run%03d' % ii)
if ii == 0:
input_signal = data['input_signal']
else:
input_signal = np.vstack((input_signal, data['input_signal']))
input_signal = np.squeeze(input_signal)
# specify our network parameters
import matplotlib
import numpy as np
matplotlib.use("TkAgg")
import os
import matplotlib.pyplot as plt
from abr_control.controllers import signals
from download_examples_db import check_exists as examples_db
from abr_analyze import DataHandler
from abr_analyze.nengo import network_utils
from abr_analyze.paths import cache_dir, figures_dir
examples_db()
dat = DataHandler("abr_analyze_examples")
fig = plt.figure(figsize=(8, 12))
ax_list = [fig.add_subplot(311), fig.add_subplot(312), fig.add_subplot(313)]
data = dat.load(
parameters=[
"n_input",
"n_output",
"n_neurons",
"n_ensembles",
"pes",
"intercepts",
"seed",
"encoders",
],
save_location="nengo_data",
)
against the first dimension of u_adapt.
"""
import matplotlib
import numpy as np
matplotlib.use("TkAgg")
import matplotlib.pyplot as plt
from download_examples_db import check_exists as examples_db
import abr_analyze.data_visualizer as vis
from abr_analyze import DataHandler
from abr_analyze.paths import figures_dir
from abr_analyze.plotting import TrajectoryError
examples_db()
dat = DataHandler("abr_analyze_examples")
data = dat.load(
parameters=["input_signal", "u_adapt"], save_location="test_1/session000/run000"
)
input_signal = data["input_signal"].squeeze()
output_signal = data["u_adapt"][:, 0].squeeze()
fig, axes = plt.subplots(3, 1)
vis.plot_against_projection_2d(
ax=axes[0], data_project=input_signal, data_plot=output_signal
)
vis.plot_against_projection_3d(
ax=axes[1], data_project=input_signal, data_plot=output_signal
)
def _example():
import matplotlib.pyplot as plt
# Instantiate database to save results
db_name = "searchable_results_example"
db_folder = None
dat = DataHandler(db_name=db_name, database_dir=db_folder)
# generate baseline json
params = {
"sin_params": {
"A": 3,
"shift": 5,
},
"time": [0, 5, 100],
"exp": 2,
}
# if loading from json
# with open(json_fp) as fp:
# params = json.load(fp)
# example function that generates results
# Needs to accept params dict as input and return dictionary of results
def example_results(params):
t = np.linspace(params["time"][0], params["time"][1],
params["time"][2])
y = (params["sin_params"]["A"] *
np.sin(t - params["sin_params"]["shift"])**params["exp"])
return {"t": t, "y": y}
# unique name for script that generates results
# should update name if something changes in the script that would affect results
script_name = "example_script"
# get results
print("--Getting results for baseline parameters--")
results = example_results(params)
# save in searchable format
print("--Saving baseline results--")
searchable_save(dat=dat,
results=results,
params=params,
script_name=script_name)
# helper function to quickly create some variations of our parameter set
print("--Generating parameter variations--")
param_variations = gen_parameter_variations(params=params,
variation_dict={
"sin_params/A": [5, 7, 10],
"exp": [3, 4]
})
# get results for each variation and save
print("--Getting results for parameter variations--")
for hash_id, varied_params in param_variations.items():
print(f"\nGetting results for {hash_id}")
# pretty printing of nested dictionaries
print_nested(varied_params, indent=0, return_val=False)
results = example_results(varied_params)
print("Saving results")
searchable_save(dat=dat,
results=results,
params=varied_params,
script_name=script_name)
# now load all results that have these parameter values
const_params = {
"exp": 3,
}
# result keys to load
result_keys = ["y"]
# Load results that have a set of common parameters
print(f"Loading results with parameters:\n{const_params}")
results = load_results(
script_name=script_name,
const_params=const_params,
saved_exp_hashes=None,
result_keys=result_keys,
dat=dat,
ignore_keys=None,
)
# plot the results
plt.figure()
ax = plt.subplot(111)
for hash_name in results:
# ignore const and variable params keys
if "params" in hash_name:
continue
# print(dict_nested2str(results[hash_name]))
ax.plot(results[hash_name]["results"]["y"],
label=results[hash_name]["name"])
# print the values that are constant between all tests
ax.text(
0,
-5,
("Constant Parameters\n" + "___________________\n" +
dict_nested2str(results["const_params"])),
fontsize=8,
)
plt.subplots_adjust(right=0.6)
plt.legend()
plt.tight_layout()
plt.show()