Lines Matching refs:self

34     def __init__(self, name, dtype, dims):
35 self.name = name
36 self.dtype = dtype
37 self.dims = dims
38 self.iotype = 0
39 self.used_count = 0
40 self.index = Operand.index
42 self.iotype2str = {Operand.IOTYPE_INPUT: 'in', Operand.IOTYPE_OUTPUT: 'out', Operand.IOTYPE_INTERMEDIATE: 'inout'}
43 self.dtype2str = {Operand.DTYPE_FLOAT: 'DT_FLOAT', Operand.DTYPE_UINT8: 'DT_UINT8'}
45 def add_iotype(self, iotype):
46 self.iotype = self.iotype | iotype
48 self.used_count = self.used_count + 1
50 def __str__(self):
51 return "{}: (name: {}, iotype: {}, dtype: {}, dims: {}, used_count: {})".format(self.index,
52 self.name, self.iotype2str[self.iotype], self.dtype2str[self.dtype],
53 self.dims, self.used_count)
55 def __lt__(self, other):
56 return self.index < other.index
59 def __init__(self, graph_def, nodes, outfile, dump4tb):
60 self.graph_def = graph_def
61 self.nodes = nodes
62 self.outfile = outfile
63 self.dump4tb = dump4tb
64 self.layer_number = 0
65 self.output_names = []
66 self.name_node_dict = {}
67 self.edges = {}
68 self.conv_activations = {'Relu':0, 'Tanh':1, 'Sigmoid':2, 'None':3, 'LeakyRelu':4}
69 self.conv_paddings = {'VALID':0, 'SAME':1}
70 self.pool_paddings = {'VALID':0, 'SAME':1}
71 self.converted_nodes = set()
72 self.conv2d_scope_names = set()
73 self.conv2d_scopename_inputname_dict = {}
74 self.dense_scope_names = set()
75 self.dense_scopename_inputname_dict = {}
76 self.op2code = {'Conv2D':1, 'DepthToSpace':2, 'MirrorPad':3, 'Maximum':4,
78 self.mathbin2code = {'Sub':0, 'Add':1, 'Mul':2, 'RealDiv':3, 'Minimum':4, 'FloorMod':5}
79 self.mathun2code = {'Abs':0, 'Sin':1, 'Cos':2, 'Tan':3, 'Asin':4,
83 self.mirrorpad_mode = {'CONSTANT':0, 'REFLECT':1, 'SYMMETRIC':2}
84 self.name_operand_dict = {}
87 def add_operand(self, name, type):
88 node = self.name_node_dict[name]
89 if name not in self.name_operand_dict:
100 self.name_operand_dict[name] = operand;
101 self.name_operand_dict[name].add_iotype(type)
102 return self.name_operand_dict[name].index
105 def dump_for_tensorboard(self):
107 tf.import_graph_def(self.graph_def, name="")
112 def get_conv2d_params(self, conv2d_scope_name):
113 knode = self.name_node_dict[conv2d_scope_name + '/kernel']
114 bnode = self.name_node_dict[conv2d_scope_name + '/bias']
116 if conv2d_scope_name + '/dilation_rate' in self.name_node_dict:
117 dnode = self.name_node_dict[conv2d_scope_name + '/dilation_rate']
123 if conv2d_scope_name + '/BiasAdd' in self.edges:
124 anode = self.edges[conv2d_scope_name + '/BiasAdd'][0]
125 if anode.op not in self.conv_activations:
132 def get_dense_params(self, dense_scope_name):
133 knode = self.name_node_dict[dense_scope_name + '/kernel']
134 bnode = self.name_node_dict.get(dense_scope_name + '/bias')
139 if dense_scope_name + '/BiasAdd' in self.edges:
140 anode = self.edges[dense_scope_name + '/BiasAdd'][0]
141 if anode.op not in self.conv_activations:
148 def dump_complex_conv2d_to_file(self, node, f):
150 self.layer_number = self.layer_number + 1
151 self.converted_nodes.add(node.name)
155 knode, bnode, dnode, anode = self.get_conv2d_params(scope_name)
169 if dilation > 1 and scope_name + '/stack' in self.name_node_dict:
170 if self.name_node_dict[scope_name + '/stack'].op == "Const":
172 padding = self.conv_paddings[padding]
184 np.array([self.op2code[node.op], dilation, padding, self.conv_activations[activation], in_channels, out_channels, filter_height, has_bias], dtype=np.uint32).tofile(f)
194 input_name = self.conv2d_scopename_inputname_dict[scope_name]
195 input_operand_index = self.add_operand(input_name, Operand.IOTYPE_INPUT)
198 output_operand_index = self.add_operand(anode.name, Operand.IOTYPE_OUTPUT)
200 output_operand_index = self.add_operand(self.edges[bnode.name][0].name, Operand.IOTYPE_OUTPUT)
203 def dump_dense_to_file(self, node, f):
205 self.layer_number = self.layer_number + 1
206 self.converted_nodes.add(node.name)
210 knode, bnode, anode = self.get_dense_params(scope_name.split('/')[0])
237 np.array([self.op2code[node.op], self.conv_activations[activation], in_channels, out_channels, has_bias], dtype=np.uint32).tofile(f)
242 input_name = self.dense_scopename_inputname_dict[scope_name.split('/')[0]]
243 input_operand_index = self.add_operand(input_name, Operand.IOTYPE_INPUT)
246 output_operand_index = self.add_operand(anode.name, Operand.IOTYPE_OUTPUT)
249 output_operand_index = self.add_operand(self.edges[bnode.name][0].name, Operand.IOTYPE_OUTPUT)
251 output_operand_index = self.add_operand(self.edges[scope_name+'/concat_1'][0].name, Operand.IOTYPE_OUTPUT)
255 def dump_simple_conv2d_to_file(self, node, f):
257 self.layer_number = self.layer_number + 1
258 self.converted_nodes.add(node.name)
260 node0 = self.name_node_dict[node.input[0]]
261 node1 = self.name_node_dict[node.input[1]]
284 np.array([self.op2code[node.op], dilation, self.conv_paddings[padding], self.conv_activations['None'],
288 input_operand_index = self.add_operand(input_name, Operand.IOTYPE_INPUT)
289 output_operand_index = self.add_operand(node.name, Operand.IOTYPE_OUTPUT)
293 def dump_depth2space_to_file(self, node, f):
295 self.layer_number = self.layer_number + 1
297 np.array([self.op2code[node.op], block_size], dtype=np.uint32).tofile(f)
298 self.converted_nodes.add(node.name)
299 input_operand_index = self.add_operand(node.input[0], Operand.IOTYPE_INPUT)
300 output_operand_index = self.add_operand(node.name, Operand.IOTYPE_OUTPUT)
304 def dump_mirrorpad_to_file(self, node, f):
306 self.layer_number = self.layer_number + 1
308 mode = self.mirrorpad_mode[mode.decode("utf-8")]
309 np.array([self.op2code[node.op], mode], dtype=np.uint32).tofile(f)
310 pnode = self.name_node_dict[node.input[1]]
311 self.converted_nodes.add(pnode.name)
314 self.converted_nodes.add(node.name)
315 input_operand_index = self.add_operand(node.input[0], Operand.IOTYPE_INPUT)
316 output_operand_index = self.add_operand(node.name, Operand.IOTYPE_OUTPUT)
320 def dump_maximum_to_file(self, node, f):
322 self.layer_number = self.layer_number + 1
323 ynode = self.name_node_dict[node.input[1]]
325 np.array([self.op2code[node.op]], dtype=np.uint32).tofile(f)
327 self.converted_nodes.add(node.name)
328 input_operand_index = self.add_operand(node.input[0], Operand.IOTYPE_INPUT)
329 output_operand_index = self.add_operand(node.name, Operand.IOTYPE_OUTPUT)
333 def dump_mathbinary_to_file(self, node, f):
334 self.layer_number = self.layer_number + 1
335 self.converted_nodes.add(node.name)
336 i0_node = self.name_node_dict[node.input[0]]
337 i1_node = self.name_node_dict[node.input[1]]
338 np.array([self.op2code['MathBinary'], self.mathbin2code[node.op]], dtype=np.uint32).tofile(f)
344 input_operand_index = self.add_operand(i1_node.name, Operand.IOTYPE_INPUT)
349 input_operand_index = self.add_operand(i0_node.name, Operand.IOTYPE_INPUT)
355 input_operand_index = self.add_operand(i0_node.name, Operand.IOTYPE_INPUT)
358 input_operand_index = self.add_operand(i1_node.name, Operand.IOTYPE_INPUT)
360 output_operand_index = self.add_operand(node.name, Operand.IOTYPE_OUTPUT)
364 def dump_mathunary_to_file(self, node, f):
365 self.layer_number = self.layer_number + 1
366 self.converted_nodes.add(node.name)
367 i0_node = self.name_node_dict[node.input[0]]
368 np.array([self.op2code['MathUnary'], self.mathun2code[node.op]], dtype=np.uint32).tofile(f)
369 input_operand_index = self.add_operand(i0_node.name, Operand.IOTYPE_INPUT)
371 output_operand_index = self.add_operand(node.name, Operand.IOTYPE_OUTPUT)
375 def dump_avg_pool_to_file(self, node, f):
377 self.layer_number = self.layer_number + 1
378 self.converted_nodes.add(node.name)
379 node0 = self.name_node_dict[node.input[0]]
398 np.array([self.op2code[node.op], strides, self.pool_paddings[padding], filter_height],
401 input_operand_index = self.add_operand(input_name, Operand.IOTYPE_INPUT)
402 output_operand_index = self.add_operand(node.name, Operand.IOTYPE_OUTPUT)
406 def dump_layers_to_file(self, f):
407 for node in self.nodes:
408 if node.name in self.converted_nodes:
412 if self.in_conv2d_scope(node.name):
414 self.dump_complex_conv2d_to_file(node, f)
416 if self.in_dense_scope(node.name):
418 self.dump_dense_to_file(node, f)
423 self.dump_simple_conv2d_to_file(node, f)
425 if node.name in self.output_names:
426 input_name = self.id_different_scope_dict[node.name]
430 self.dump_avg_pool_to_file(node, f)
432 self.dump_depth2space_to_file(node, f)
434 self.dump_mirrorpad_to_file(node, f)
436 self.dump_maximum_to_file(node, f)
437 elif node.op in self.mathbin2code:
438 self.dump_mathbinary_to_file(node, f)
439 elif node.op in self.mathun2code:
440 self.dump_mathunary_to_file(node, f)
443 def dump_operands_to_file(self, f):
444 operands = sorted(self.name_operand_dict.values())
453 def dump_to_file(self):
454 with open(self.outfile, 'wb') as f:
457 self.dump_layers_to_file(f)
458 self.dump_operands_to_file(f)
459 np.array([self.layer_number, len(self.name_operand_dict)], dtype=np.uint32).tofile(f)
462 def generate_name_node_dict(self):
463 for node in self.nodes:
464 self.name_node_dict[node.name] = node
467 def generate_output_names(self):
469 for node in self.nodes:
473 for node in self.nodes:
475 self.output_names.append(node.name)
478 def remove_identity(self):
479 self.id_different_scope_dict = {}
482 for node in self.nodes:
488 if name in self.output_names:
489 self.name_node_dict[input].name = name
490 self.name_node_dict[name] = self.name_node_dict[input]
491 del self.name_node_dict[input]
492 self.id_different_scope_dict[name] = input
497 self.nodes.remove(idnode)
499 for node in self.nodes:
506 def generate_edges(self):
507 for node in self.nodes:
509 if input in self.edges:
510 self.edges[input].append(node)
512 self.edges[input] = [node]
523 def in_conv2d_scope(self, name):
527 for scope in self.conv2d_scope_names:
534 def in_dense_scope(self, name):
538 for scope in self.dense_scope_names:
544 def generate_sub_block_op_scope_info(self):
546 for node in self.nodes:
553 if scope + '/kernel' not in self.name_node_dict:
555 self.conv2d_scope_names.add(scope)
562 if scope + '/kernel' not in self.name_node_dict and scope.split('/Tensordot')[0] + '/kernel' not in self.name_node_dict:
564 self.dense_scope_names.add(scope.split('/Tensordot')[0])
567 for node in self.nodes:
569 if scope in self.conv2d_scope_names:
573 self.conv2d_scopename_inputname_dict[scope] = inp
574 elif scope in self.dense_scope_names:
578 self.dense_scopename_inputname_dict[scope] = inp
579 elif scope.split('/Tensordot')[0] in self.dense_scope_names:
583 self.dense_scopename_inputname_dict[scope.split('/Tensordot')[0]] = inp
586 def run(self):
587 self.generate_name_node_dict()
588 self.generate_output_names()
589 self.remove_identity()
590 self.generate_edges()
591 self.generate_sub_block_op_scope_info()
593 if self.dump4tb:
594 self.dump_for_tensorboard()
596 self.dump_to_file()