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_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_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():
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():
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 mdf_to_onnx(mdf_model):
"""
Takes an MDF model object and returns a list of ONNX models for each graph in the model.
"""
# An MDF model can have multiple graphs. Each graph will be an onnx model
onnx_models = []
for graph in mdf_model.graphs:
print("Processing Graph ", graph.id)
# Use edges and nodes to construct execution order
nodenames_in_execution_order = []
evaluable_graph = EvaluableGraph(graph, verbose=False)
for idx, edge in enumerate(evaluable_graph.ordered_edges):
if idx == 0:
nodenames_in_execution_order.append(edge.sender)
nodenames_in_execution_order.append(edge.receiver)
# print(nodenames_in_execution_order, graph.nodes, graph.edges)
# Generate onnx graph
onnx_graph = generate_onnx_graph(graph, nodenames_in_execution_order)
# Make an onnx model from graph
onnx_model = helper.make_model(onnx_graph)
# Infer shapes
onnx_model = shape_inference.infer_shapes(onnx_model)
# Check model
onnx.checker.check_model(onnx_model)
onnx_models.append(onnx_model)
return onnx_models
def _generate_scripts_from_json(model_input):
"""
Helper function to parse MDF objects from MDF json representation as well
as load the h5 weights for large weight matrices. Uses MDF scheduler to
determine proper ordering of nodes, and calls `build_script`.
Returns dictionary of scripts where key = name of mdf model, value is string
representation of script.
"""
file_dir = os.path.dirname(model_input)
model = load_mdf(model_input)
scripts = {}
for graph in model.graphs:
nodes = graph.nodes
# Read weights.h5 if exists
if "weights.h5" in os.listdir(file_dir):
weight_dict = h5py.File(os.path.join(file_dir, "weights.h5"), "r")
# Hack to fix problem with HDF5 parameters
for node in graph.nodes:
if node.parameters:
for param in node.parameters:
param_key = param.id
param_val = param.value
if param_key in ["weight", "bias"
] and type(param_val) == str:
# Load and reassign
array = weight_dict[param_val][:]
# np.set_printoptions(threshold=sys.maxsize)
param.value = array
evaluable_graph = EvaluableGraph(graph, verbose=False)
enodes = evaluable_graph.enodes
edges = evaluable_graph.ordered_edges
try:
conditions = evaluable_graph.conditions
except AttributeError:
conditions = {}
# Use edges and nodes to construct execution order
execution_order = []
for idx, edge in enumerate(edges):
if idx == 0:
execution_order.append(edge.sender)
execution_order.append(edge.receiver)
# Build script
script = build_script(nodes, execution_order, conditions=conditions)
scripts[graph.id] = script
return scripts
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():
# 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():
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():
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="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
)
"value": "logistic_1"
}
}
}
},
"edges": {
"input_edge": {
"parameters": {
"weight": 0.55
},
"sender": "input_node",
"receiver": "processing_node",
"sender_port": "out_port",
"receiver_port": "input_port1"
}
}
}
}
}
}"""
)
model = Model()
model = _parse_element(data, model)
print("----")
print(model)
graph = model.graphs[0]
egraph = EvaluableGraph(graph, False)
###### TODO: update WebGME import to handle post https://github.com/ModECI/MDF/issues/101 changes!
result = graph # DeepForge requires the concept of interest to be available as "result"
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
