def main(args):
graph = ts.new_graph()
input_size = tuple([int(x) for x in args.input_size.split('x')])
input = graph.new_input(dims=input_size)
all_w = create_layer_weights(graph, NUM_LAYERS, args.channels)
all_arcs = parse_arcs(args.input_file)
if args.num_models is not None:
all_arcs = all_arcs[:args.num_models]
# stem conv
t = graph.conv2d(input=input,
weight=graph.new_weight(dims=(args.channels, input.dim(1),
1, 1)),
strides=(1, 1),
padding="SAME",
activation="RELU")
for arc in all_arcs:
create_architecture(arc, graph, t, all_w)
if args.save_models:
onnx_model = ts.export_onnx(graph)
onnx.save(onnx_model, 'original_model.onnx')
new_graph = ts.optimize(graph, alpha=1.0, budget=1000)
if args.save_models:
onnx_model = ts.export_onnx(new_graph)
onnx.save(onnx_model, 'optimized_model.onnx')
def main(args):
graph = ts.new_graph()
input_size = tuple([int(x) for x in args.input_size.split('x')])
input = graph.new_input(dims=input_size)
shared_resnet_model(graph, input, args.num_models, args.num_shared_blocks)
if args.save_graphs:
original_model = ts.export_onnx(graph)
onnx.save(original_model, 'original_model.onnx')
new_graph = ts.optimize(graph, alpha=1.0, budget=1000)
if args.save_graphs:
optimized_model = ts.export_onnx(new_graph)
onnx.save(optimized_model, 'optimized_model.onnx')
def graph_ios2taso(graph: Graph, batch_size):
"""
Convert an IOS computation graph to TASO computation graph with given batch size.
:param graph: ios.ir.Graph
IOS computation graph.
:param batch_size:
Batch size that is used in the TASO computation graph.
:return: taso.Graph
The equivalent TASO computation graph to IOS's.
"""
node2var = {}
tg = taso.new_graph()
for node in graph.nodes():
if node is graph.enter_node:
node2var[node] = tg.new_input(dims=(batch_size,
*node.output_shape))
else:
term_vars = []
for term in node.inputs:
value_vars = []
for value in term:
if value.begin == 0 and value.end == value.node.output_shape[
0]:
var = node2var[value.node]
else:
raise NotImplementedError
value_vars.append(var)
term_var = value_vars[0]
for value_var in value_vars[1:]:
if isinstance(node, Element):
if node.op_type == 'mul':
term_var = tg.mul(term_var, value_var)
elif node.op_type == 'add':
term_var = tg.add(term_var, value_var)
else:
raise ValueError
else:
term_var = tg.add(term_var, value_var)
term_vars.append(term_var)
if len(term_vars) > 1:
x = tg.concat(1, term_vars)
else:
x = term_vars[0]
node2var[node] = do_layer(x, node, tg)
x = node2var[graph.exit_node]
return tg
def inception_v3(batch_size=1):
graph = taso.new_graph()
v = graph.new_input(dims=(batch_size, 3, 299, 299))
v = inception_front(graph, v)
v = inception_a(graph, v, 32)
v = inception_a(graph, v, 64)
v = inception_a(graph, v, 64)
v = inception_b(graph, v)
v = inception_c(graph, v, 128)
v = inception_c(graph, v, 160)
v = inception_c(graph, v, 160)
v = inception_c(graph, v, 192)
v = inception_d(graph, v)
v = inception_e(graph, v)
v = inception_e(graph, v)
v = inception_logits(graph, v)
return graph
DEFAULT_MODEL_PATH = Path("/home/groups/aaiken/unger/models/resnext50")
if __name__ == '__main__':
import argparse
p = argparse.ArgumentParser()
p.add_argument("batch_size", type=int)
p.add_argument("--output-dir", "-o", type=Path, default=DEFAULT_MODEL_PATH)
p.add_argument("--export", action="store_true", default=False)
p.add_argument("--print-subst", action="store_true", default=False)
p.add_argument("--budget", "-b", default=100, type=int)
p.add_argument("--alpha", default=1.05, type=float)
p.add_argument("--debug-dir", "-d", type=Path, default=None)
args = p.parse_args()
batch_size = args.batch_size
graph = ts.new_graph()
input = graph.new_input(dims=(batch_size, 3, 224, 224))
weight = graph.new_weight(dims=(64, 3, 7, 7))
t = graph.conv2d(input=input,
weight=weight,
strides=(2, 2),
padding="SAME",
activation="RELU")
t = graph.maxpool2d(input=t,
kernels=(3, 3),
strides=(2, 2),
padding="SAME")
for i in range(3):
t = resnext_block(graph, t, (1, 1), 128, 32)
strides = (2, 2)
for i in range(4):
def nas_node(graph, input, x):
t = list()
for i in range(8):
t.append(combine(graph, x, input))
midt = list()
midt.append(graph.add(graph.relu(t[0]), graph.sigmoid(t[3])))
midt.append(graph.add(graph.sigmoid(t[1]), graph.tanh(t[2])))
midt.append(graph.mul(graph.sigmoid(t[4]), graph.tanh(t[5])))
midt.append(graph.mul(graph.sigmoid(t[6]), graph.relu(t[7])))
midt.append(graph.add(graph.sigmoid(midt[1]), graph.tanh(midt[2])))
midt.append(graph.mul(graph.tanh(midt[0]), graph.tanh(midt[3])))
midt.append(graph.mul(graph.tanh(midt[4]), graph.tanh(midt[5])))
return graph.tanh(midt[6])
graph = taso.new_graph()
xs = list()
for i in range(length):
xs.append(graph.new_input(dims=(1, hidden_size)))
state = graph.new_weight(dims=(1, hidden_size))
for i in range(length):
state = nas_node(graph, state, xs[i])
old_time = graph.run_time()
new_graph = taso.optimize(graph, alpha=1.0, budget=100)
new_time = new_graph.run_time()
print("Run time of original graph is: {}".format(old_time))
print("Run time of optimized graph is: {}".format(new_time))
