def main():
file_path = "Simple.json"
data = convert_states_to_stateful_parameters("../" + file_path)
# print(data)
with open("Translated_" + file_path, "w") as fp:
json.dump(data, fp, indent=4)
if "-run" in sys.argv:
verbose = True
mod_graph = load_mdf("Translated_%s" % file_path).graphs[0]
eg = EvaluableGraph(mod_graph, verbose)
mod_graph_old = load_mdf("../" + file_path).graphs[0]
eg_old = EvaluableGraph(mod_graph_old, verbose)
format = FORMAT_NUMPY
eg.evaluate(array_format=format)
eg_old.evaluate(array_format=format)
print(
"New file output value>>>",
eg.enodes["processing_node"].evaluable_outputs["output_1"].
curr_value,
)
print(
"Old file output value>>>",
eg_old.enodes["processing_node"].evaluable_outputs["output_1"].
curr_value,
)
def test_abc():
base_path = Path(__file__).parent
filename = "examples/ONNX/abc_basic-mdf.json"
file_path = (base_path / "../../.." / filename).resolve()
# Load the MDF model
mdf_model = load_mdf(str(file_path))
# Test input
test_input = np.array([[0, 0, 0], [1, 1, 1]], dtype=np.float32)
# Get the result of MDF execution
mdf_executable = EvaluableGraph(mdf_model.graphs[0], verbose=False)
mdf_executable.evaluate(initializer={"input": test_input})
mdf_output = mdf_executable.enodes["Cos_2"].evaluable_outputs[
"_3"].curr_value
# Get the translated ONNX model
onnx_models = mdf_to_onnx(mdf_model)
# Bluffing onnx that our model is 13 when it is actually 15. This is needed for older onnxruntime
# installations to run this model. See https://github.com/onnx/onnx/issues/3205
onnx_models[0].opset_import[0].version = 13
# Get the result of running the ONNX model
session = backend.prepare(onnx_models[0])
onnx_output = session.run(
test_input) # run returns a list with the actual result and type
onnx_res_output = np.array(onnx_output[0])
assert np.array_equal(onnx_res_output, mdf_output)
def test_inception(inception_model_pytorch):
"""Test the InceptionBlocks model that WebGME folks provided us."""
galaxy_images_output = torch.zeros((1, 5, 64, 64))
ebv_output = torch.zeros((1,))
# Run the model once to get some ground truth outpot (from PyTorch)
output = inception_model_pytorch(galaxy_images_output, ebv_output).detach().numpy()
# Convert to MDF
mdf_model, params_dict = pytorch_to_mdf(
model=inception_model_pytorch,
args=(galaxy_images_output, ebv_output),
example_outputs=output,
trace=True,
)
# Get the graph
mdf_graph = mdf_model.graphs[0]
# Add inputs to the parameters dict so we can feed this to the EvaluableGraph for initialization of all
# graph inputs.
params_dict["input1"] = galaxy_images_output.numpy()
params_dict["input2"] = ebv_output.numpy()
eg = EvaluableGraph(graph=mdf_graph, verbose=False)
eg.evaluate(initializer=params_dict)
assert np.allclose(
output,
eg.enodes["Add_381"].evaluable_outputs["_381"].curr_value,
)
def test_ab():
base_path = Path(__file__).parent
filename = "examples/ONNX/ab.json"
file_path = (base_path / "../../.." / filename).resolve()
# Load the MDF model
mdf_model = load_mdf(str(file_path))
# Test input
test_input = np.array([[0, 0, 0], [1, 1, 1]], dtype=np.float32)
# Get the result of MDF execution
mdf_executable = EvaluableGraph(mdf_model.graphs[0], verbose=False)
# TODO: the int type cast is necessaryf or now because the nodes' parameters are constants and inputs must have
# the same type
mdf_executable.evaluate(initializer={"input": test_input.astype(int)})
mdf_output = mdf_executable.enodes["Mul_3"].evaluable_outputs[
"_4"].curr_value
# Get the translated ONNX model
onnx_models = mdf_to_onnx(mdf_model)
# Bluffing onnx that our model is 13 when it is actually 15. This is needed for older onnxruntime
# installations to run this model. See https://github.com/onnx/onnx/issues/3205
onnx_models[0].opset_import[0].version = 13
# Get the result of running the ONNX model
session = backend.prepare(onnx_models[0])
onnx_output = session.run(
test_input) # run returns a list with the actual result and type
onnx_res_output = np.array(onnx_output[0])
# print(f"Output calculated by onnxruntime: {onnx_res_output} and MDF: {mdf_output.astype(float)}")
assert np.array_equal(onnx_res_output, mdf_output)
def main():
"""Takes count.lisp, converts to MDF, and runs using the scheduler."""
file_name = os.path.dirname(os.path.realpath(__file__)) + "/count.lisp"
print(file_name)
mod = actr_to_mdf(file_name)
mdf_graph = load_mdf(file_name[:-5] + ".json").graphs[0]
eg = EvaluableGraph(graph=mdf_graph, verbose=False)
term = False
goal = {}
retrieval = {}
while not term:
eg.evaluate(initializer={"goal_input": goal, "dm_input": retrieval})
term = (eg.enodes["check_termination"].
evaluable_outputs["check_output"].curr_value)
goal = (eg.enodes["fire_production"].
evaluable_outputs["fire_prod_output_to_goal"].curr_value)
retrieval = (
eg.enodes["fire_production"].
evaluable_outputs["fire_prod_output_to_retrieval"].curr_value)
print("Final Goal:")
print(eg.enodes["goal_buffer"].evaluable_outputs["goal_output"].curr_value)
def main():
mod_graph = generate_test_model("small_test", save_to_file=True)
scale = 2
mod_graph = generate_test_model(
"medium_test",
input_shape=(scale, scale),
hidden_shape=(scale, scale),
hidden_layers=5,
save_to_file=True,
)
if "-run" in sys.argv:
from modelspec.utils import FORMAT_NUMPY, FORMAT_TENSORFLOW
format = FORMAT_TENSORFLOW if "-tf" in sys.argv else FORMAT_NUMPY
print("------------------")
eg = EvaluableGraph(mod_graph, verbose=False)
eg.evaluate(array_format=format)
print("Finished evaluating graph using array format %s" % format)
def main():
dt = 0.01
file_path = "States.json"
data = convert_states_to_stateful_parameters("../" + file_path, dt)
with open("Translated_" + file_path, "w") as fp:
json.dump(data, fp, indent=4)
if "-run" in sys.argv:
verbose = True
mod_graph = load_mdf("Translated_%s" % file_path).graphs[0]
eg = EvaluableGraph(mod_graph, verbose)
mod_graph_old = load_mdf("../" + file_path).graphs[0]
eg_old = EvaluableGraph(mod_graph_old, verbose)
duration = 2
t = 0
recorded = {}
times = []
s = []
s_old = []
while t <= duration:
print("====== Evaluating at t = %s ======" % (t))
# levels.append(eg.enodes['sine_node'].evaluable_stateful_parameters['level'].curr_value)
# t+=args.dt
# print("time first>>>",type(t))
t = float(
eg.enodes["sine_node"].evaluable_parameters["time"].curr_value)
# times.append(float(eg.enodes['sine_node'].evaluable_parameters['time'].curr_value))
times.append(t)
if t == 0:
eg_old.evaluate() # replace with initialize?
else:
eg_old.evaluate(time_increment=dt)
s_old.append(eg_old.enodes["sine_node"].
evaluable_outputs["out_port"].curr_value)
eg.evaluate()
s.append(eg.enodes["sine_node"].evaluable_outputs["out_port"].
curr_value)
# t+=dt
print(s_old[:10], s[:10], times[:10])
import matplotlib.pyplot as plt
plt.plot(times, s)
plt.show()
plt.savefig("translated_levelratesineplot.jpg")
def main():
mod = Model(id="Simple")
mod_graph = Graph(id="simple_example")
mod.graphs.append(mod_graph)
input_node = Node(id="input_node")
input_node.parameters.append(Parameter(id="input_level", value=0.5))
op1 = OutputPort(id="out_port")
op1.value = "input_level"
input_node.output_ports.append(op1)
mod_graph.nodes.append(input_node)
processing_node = Node(id="processing_node")
mod_graph.nodes.append(processing_node)
processing_node.parameters.append(Parameter(id="lin_slope", value=0.5))
processing_node.parameters.append(Parameter(id="lin_intercept", value=0))
processing_node.parameters.append(Parameter(id="log_gain", value=3))
ip1 = InputPort(id="input_port1")
processing_node.input_ports.append(ip1)
f1 = Parameter(
id="linear_1",
function="linear",
args={"variable0": ip1.id, "slope": "lin_slope", "intercept": "lin_intercept"},
)
f2 = Parameter(
id="logistic_1",
function="logistic",
args={"variable0": f1.id, "gain": "log_gain", "bias": 0, "offset": 0},
)
processing_node.parameters.append(f1)
processing_node.parameters.append(f2)
processing_node.output_ports.append(OutputPort(id="output_1", value="logistic_1"))
e1 = Edge(
id="input_edge",
parameters={"weight": 0.55},
sender=input_node.id,
sender_port=op1.id,
receiver=processing_node.id,
receiver_port=ip1.id,
)
mod_graph.edges.append(e1)
print(mod)
print("------------------")
print(mod.to_json())
new_file = mod.to_json_file("%s.json" % mod.id)
new_file = mod.to_yaml_file("%s.yaml" % mod.id)
if "-run" in sys.argv:
verbose = True
# verbose = False
from modeci_mdf.execution_engine import EvaluableGraph
from modelspec.utils import FORMAT_NUMPY, FORMAT_TENSORFLOW
format = FORMAT_TENSORFLOW if "-tf" in sys.argv else FORMAT_NUMPY
eg = EvaluableGraph(mod_graph, verbose=verbose)
eg.evaluate(array_format=format)
if "-graph" in sys.argv:
mod.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=1,
filename_root="simple",
only_warn_on_fail=True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
mod.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=3,
filename_root="simple_3",
only_warn_on_fail=True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
def main():
# changed import call
from modeci_mdf.execution_engine import EvaluableGraph
# Create some test inputs for the model
galaxy_images_output = torch.zeros((1, 5, 64, 64))
ebv_output = torch.zeros((1, ))
# Seed the random number generator to get deterministic behavior for weight initialization
torch.manual_seed(0)
model = InceptionBlocks()
# Turn on eval mode for model to get rid of any randomization due to things like BatchNorm or Dropout
model.eval()
# Run the model once to get some ground truth outpot (from PyTorch)
output = model(galaxy_images_output, ebv_output).detach().numpy()
# Convert to MDF
mdf_model, params_dict = pytorch_to_mdf(
model=model,
args=(galaxy_images_output, ebv_output),
example_outputs=output,
trace=True,
)
# Get the graph
mdf_graph = mdf_model.graphs[0]
# Add inputs to the parameters dict so we can feed this to the EvaluableGraph for initialization of all
# graph inputs.
params_dict["input1"] = galaxy_images_output.numpy()
params_dict["input2"] = ebv_output.numpy()
# Evaluate the model via the MDF scheduler
eg = EvaluableGraph(graph=mdf_graph, verbose=False)
eg.evaluate(initializer=params_dict)
# Make sure the results are the same betweeen PyTorch and MDF
assert np.allclose(
output,
eg.enodes["Add_381"].evaluable_outputs["_381"].curr_value,
)
print("Passed all comparison tests!")
# Output the model to JSON
mdf_model.to_json_file("inception.json")
import sys
if "-graph" in sys.argv:
mdf_model.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=1,
filename_root="inception",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
def main():
verbose = True
dt = 5e-05
file_path = "mlp_pure_mdf.json"
data = convert_states_to_stateful_parameters(file_path, dt)
# print(data)
with open("Translated_" + file_path, "w") as fp:
json.dump(data, fp, indent=4)
test_all = "-test" in sys.argv
mod_graph = load_mdf("Translated_%s" % file_path).graphs[0]
# mdf_to_graphviz(mod_graph,view_on_render=not test_all, level=3)
from modelspec.utils import FORMAT_NUMPY, FORMAT_TENSORFLOW
format = FORMAT_TENSORFLOW if "-tf" in sys.argv else FORMAT_NUMPY
eg = EvaluableGraph(mod_graph, verbose=False)
eg.evaluate(array_format=format)
print("Finished evaluating graph using array format %s" % format)
for n in [
"mlp_input_layer",
"mlp_relu_1",
"mlp_hidden_layer_with_relu",
"mlp_output_layer",
]:
out = eg.enodes[n].evaluable_outputs["out_port"].curr_value
print(f"Final output value of node {n}: {out}, shape: {out.shape}")
if "-graph" in sys.argv:
mod.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=2,
filename_root="mlp_pure_mdf",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
if test_all:
# Iterate on training data, feed forward and log accuracy
imgs = np.load("example_data/imgs.npy")
labels = np.load("example_data/labels.npy")
import torch.nn
matches = 0
imgs_to_test = imgs[:300]
start = time.time()
for i in range(len(imgs_to_test)):
ii = imgs[i, :, :]
target = labels[i]
img = torch.Tensor(ii).view(-1, 14 * 14).numpy()
# plot_img(img, 'Post_%i (%s)'%(i, img.shape))
print("***********\nTesting image %i (label: %s): %s\n%s" %
(i, target, np.array2string(img, threshold=5,
edgeitems=2), img.shape))
# print(mod_graph.nodes[0].parameters['input'])
mod_graph.nodes[0].get_parameter("input").value = img
eg = EvaluableGraph(mod_graph, verbose=False)
eg.evaluate(array_format=format)
for n in ["mlp_output_layer"]:
out = eg.enodes[n].evaluable_outputs["out_port"].curr_value
print("Output of evaluated graph: %s %s (%s)" %
(out, out.shape, type(out).__name__))
prediction = np.argmax(out)
match = target == int(prediction)
if match:
matches += 1
print(
f"Target: {target}, prediction: {prediction}, match: {match}")
t = time.time() - start
print(
"Matches: %i/%i, accuracy: %s%%. Total time: %.4f sec (%.4fs per run)"
% (
matches,
len(imgs_to_test),
(100.0 * matches) / len(imgs_to_test),
t,
t / len(imgs_to_test),
))
def execute(multi=False):
mdf_model = load_mdf("FN.mdf.yaml")
mod_graph = mdf_model.graphs[0]
dt = 0.00005
duration = 0.1
if not multi:
fn_node = mod_graph.nodes[0]
fn_node.get_parameter("initial_v").value = [-1.0]
fn_node.get_parameter("initial_w").value = [0.0]
input = np.array([0])
else:
size = 15
max_amp = 0.5
input = np.array(
[max_amp * (-1 + 2 * i / size) for i in range(size + 1)])
# input = [-0.4,-0.2, 0.,0.2,0.4]
input_node = Node(id="input_node", parameters={"input_level": input})
op1 = OutputPort(id="out_port", value="input_level")
input_node.output_ports.append(op1)
mod_graph.nodes.append(input_node)
fn_node = mod_graph.nodes[0]
fn_node.get_parameter("initial_v").value = np.array([1.0] * len(input))
fn_node.get_parameter("initial_w").value = np.array([0.0] * len(input))
print(fn_node)
e1 = Edge(
id="input_edge",
sender=input_node.id,
sender_port=op1.id,
receiver="FNpop_0",
receiver_port="INPUT",
)
mod_graph.edges.append(e1)
mdf_model.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=3,
filename_root="FNmulti",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
duration = 0.1
eg = EvaluableGraph(mod_graph, verbose)
# duration= 2
t = 0
times = []
vv = {}
ww = {}
format = FORMAT_TENSORFLOW if "-tf" in sys.argv else FORMAT_NUMPY
while t < duration + 0.00005:
times.append(t)
print("====== Evaluating at t = %s ======" % (t))
if t == 0:
eg.evaluate(array_format=format) # replace with initialize?
else:
eg.evaluate(array_format=format, time_increment=dt)
for i in range(
len(eg.enodes["FNpop_0"].evaluable_parameters["V"].curr_value)
):
if not i in vv:
vv[i] = []
ww[i] = []
v = eg.enodes["FNpop_0"].evaluable_parameters["V"].curr_value[i]
w = eg.enodes["FNpop_0"].evaluable_parameters["W"].curr_value[i]
vv[i].append(v)
ww[i].append(w)
if i == 0:
print(f" Value at {t}: v={v}, w={w}")
t += dt
import matplotlib.pyplot as plt
for vi in vv:
plt.plot(times, vv[vi], label="V %.3f" % input[vi])
plt.plot(times, ww[vi], label="W %.3f" % input[vi])
plt.legend()
if not multi:
plt.savefig("MDFFNrun.png", bbox_inches="tight")
if not "-nogui" in sys.argv:
plt.show()
def main():
model = AB()
dummy_input = torch.zeros(2, 3)
output = model(dummy_input)
print(
f"PyTorch model: {model} created. Evaluates {dummy_input} as {output}")
torch.onnx.export(
model,
(dummy_input),
"ab.onnx",
verbose=True,
input_names=["input"],
opset_version=9,
)
# Load it back in using ONNX package
onnx_model = onnx.load("ab.onnx")
onnx.checker.check_model(onnx_model)
import onnxruntime as rt
sess = rt.InferenceSession("ab.onnx")
res = sess.run([sess.get_outputs()[0].name],
{sess.get_inputs()[0].name: dummy_input.numpy()})
print(f"Output calculated by onnxruntime (input: {dummy_input}): {res}")
mdf_model = onnx_to_mdf(onnx_model)
mdf_model.to_json_file("ab.json")
mdf_model.to_yaml_file("ab.yaml")
mdf_model.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=3,
filename_root="ab",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
if "-run" in sys.argv:
verbose = True
verbose = False
from modeci_mdf.execution_engine import EvaluableGraph
eg = EvaluableGraph(mdf_model.graphs[0], verbose=verbose)
print("Evaluating graph...")
test_values = [0, 1, [1, 2], dummy_input.numpy()]
test_values = [0, 1, [1, 2]]
for t in test_values:
print("===================\nEvaluating MDF model with input: %s" %
t)
eg.evaluate(initializer={"input": t})
print("Output: %s" %
eg.enodes["Mul_3"].evaluable_outputs["_4"].curr_value)
def main():
mod = Model(id="abc_conditions")
mod_graph = Graph(id="abc_conditions_example")
mod.graphs.append(mod_graph)
input_node = Node(id="input0")
input_node.parameters.append(Parameter(id="input_level", value=0.0))
input_node.parameters.append(Parameter(id="count_0", value="count_0 + 1"))
op1 = OutputPort(id="out_port")
op1.value = "input_level"
input_node.output_ports.append(op1)
mod_graph.nodes.append(input_node)
def create_simple_node(graph, id_, sender=None):
n = Node(id=id_)
graph.nodes.append(n)
ip1 = InputPort(id="input_port1", shape="(1,)")
n.input_ports.append(ip1)
n.output_ports.append(OutputPort(id="output_1", value=ip1.id))
if sender is not None:
simple_connect(sender, n, graph)
return n
a = create_simple_node(mod_graph, "A", input_node)
a.parameters.append(Parameter(id="count_A", value="count_A + 1"))
b = create_simple_node(mod_graph, "B", a)
b.parameters.append(Parameter(id="count_B", value="count_B + 1"))
c = create_simple_node(mod_graph, "C", a)
c.parameters.append(Parameter(id="count_C", value="count_C+ 1"))
cond_i = Condition(type="BeforeNCalls", dependencies=input_node.id, n=1)
cond_a = Condition(type="Always")
cond_b = Condition(type="EveryNCalls", dependencies=a.id, n=2)
cond_c = Condition(type="EveryNCalls", dependencies=a.id, n=3)
cond_term = Condition(
type="And",
dependencies=[
Condition(type="AfterNCalls", dependencies=c.id, n=2),
Condition(type="JustRan", dependencies=a.id),
],
)
mod_graph.conditions = ConditionSet(
node_specific={
input_node.id: cond_i,
a.id: cond_a,
b.id: cond_b,
c.id: cond_c
},
termination={"environment_state_update": cond_term},
)
mod.to_json_file(
os.path.join(os.path.dirname(__file__), "%s.json" % mod.id))
mod.to_yaml_file(
os.path.join(os.path.dirname(__file__), "%s.yaml" % mod.id))
print_summary(mod_graph)
import sys
if "-run" in sys.argv:
verbose = True
# verbose = False
from modeci_mdf.execution_engine import EvaluableGraph
from modelspec.utils import FORMAT_NUMPY, FORMAT_TENSORFLOW
format = FORMAT_TENSORFLOW if "-tf" in sys.argv else FORMAT_NUMPY
eg = EvaluableGraph(mod_graph, verbose=verbose)
eg.evaluate(array_format=format)
if "-graph" in sys.argv:
mod.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=3,
filename_root="abc_conditions",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
def main():
mod = Model(id="ABCD")
mod_graph = Graph(id="abcd_example")
mod.graphs.append(mod_graph)
input_node = Node(id="input0", metadata={"color": ".8 .8 .8"})
input_node.parameters.append(Parameter(id="input_level", value=0.0))
op1 = OutputPort(id="out_port")
op1.value = "input_level"
input_node.output_ports.append(op1)
mod_graph.nodes.append(input_node)
print(input_node)
print(input_node.output_ports)
# a = create_example_node('A', mod_graph)
a = Node(id="A", metadata={"color": ".8 0 0"})
mod_graph.nodes.append(a)
ip1 = InputPort(id="input_port1")
a.input_ports.append(ip1)
a.parameters.append(Parameter(id="slope", value=abcd.A_slope))
a.parameters.append(Parameter(id="intercept", value=abcd.A_intercept))
f1 = Parameter(
id="linear_func",
function="linear",
args={
"variable0": ip1.id,
"slope": "slope",
"intercept": "intercept"
},
)
a.parameters.append(f1)
a.output_ports.append(OutputPort(id="output_1", value="linear_func"))
e1 = simple_connect(input_node, a, mod_graph)
b = Node(id="B", metadata={"color": "0 .8 0"})
mod_graph.nodes.append(b)
ip1 = InputPort(id="input_port1")
b.input_ports.append(ip1)
b.parameters.append(Parameter(id="gain", value=abcd.B_gain))
b.parameters.append(Parameter(id="bias", value=abcd.B_bias))
b.parameters.append(Parameter(id="offset", value=abcd.B_offset))
f1 = Parameter(
id="logistic_func",
function="logistic",
args={
"variable0": ip1.id,
"gain": "gain",
"bias": "bias",
"offset": "offset"
},
)
b.parameters.append(f1)
b.output_ports.append(OutputPort(id="output_1", value="logistic_func"))
simple_connect(a, b, mod_graph)
c = Node(id="C", metadata={"color": "0 0 .8"})
mod_graph.nodes.append(c)
ip1 = InputPort(id="input_port1", shape="(1,)")
c.input_ports.append(ip1)
c.parameters.append(Parameter(id="scale", value=abcd.C_scale))
c.parameters.append(Parameter(id="rate", value=abcd.C_rate))
c.parameters.append(Parameter(id="bias", value=abcd.C_bias))
c.parameters.append(Parameter(id="offset", value=abcd.C_offset))
f1 = Parameter(
id="exponential_func",
function="exponential",
args={
"variable0": ip1.id,
"scale": "scale",
"rate": "rate",
"bias": "bias",
"offset": "offset",
},
)
c.parameters.append(f1)
c.output_ports.append(OutputPort(id="output_1", value="exponential_func"))
simple_connect(b, c, mod_graph)
d = Node(id="D", metadata={"color": ".8 0 .8"})
mod_graph.nodes.append(d)
ip1 = InputPort(id="input_port1", shape="(1,)")
d.input_ports.append(ip1)
d.parameters.append(Parameter(id="scale", value=abcd.D_scale))
f1 = Parameter(id="sin_func",
function="sin",
args={
"variable0": ip1.id,
"scale": "scale"
})
d.parameters.append(f1)
d.output_ports.append(OutputPort(id="output_1", value="sin_func"))
simple_connect(c, d, mod_graph)
print(mod)
print("------------------")
# print(mod.to_json())
new_file = mod.to_json_file("%s.json" % mod.id)
new_file = mod.to_yaml_file("%s.yaml" % mod.id)
print_summary(mod_graph)
import sys
if "-run" in sys.argv:
verbose = True
# verbose = False
from modeci_mdf.execution_engine import EvaluableGraph
from modelspec.utils import FORMAT_NUMPY, FORMAT_TENSORFLOW
format = FORMAT_TENSORFLOW if "-tf" in sys.argv else FORMAT_NUMPY
eg = EvaluableGraph(mod_graph, verbose=verbose)
eg.evaluate(array_format=format)
if "-graph" in sys.argv:
mod.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=1,
filename_root="abcd",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
mod.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=3,
filename_root="abcd_3",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
def main():
mod = Model(id="Arrays")
mod_graph = Graph(id="array_example")
mod.graphs.append(mod_graph)
input_node = Node(id="input_node")
input_node.parameters.append(
Parameter(id="input_level", value=[[1, 2.0], [3, 4]]))
op1 = OutputPort(id="out_port", value="input_level")
input_node.output_ports.append(op1)
mod_graph.nodes.append(input_node)
middle_node = Node(id="middle_node")
middle_node.parameters.append(Parameter(id="slope", value=0.5))
middle_node.parameters.append(
Parameter(id="intercept", value=np.array([[0, 1.0], [2, 2]])))
ip1 = InputPort(id="input_port1")
middle_node.input_ports.append(ip1)
mod_graph.nodes.append(middle_node)
f1 = Parameter(
id="linear_1",
function="linear",
args={
"variable0": ip1.id,
"slope": "slope",
"intercept": "intercept"
},
)
middle_node.parameters.append(f1)
middle_node.output_ports.append(OutputPort(id="output_1",
value="linear_1"))
e1 = Edge(
id="input_edge",
parameters={"weight": [[1, 0], [0, 1]]},
sender=input_node.id,
sender_port=op1.id,
receiver=middle_node.id,
receiver_port=ip1.id,
)
mod_graph.edges.append(e1)
new_file = mod.to_json_file("%s.json" % mod.id)
new_file = mod.to_yaml_file("%s.yaml" % mod.id)
if "-run" in sys.argv:
verbose = True
# verbose = False
from modeci_mdf.execution_engine import EvaluableGraph
from modelspec.utils import FORMAT_NUMPY, FORMAT_TENSORFLOW
format = FORMAT_TENSORFLOW if "-tf" in sys.argv else FORMAT_NUMPY
eg = EvaluableGraph(mod_graph, verbose=True)
eg.evaluate(array_format=format)
if "-graph" in sys.argv:
mod.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=3,
filename_root="arrays",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
def main():
dt = 5e-05
file_path = "FN.mdf.json"
data = convert_states_to_stateful_parameters("../" + file_path, dt)
# print(data)
with open("Translated_" + file_path, "w") as fp:
json.dump(data, fp, indent=4)
if "-run" in sys.argv:
verbose = True
mod_graph = load_mdf("Translated_%s" % file_path).graphs[0]
eg = EvaluableGraph(mod_graph, verbose)
mod_graph_old = load_mdf("../" + file_path).graphs[0]
eg_old = EvaluableGraph(mod_graph_old, verbose)
duration = 0.1
t = 0
recorded = {}
times = []
s = []
vv = []
ww = []
vv_old = []
ww_old = []
while t <= duration + dt:
print("====== Evaluating at t = %s ======" % (t))
vv.append(
float(
eg.enodes["FNpop_0"].evaluable_parameters["V"].curr_value))
ww.append(
float(
eg.enodes["FNpop_0"].evaluable_parameters["W"].curr_value))
# levels.append(eg.enodes['sine_node'].evaluable_stateful_parameters['level'].curr_value)
# print("time first>>>",type(t))
t = float(
eg.enodes["FNpop_0"].evaluable_parameters["time"].curr_value)
times.append(t)
if t == 0:
eg_old.evaluate() # replace with initialize?
else:
eg_old.evaluate(time_increment=dt)
vv_old.append(
eg_old.enodes["FNpop_0"].evaluable_parameters["V"].curr_value)
ww_old.append(
eg_old.enodes["FNpop_0"].evaluable_parameters["W"].curr_value)
eg.evaluate()
print("Times>>>", times[:10])
print("Translated file W and V>>>", ww[:10], vv[:10])
print("Old file W and V>>>", ww_old[:10], vv_old[:10])
import matplotlib.pyplot as plt
plt.plot(times, vv, label="V")
plt.plot(times, ww, label="W")
plt.legend()
plt.show()
plt.savefig("translated_FN_stateful_vw_plot.jpg")
def main():
mod = Model(id="States")
mod_graph = Graph(id="state_example")
mod.graphs.append(mod_graph)
## Counter node
counter_node = Node(id="counter_node")
p1 = Parameter(id="increment", value=1)
counter_node.parameters.append(p1)
p2 = Parameter(id="count", value="count + increment")
counter_node.parameters.append(p2)
op1 = OutputPort(id="out_port", value=p2.id)
counter_node.output_ports.append(op1)
mod_graph.nodes.append(counter_node)
## Sine node...
sine_node = Node(id="sine_node")
sine_node.parameters.append(Parameter(id="amp", value=3))
sine_node.parameters.append(Parameter(id="period", value=0.4))
s1 = Parameter(id="level",
default_initial_value=0,
time_derivative="6.283185 * rate / period")
sine_node.parameters.append(s1)
s2 = Parameter(
id="rate",
default_initial_value=1,
time_derivative="-1 * 6.283185 * level / period",
)
sine_node.parameters.append(s2)
op1 = OutputPort(id="out_port", value="amp * level")
sine_node.output_ports.append(op1)
mod_graph.nodes.append(sine_node)
new_file = mod.to_json_file("%s.json" % mod.id)
new_file = mod.to_yaml_file("%s.yaml" % mod.id)
if "-run" in sys.argv:
verbose = True
# verbose = False
from modeci_mdf.utils import load_mdf, print_summary
from modeci_mdf.execution_engine import EvaluableGraph
eg = EvaluableGraph(mod_graph, verbose)
dt = 0.01
duration = 2
t = 0
recorded = {}
times = []
s = []
while t <= duration:
times.append(t)
print("====== Evaluating at t = %s ======" % (t))
if t == 0:
eg.evaluate() # replace with initialize?
else:
eg.evaluate(time_increment=dt)
s.append(eg.enodes["sine_node"].evaluable_outputs["out_port"].
curr_value)
t += dt
if "-nogui" not in sys.argv:
import matplotlib.pyplot as plt
plt.plot(times, s)
plt.show()
if "-graph" in sys.argv:
mod.to_graph_image(
engine="dot",
output_format="png",
view_on_render=False,
level=3,
filename_root="states",
only_warn_on_fail=
True, # Makes sure test of this doesn't fail on Windows on GitHub Actions
)
return mod_graph