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))