def _get_loss(event_file): with open(event_file, 'rb') as stream: while True: header = stream.read(8) if not header: break header_crc, = struct.unpack('I', stream.read(4)) assert masked_crc32c(header) == header_crc str_len, = struct.unpack('Q', header) event_str = stream.read(str_len) body_crc, = struct.unpack('I', stream.read(4)) assert masked_crc32c(event_str) == body_crc event = event_pb2.Event() event.ParseFromString(event_str) if len(event.summary.value) > 0: value = event.summary.value[0] if value.tag == 'best_loss': return event.step, value.simple_value raise AssertionError('could not find "loss" value in event file: ' + event_file)
def test_event_file_writer_roundtrip(self): _TAGNAME = 'dummy' _DUMMY_VALUE = 42 logdir = self.get_temp_dir() w = EventFileWriter(logdir) summary = Summary( value=[Summary.Value(tag=_TAGNAME, simple_value=_DUMMY_VALUE)]) fakeevent = event_pb2.Event(summary=summary) w.add_event(fakeevent) w.close() event_files = sorted(glob.glob(os.path.join(logdir, '*'))) self.assertEqual(len(event_files), 1) r = PyRecordReader_New(event_files[0]) r.GetNext() # meta data, so skip r.GetNext() self.assertEqual(fakeevent.SerializeToString(), r.record())
def _read_event(self): # Read the header which tells the length of the event string header_str = self._buf[self._index:self._index + 8] header = struct.unpack('Q', header_str) self._index += 12 # Read the event string header_len = int(header[0]) event_str = self._buf[self._index:self._index + header_len] self._index += (header_len + 4) # Parse event string ev = event_pb2.Event() try: ev.ParseFromString(event_str) except: raise return ev
def test_writer(self): TEST_LEN = 100 N_PROC = 4 writer = SummaryWriter() event_filename = writer.file_writer.event_writer._ev_writer._file_name predifined_values = list(range(TEST_LEN)) def train3(): for i in range(TEST_LEN): writer.add_scalar('many_write_in_func', predifined_values[i]) time.sleep(0.01 * np.random.randint(0, 10)) processes = [] for i in range(N_PROC): p1 = mp.Process(target=train3) processes.append(p1) p1.start() for p in processes: p.join() writer.close() collected_values = [] r = PyRecordReader_New(event_filename) r.GetNext() # meta data, so skip for _ in range(TEST_LEN * N_PROC): # all of the data should be flushed r.GetNext() ev = event_pb2.Event() value = ev.FromString(r.record()).summary.value collected_values.append(value[0].simple_value) collected_values = sorted(collected_values) for i in range(TEST_LEN): for j in range(N_PROC): assert collected_values[i * N_PROC + j] == i
def from_variable(self, leaf, output_name="output"): def parse_variable(v, var_num): def add_variable(v, v_idx): v_name = parameters.get(v.data, None) exist = False if not v_name: v_name, exist = get_variable_name(v, v_idx) if not exist: shape_proto = TensorShapeProto( dim=[TensorShapeProto.Dim(size=d) for d in v.shape]) if v.parent is None: inputs = [] else: inputs = [get_func_name(v.parent)] # print("Variable: {}:{}".format(v_name, inputs)) nodes.append(NodeDef( name=v_name.encode(encoding='utf-8'), op='Variable', input=inputs, attr={ 'shape': AttrValue(shape=shape_proto), 'dtype': AttrValue(type=DT_FLOAT) } )) return v_name def get_unique_variable_name(v_name_base): v_num = 0 v_name = v_name_base + str(v_num) while v_name in unique_var_names: v_num += 1 v_name = v_name_base + str(v_num) unique_var_names.add(v_name) return v_name def get_variable_name(v, v_idx): v_name = variables.get(v, None) if v_name: return v_name, True else: if v.parent is None: v_name_base = "Input" v_name = get_unique_variable_name(v_name_base) elif not nodes: v_name = output_name else: f_name_sections = get_func_name(v.parent).split("/") f_name = f_name_sections[-1] f_scope = f_name_sections[:-1] base_name = "variable<-{}".format(f_name) v_name_base = "/".join(f_scope + [base_name]) v_name = get_unique_variable_name(v_name_base) variables[v] = v_name return v_name, False def get_func_name(func): func_name = func_names.get(func, None) if func_name: return func_name name_scope = loc_var['name_scope'] for v in func.inputs: v_name = self.parameters.get(v.data, None) if v_name: name_scope = '/'.join(v_name.split('/')[:-1]) break if name_scope: func_name_base = '/'.join([name_scope, func.name]) else: func_name_base = func.name func_num = 0 func_name = func_name_base + str(func_num) while func_name in unique_func_names: func_num += 1 func_name = func_name_base + str(func_num) unique_func_names.add(func_name) func_names[func] = func_name return func_name def add_func(v): input_names = [] for index, v_input in enumerate(v.parent.inputs): v_name = add_variable(v_input, index) input_names.append(v_name) # print("Function: {}:{}".format(get_func_name(v.parent), input_names)) f_name = get_func_name(v.parent) if f_name in func_set: return False attrs = [] for k, a in v.parent.info.args.items(): attr = "{}={}".format(k, a) attrs.append(attr) attr_str = ','.join(attrs).encode(encoding='utf-8') nodes.append(NodeDef( name=f_name, op=v.parent.info.type_name, input=input_names, attr={"parameters": AttrValue(s=attr_str)} )) func_set.add(f_name) return True name_scope = loc_var['name_scope'] if not nodes: add_variable(v, var_num) if v.parent is None: add_variable(v, var_num) else: if not add_func(v): return for idx, in_var in enumerate(v.parent.inputs): name_scope_stack.append(name_scope) parse_variable(in_var, idx) name_scope = name_scope_stack.pop() nodes = [] variables = {} loc_var = {} loc_var['name_scope'] = '' name_scope_stack = [] func_names = {} func_set = set() unique_func_names = set() unique_var_names = set() parameters = {v.data: k for k, v in get_parameters(grad_only=False).items()} parse_variable(leaf, 0) nodes = nodes[::-1] current_graph = GraphDef(node=nodes, versions=VersionDef(producer=22)) event = event_pb2.Event( graph_def=current_graph.SerializeToString()) self.file_writer.add_event(event)
def from_graph_def(self, graph_def): variables = graph_def.variables parameters = graph_def.parameters functions = graph_def.functions inputs = graph_def.inputs nodes = [] scope = {} for n, v in parameters.items(): shape_proto = TensorShapeProto( dim=[TensorShapeProto.Dim(size=d) for d in v.shape]) node = NodeDef( name=n.encode(encoding='utf-8'), op='Parameter', input=[], attr={ 'shape': AttrValue(shape=shape_proto), 'dtype': AttrValue(type=DT_FLOAT) } ) nodes.append(node) scope[n] = node for n, v in inputs.items(): shape_proto = TensorShapeProto( dim=[TensorShapeProto.Dim(size=d) for d in v.shape]) nodes.append(NodeDef( name=n.encode(encoding='utf-8'), op='Variable', input=[], attr={ 'shape': AttrValue(shape=shape_proto), 'dtype': AttrValue(type=DT_FLOAT) } )) for func_name, func in functions.items(): for o in func['outputs']: if o in scope: node = scope[o] node.input.extend([func_name]) else: if o in variables: v = variables[o] shape_proto = TensorShapeProto( dim=[TensorShapeProto.Dim(size=d) for d in v.shape]) node = NodeDef( name=o.encode(encoding='utf-8'), op='Variable', input=[func_name], attr={ 'shape': AttrValue(shape=shape_proto), 'dtype': AttrValue(type=DT_FLOAT) } ) nodes.append(node) for i in func['inputs']: if i in variables: v = variables[i] shape_proto = TensorShapeProto( dim=[TensorShapeProto.Dim(size=d) for d in v.shape]) node = NodeDef( name=o.encode(encoding='utf-8'), op='Variable', input=[], attr={ 'shape': AttrValue(shape=shape_proto), 'dtype': AttrValue(type=DT_FLOAT) } ) nodes.append(node) scope[o] = node nodes.append(NodeDef( name=func_name, op=func['type'], input=func['inputs'], attr={"arguments": AttrValue(s='a=1'.encode(encoding='utf-8'))} )) current_graph = GraphDef(node=nodes, versions=VersionDef(producer=22)) event = event_pb2.Event( graph_def=current_graph.SerializeToString()) self.file_writer.add_event(event)