def test_write_json_file_multiple_comps(
filename,
input_dict_strs,
):
orig_results = {}
# Get python script from file and execute
filename = f'{os.path.dirname(__file__)}/{filename}'
with open(filename, 'r') as orig_file:
exec(orig_file.read())
for composition_name in input_dict_strs:
exec(
f'{composition_name}.run(inputs={input_dict_strs[composition_name]})'
)
orig_results[composition_name] = eval(
f'{composition_name}.results')
# reset random seed
pnl.core.globals.utilities.set_global_seed(0)
# Save json_summary of Composition to file and read back in.
json_filename = filename.replace('.py', '.json')
exec(f'pnl.write_json_file([{",".join(input_dict_strs)}], json_filename)')
exec(pnl.generate_script_from_json(json_filename))
for composition_name in input_dict_strs:
exec(
f'{composition_name}.run(inputs={input_dict_strs[composition_name]})'
)
final_results = eval(f'{composition_name}.results')
assert orig_results[
composition_name] == final_results, f'{composition_name}:'
def main():
reconstructed_identifer = "reconstructed"
for example in glob.glob(os.path.join(os.path.dirname(__file__), "*.py")):
if reconstructed_identifer in example or example == __file__:
continue
pnl.clear_registry()
border = "=" * len(example)
print(f"{border}\n{example}\n{border}")
base_fname = example.replace(".py", "")
script_globals = runpy.run_path(example)
compositions = list(
filter(lambda v: isinstance(v, pnl.Composition),
script_globals.values()))
nonnested_comps = []
for x in compositions:
for y in compositions:
if x in y.nodes:
break
else:
nonnested_comps.append(x)
try:
comp = nonnested_comps[0]
except IndexError:
continue
json_summary = pnl.generate_json(comp)
with open(f"{base_fname}.json", "w") as outfi:
outfi.write(json_summary)
outfi.write("\n")
reconstructed_fname = f"{base_fname}.{reconstructed_identifer}.py"
with open(reconstructed_fname, "w") as outfi:
outfi.write(pnl.generate_script_from_json(json_summary))
outfi.write("\n")
subprocess.run(["black", reconstructed_fname])
subprocess.run(["python", reconstructed_fname])
def test_json_results_equivalence(
filename,
composition_name,
input_dict_str,
):
# Get python script from file and execute
filename = f'{os.path.dirname(__file__)}/{filename}'
with open(filename, 'r') as orig_file:
exec(orig_file.read())
exec(f'{composition_name}.run(inputs={input_dict_str})')
orig_results = eval(f'{composition_name}.results')
# reset random seed
pnl.core.globals.utilities.set_global_seed(0)
# Generate python script from JSON summary of composition and execute
json_summary = eval(f'{composition_name}.json_summary')
exec(pnl.generate_script_from_json(json_summary))
exec(f'{composition_name}.run(inputs={input_dict_str})')
new_results = eval(f'{composition_name}.results')
assert orig_results == new_results
def test_write_json_file(
filename,
composition_name,
input_dict_str,
):
# Get python script from file and execute
filename = f'{os.path.dirname(__file__)}/{filename}'
with open(filename, 'r') as orig_file:
exec(orig_file.read())
exec(f'{composition_name}.run(inputs={input_dict_str})')
orig_results = eval(f'{composition_name}.results')
# reset random seed
pnl.core.globals.utilities.set_global_seed(0)
# Save json_summary of Composition to file and read back in.
json_filename = filename.replace('.py', '.json')
exec(f'pnl.write_json_file({composition_name}, json_filename)')
exec(pnl.generate_script_from_json(json_filename))
# exec(f'{composition_name}.run(inputs={input_dict_str})')
exec(f'pnl.get_compositions()[0].run(inputs={input_dict_str})')
final_results = eval(f'{composition_name}.results')
assert orig_results == final_results
def test_json_results_equivalence(
filename,
composition_name,
input_dict_str,
):
filename = f'{os.path.dirname(__file__)}/{filename}'
with open(filename, 'r') as orig_file:
exec(orig_file.read())
exec(f'{composition_name}.run(inputs={input_dict_str})')
orig_results = eval(f'{composition_name}.results')
# reset random seed
seed = 0
random.seed(seed)
np.random.seed(seed)
pnl.core.globals.utilities.set_global_seed(seed)
exec(
pnl.generate_script_from_json(
eval(f'{composition_name}.json_summary')))
exec(f'{composition_name}.run(inputs={input_dict_str})')
new_results = eval(f'{composition_name}.results')
assert orig_results == new_results
), # default, "Never" for early termination - ends when all trials finished
pnl.TimeScale.TRIAL: pnl.AfterNCalls(fn, int(simtime / dt))
}
print('Running the SimpleFN model...')
comp.run(inputs={fn: 0}, log=True)
print('Finished running the SimpleFN model')
base_fname = __file__.replace('.py', '')
with open(f'{base_fname}.json', 'w') as outfi:
outfi.write(comp.json_summary)
with open(f'{base_fname}.converted.py', 'w') as outfi:
outfi.write(pnl.generate_script_from_json(comp.json_summary))
outfi.write('\ncomp.show_graph()\n')
for node in comp.nodes:
print(f'=== {node} {node.name}: {node.parameters.value.get(comp)}')
def generate_time_array(node, context='comp', param='value'):
return [
entry.time.pass_
for entry in getattr(node.parameters, param).log[context]
]
def generate_value_array(node, index, context='comp', param='value'):
print(node, index, param, context)
# Generated by NeuroMLlite v0.2.1
import psyneulink as pnl
conv_json_filename = 'FN.bids-mdf.json'
with open(conv_json_filename, 'r') as infile:
json = infile.read()
load_model = 'load_FN_bids_mdf'
py_filename = load_model + '.py'
with open(py_filename, 'w') as outfi:
outfi.write(pnl.generate_script_from_json(json))
exec('from %s import FN' % load_model)
print('Ready to run network: FN imported using %s' % py_filename)
dt = 0.05
simtime = 100.0
time_step_size = dt
num_trials = int(simtime / dt)
FN.run(inputs={}, log=True, num_trials=num_trials)
print('Finished simulation run of %s ms' % simtime)
def generate_time_array(node, context='FN', param='value'):
return [
entry.time.trial
for entry in getattr(node.parameters, param).log[context]
for name, projection in lems_json["projections"].items():
# unsure of any edge parameters in the original json
for proj in parse_projection(projection):
proj_name = proj['name']
composition['edges'][proj_name] = proj
converted_json = json.dumps(
converted_json,
cls=pnl.PNLJSONEncoder,
indent=4,
)
print(converted_json)
with open(filename_to_samedir_filename(converted_json_fname), 'w') as outfi:
outfi.write(converted_json)
with open(filename_to_samedir_filename(converted_pnl_script_fname),
'w') as outfi:
outfi.write(pnl.generate_script_from_json(converted_json))
outfi.write('\ncomposition.show_graph()')
# make output py script easier to read using black
line_length = 80
subprocess.Popen([
'black', '-l',
str(line_length),
filename_to_samedir_filename(converted_pnl_script_fname)
])