def default_validate_gate(gate_base_dir, validation_processor_configs):
model = torch.load(
os.path.join(gate_base_dir, 'reproducibility', 'model.pt'),
map_location=torch.device(TorchUtils.get_accelerator_type()))
results = torch.load(
os.path.join(gate_base_dir, 'reproducibility', 'results.pickle'),
map_location=torch.device(TorchUtils.get_accelerator_type()))
experiment_configs = load_configs(
os.path.join(gate_base_dir, 'reproducibility', 'configs.yaml'))
results_dir = init_dirs(gate_base_dir, is_main=True)
criterion = manager.get_criterion(experiment_configs["algorithm"])
waveform_transforms = transforms.Compose([
PlateausToPoints(
experiment_configs['processor']["data"]['waveform']
), # Required to remove plateaus from training because the perceptron cannot accept less than 10 values for each gate
PointsToPlateaus(validation_processor_configs["data"]["waveform"])
])
validate_gate(model,
results,
validation_processor_configs,
criterion,
results_dir=results_dir,
transforms=waveform_transforms)
def data_loader(data_directory):
config_path = os.path.join(data_directory, 'sampler_configs.json')
configs = load_configs(config_path)
data_path = os.path.join(data_directory, 'IO.dat')
data = np.loadtxt(data_path)
inputs = data[:, :configs["input_data"]["input_electrodes"]]
outputs = data[:, -configs["input_data"]["output_electrodes"]:]
return inputs, outputs, configs
def consistency_check(configs_path):
configs = load_configs(configs_path)
sampler = ConsistencyChecker(configs)
outputs, deviations, correlation, deviation_chargeup = sampler.get_data()
mean_output = np.mean(outputs, axis=0)
std_output = np.std(outputs, axis=0)
plt.figure()
plt.plot(mean_output, 'k', label='mean over repetitions')
plt.plot(mean_output + std_output, ':k')
plt.plot(mean_output - std_output, ':k', label='stdev over repetitions')
plt.plot(sampler.reference_outputs, 'r', label='reference signal')
plt.title(
f'Consistency over {sampler.configs_checker["repetitions"]} trials with same input'
)
plt.legend()
plt.savefig(
os.path.join(configs["path_to_reference_data"], 'consistency_check'))
plt.figure()
plt.plot(mean_output - sampler.reference_outputs,
"b",
label="mean - reference")
plt.plot(std_output, ":k", label="stdev over repetitions")
plt.plot(-std_output, ":k")
plt.title("Difference Mean Signal and Reference Signal")
plt.legend()
plt.savefig(
os.path.join(configs["path_to_reference_data"], 'diff_mean-ref'))
plt.figure()
plt.hist(deviations)
plt.title("Deviations of Reference Signal")
plt.savefig(
os.path.join(configs["path_to_reference_data"], 'hist_deviations'))
plt.figure()
plt.plot(deviation_chargeup)
plt.title("DEVIATIONS WHILE CHARGING UP")
plt.savefig(
os.path.join(configs["path_to_reference_data"],
'deviations_while_charging_up'))
plt.show()
print("DONE!")
def validate_vcdim(vcdim_base_dir, validation_processor_configs, is_main=True):
base_dir = init_dirs(vcdim_base_dir, is_main=is_main)
dirs = [
os.path.join(vcdim_base_dir, o) for o in os.listdir(vcdim_base_dir)
if os.path.isdir(os.path.join(vcdim_base_dir, o))
]
for d in dirs:
if os.path.split(d)[1] != "validation":
gate_dir = create_directory(
os.path.join(base_dir,
d.split(os.path.sep)[-1]))
model = torch.load(os.path.join(d, 'reproducibility', 'model.pt'),
map_location=torch.device(
TorchUtils.get_accelerator_type()))
results = torch.load(
os.path.join(d, 'reproducibility', "results.pickle"),
map_location=torch.device(TorchUtils.get_accelerator_type()))
experiment_configs = load_configs(
os.path.join(d, 'reproducibility', "configs.yaml"))
#results_dir = init_dirs(d, is_main=is_main)
criterion = manager.get_criterion(experiment_configs["algorithm"])
waveform_transforms = transforms.Compose([
PlateausToPoints(
experiment_configs['processor']["data"]['waveform']
), # Required to remove plateaus from training because the perceptron cannot accept less than 10 values for each gate
PointsToPlateaus(
validation_processor_configs["data"]["waveform"])
])
# validate_gate(os.path.join(d, "reproducibility"), base_dir, is_main=False)
validate_gate(model,
results,
validation_processor_configs,
criterion,
results_dir=gate_dir,
transforms=waveform_transforms,
is_main=False)
def __init__(self, configs):
super().__init__(load_configs(configs['path_to_sampler_configs']))
_, batch_size, _ = self.init_configs()
self.configs_checker = configs
path_to_file = os.path.join(
self.configs_checker['path_to_reference_data'],
self.configs_checker['reference_batch_name'])
with np.load(path_to_file) as data:
self.reference_outputs = data['outputs']
self.reference_inputs = data['inputs'].T
path_to_file = os.path.join(
self.configs_checker['path_to_reference_data'],
self.configs_checker['data_name'])
with np.load(path_to_file) as data:
self.chargingup_outputs = data['outputs']
self.chargingup_inputs = data['inputs'].T
self.nr_samples = len(self.reference_outputs)
assert self.nr_samples % batch_size == 0, f"Batch length {batch_size} is not a multiple of the reference signal length {self.nr_samples}; possible data missmatch!"
self.configs_checker['batch_size'] = batch_size
self.results_filename = os.path.join(
self.configs_checker['path_to_reference_data'],
'consistency_results.npz')
from torchvision import transforms
from brainspy.utils import manager
from bspytasks.boolean.logger import Logger
from brainspy.utils.io import load_configs
from brainspy.utils.transforms import (
DataToTensor,
DataPointsToPlateau,
DataToVoltageRange,
)
from brainspy.processors.dnpu import DNPU
V_MIN = [-1.2, -1.2]
V_MAX = [0.6, 0.6]
configs = load_configs("configs/boolean.yaml")
data_transforms = transforms.Compose(
[DataToVoltageRange(V_MIN, V_MAX, -1, 1), DataToTensor('cpu')]
)
waveform_transforms = transforms.Compose(
[DataPointsToPlateau(configs["processor"]["data"]["waveform"])]
)
criterion = manager.get_criterion(configs["algorithm"])
algorithm = manager.get_algorithm(configs["algorithm"])
configs["current_dimension"] = 4
results = vc_dimension_test(
configs,
DNPU,
PointsToPlateaus(validation_processor_configs["data"]["waveform"])
])
validate_gate(model,
results,
validation_processor_configs,
criterion,
results_dir=results_dir,
transforms=waveform_transforms)
if __name__ == "__main__":
from torchvision import transforms
from brainspy.utils.io import load_configs
from brainspy.utils.transforms import PointsToPlateaus, PlateausToPoints
from brainspy.utils import manager
from brainspy.utils.pytorch import TorchUtils
validation_processor_configs = load_configs(
"configs/defaults/processors/hw.yaml")
capacity_base_dir = "tmp/TEST/output/boolean/capacity_test_2020_09_21_155613"
vcdim_base_dir = '/home/unai/Documents/3-programming/brainspy-tasks/tmp/TEST/output/boolean/vc_dimension_4_2020_09_24_190737'
gate_base_dir = '/home/unai/Documents/3-programming/brainspy-tasks/tmp/TEST/output/boolean/[0, 0, 0, 1]_2020_09_24_181148'
#default_validate_gate(gate_base_dir, validation_processor_configs)
validate_vcdim(vcdim_base_dir, validation_processor_configs)
# validate_capacity(capacity_base_dir, validation_processor_configs)
base_dir = os.path.join(base_dir, gate)
create_directory(base_dir)
return base_dir
if __name__ == "__main__":
from torchvision import transforms
from brainspy.utils.io import load_configs
from brainspy.utils.transforms import PointsToPlateaus
from brainspy.algorithms.modules.signal import fisher
base_dir = "tmp/TEST/output/ring/ring_classification_gap_0.00625_2020_09_23_140014"
model, results = load_reproducibility_results(base_dir)
configs = load_configs("configs/ring.yaml")
hw_processor_configs = load_configs("configs/defaults/processors/hw.yaml")
waveform_transforms = transforms.Compose(
[PointsToPlateaus(hw_processor_configs["data"]["waveform"])])
results_dir = init_dirs(os.path.join(base_dir, "validation"))
validate(
model,
results,
hw_processor_configs,
fisher,
results_dir,
transforms=waveform_transforms,
)
import matplotlib.pyplot as plt
from brainspy.utils.io import load_configs
from bspysmg.measurement.data.output.sampler_mgr import Sampler
from bspysmg.measurement.data.processing.postprocessing import post_process
CONFIGS = load_configs(
'configs/sampling/sampling_configs_template_cdaq_to_cdaq.yaml')
sampler = Sampler(CONFIGS)
path_to_data = sampler.get_data()
INPUTS, OUTPUTS, INFO_DICT = post_process(path_to_data,
clipping_value=[-110, 110])
print(f"max out {OUTPUTS.max()} max min {OUTPUTS.min()} shape {OUTPUTS.shape}")
plt.show()
if __name__ == "__main__":
from brainspy.utils.io import load_configs
from bspysmg.model.data.outputs.train_model import generate_surrogate_model
configs = load_configs("configs/training/smg_configs_template.yaml")
generate_surrogate_model(configs)
axs[i, j].set_ylabel('input (V)')
axs[i, j].set_xlabel('points', labelpad=1)
axs[i, j].set_title("Input Waveform")
axs[i, j].xaxis.grid(True)
axs[i, j].yaxis.grid(True)
plt.show()
if __name__ == '__main__':
from brainspy.utils.io import load_configs
configs = {}
configs['results_base_dir'] = 'tmp/tests/iv'
configs['show_plots'] = True
configs['devices'] = ['A', 'B', 'C', "D", 'E']
configs['shape'] = 500 # length of the experiment
configs['waveform'] = {}
configs['waveform']['V_high'] = 0.75
configs['waveform']['V_low'] = -0.75
configs['waveform']['input_type'] = 'sine'
configs['waveform']['time'] = 5
configs['waveform']['direction'] = 'up'
configs['processor'] = load_configs(
'C:/Users/braml/Documents/Github/ring-example/processor_iv_curves.yaml'
)
suite = unittest.TestSuite()
suite.addTest(IVtest(configs))
unittest.TextTestRunner().run(suite)
'c_dnpu_output':
self.dnpu_output.clone().detach(),
'd_clamped_dnpu_output':
self.clamped_dnpu_output.clone().detach(),
'e_batch_norm_output':
self.batch_norm_output.clone().detach()
})
if __name__ == "__main__":
from brainspy.utils.io import load_configs
import matplotlib.pyplot as plt
import time
NODE_CONFIGS = load_configs(
"/home/hruiz/Documents/PROJECTS/DARWIN/Code/packages/brainspy/brainspy-processors/configs/configs_nn_model.json"
)
node = DNPU(NODE_CONFIGS)
# linear_layer = nn.Linear(20, 3).to(device=TorchUtils.get_accelerator_type())
# dnpu_layer = DNPU_Channels([[0, 3, 4]] * 1000, node)
linear_layer = nn.Linear(20,
300).to(device=TorchUtils.get_accelerator_type())
dnpu_layer = DNPU_Layer([[0, 3, 4]] * 100, node)
model = nn.Sequential(linear_layer, dnpu_layer)
data = torch.rand((200, 20)).to(device=TorchUtils.get_accelerator_type())
start = time.time()
output = model(data)
end = time.time()
axs[i, j].set_ylabel('input (V)')
axs[i, j].set_xlabel('points', labelpad=1)
axs[i, j].set_title("Input Waveform")
axs[i, j].xaxis.grid(True)
axs[i, j].yaxis.grid(True)
plt.show()
if __name__ == '__main__':
from brainspy.utils.io import load_configs
configs = {}
configs['results_base_dir'] = 'tmp/tests/iv'
configs['show_plots'] = True
configs['devices'] = ['A'] #, 'B', 'C', "D", 'E']
configs['shape'] = 500 # length of the experiment
configs['waveform'] = {}
configs['waveform']['V_high'] = 1.25
configs['waveform']['V_low'] = -1.25
configs['waveform']['input_type'] = 'sine'
configs['waveform']['time'] = 5
configs['waveform']['direction'] = 'up'
configs['processor'] = load_configs(
'C:/Users/bram/Documents/Github/examples-multiple-devices/processor_iv_curves.yaml'
)
suite = unittest.TestSuite()
suite.addTest(IVtest(configs))
unittest.TextTestRunner().run(suite)
import torch
from brainspy.processors.simulation.model import NeuralNetworkModel
from brainspy.utils.io import load_configs
from brainspy.utils.pytorch import TorchUtils
from bspysmg.model.data.outputs.train_model import train_surrogate_model
#TorchUtils.force_cpu = True
CONFIGS = load_configs('configs/training/smg_configs_template.yaml')
MODEL = NeuralNetworkModel(CONFIGS['processor'])
OPTIMIZER = torch.optim.Adam(filter(lambda p: p.requires_grad,
MODEL.parameters()),
lr=CONFIGS['hyperparameters']['learning_rate'])
CRITERION = torch.nn.MSELoss()
train_surrogate_model(CONFIGS, MODEL, CRITERION, OPTIMIZER)
plt.xlabel("Accuracy values")
plt.ylabel("Counts")
plt.savefig(os.path.join(save_dir, "accuracy_histogram_" + label + "." + extension))
if show_plots:
plt.show()
if __name__ == "__main__":
from torchvision import transforms
from brainspy.utils import manager
from brainspy.utils.io import load_configs
from brainspy.utils.transforms import DataToTensor, DataToVoltageRange
from brainspy.processors.dnpu import DNPU
V_MIN = [-1.2, -1.2]
V_MAX = [0.6, 0.6]
transforms = transforms.Compose(
[DataToVoltageRange(V_MIN, V_MAX, -1, 1), DataToTensor(torch.device('cpu'))]
)
configs = load_configs("configs/ring.yaml")
criterion = manager.get_criterion(configs["algorithm"])
algorithm = manager.get_algorithm(configs["algorithm"])
search_solution(configs, DNPU, criterion, algorithm, transforms=transforms)
print('Repeating the experiment...')
count = 0
while nr_samples > count * batch:
indices = list(range(batch))
if None in indices:
indices = [index for index in indices if index is not None]
yield indices
count += 1
if __name__ == '__main__':
from brainspy.utils.io import load_configs
import matplotlib.pyplot as plt
CONFIGS = load_configs('configs/sampling/sampling_configs_template.json')
sampler = Sampler(CONFIGS)
# CONFIGS = load_configs('configs/sampling/toy_sampling_configs_template.json')
# sampler = Sampler(CONFIGS)
# CONFIGS = load_configs('configs/sampling/toy_sampling_configs_template.json')
# sampler = Repeater(CONFIGS)
path_to_data = sampler.get_data()
INPUTS, OUTPUTS, INFO_DICT = sampler.load_data(path_to_data)
# OUTPUTS = OUTPUTS.reshape((-1,INFO_DICT['input_data']["batch_points"])).T
plt.figure()
plt.hist(OUTPUTS, 500)
plt.show()
import torch
from brainspy.processors.simulation.model import NeuralNetworkModel
from brainspy.utils.io import load_configs
from brainspy.utils.pytorch import TorchUtils
from bspysmg.model.data.outputs.train_model import train_surrogate_model
#TorchUtils.force_cpu = True
CONFIGS = load_configs(
'configs/training/smg_configs_template_multiple_outputs.yaml')
MODEL = NeuralNetworkModel(CONFIGS['processor'])
OPTIMIZER = torch.optim.Adam(filter(lambda p: p.requires_grad,
MODEL.parameters()),
lr=CONFIGS['hyperparameters']['learning_rate'])
CRITERION = torch.nn.MSELoss()
train_surrogate_model(CONFIGS, MODEL, CRITERION, OPTIMIZER)
for i in range(len(configs['readout_channels'])):
readout_channel_list.append(configs['readout_instrument'] + "/ai" +
str(configs['readout_channels'][i]))
return readout_channel_list
def get_mask(configs):
if 'activation_channel_mask' in configs:
return np.array(configs['activation_channel_mask'])
else:
return None
def add_uniquely(original_list, value):
if value not in original_list:
original_list.append(value)
return original_list
if __name__ == "__main__":
from brainspy.utils.io import load_configs
configs = load_configs(
'/home/unai/Documents/3-programming/brainspy-tasks/configs/defaults/processors/hw.yaml'
)
a, r, ins, vr = init_channel_data(configs['driver'])
print(a)
print(r)
