def BinaryData_Disparity_Single(net, **kwargs): ''' @brief Setup network inputs for disparity @returns A two-element list of single-blob network INPUT and LABEL ''' samples = [] if kwargs['rendertype'] == 'CLEAN' or kwargs['rendertype'] == 'BOTH': samples += (Sample((Entry('cleanImageL', 0), Entry('cleanImageR', 0), Entry('dispL', 0))), ) if kwargs['rendertype'] == 'FINAL' or kwargs['rendertype'] == 'BOTH': samples += (Sample((Entry('finalImageL', 0), Entry('finalImageR', 0), Entry('dispL', 0))), ) nout = NumberOfEntries(samples) if 'output_index' in kwargs: nout += 1 del kwargs['output_index'] return Layers.BinaryData( net, nout=nout, include=(Proto.NetStateRule(phase=kwargs['phase']), ), data_param=DataParams(samples, **kwargs))
def BinaryData_SceneFlow_Single_Reduced(net, **kwargs): ''' @brief Setup network inputs for scene flow @returns A list of single-blob network INPUT and LABEL ''' samples = [] if kwargs['rendertype'] == 'CLEAN' or kwargs['rendertype'] == 'BOTH': samples += (Sample( (Entry('cleanImageL', 0), Entry('cleanImageR', 0), Entry('cleanImageL', +1), Entry('cleanImageR', +1), Entry('forwardFlowL', 0), Entry('dispL', 0), Entry('forwardDispChangeL', 0))), ) if kwargs['rendertype'] == 'FINAL' or kwargs['rendertype'] == 'BOTH': samples += (Sample( (Entry('finalImageL', 0), Entry('finalImageR', 0), Entry('finalImageL', +1), Entry('finalImageR', +1), Entry('forwardFlowL', 0), Entry('dispL', 0), Entry('forwardDispChangeL', 0))), ) nout = NumberOfEntries(samples) if 'output_index' in kwargs: nout += 1 del kwargs['output_index'] blobs = Layers.BinaryData( net, nout=nout, include=(Proto.NetStateRule(phase=kwargs['phase']), ), data_param=DataParams(samples, **kwargs)) if kwargs['return_struct']: return _dataStructFromSceneFlow2(blobs) else: return blobs
def dropout(pytorch_layer): layer = pb2.LayerParameter() layer.type = "Dropout" layer.dropout_param.dropout_ratio = float(pytorch_layer.p) train_only = pb2.NetStateRule() train_only.phase = pb2.TEST layer.exclude.extend([train_only]) return layer
def _get_include(phase): inc = caffe_pb2.NetStateRule() if phase == 'train': inc.phase = caffe_pb2.TRAIN elif phase == 'test': inc.phase = caffe_pb2.TEST else: raise ValueError("Unknown phase {}".format(phase)) return inc
def dropout(torch_layer): # Only run dropout layer = pb2.LayerParameter() layer.type = "Dropout" layer.dropout_param.dropout_ratio = torch_layer["p"] #assert torch_layer["v2"], "Only handle nn.Dropout v2" train_only = pb2.NetStateRule() train_only.phase = pb2.TEST layer.exclude.extend([train_only]) return layer
def add_accuracy_layer(net_msg,bottom): accuracy_layer = net_msg.layer.add() accuracy_layer.name = 'accuracy' accuracy_layer.type = 'Accuracy' accuracy_layer.bottom._values.append(bottom) accuracy_layer.bottom._values.append('label') accuracy_layer.top._values.append('accuracy') include_param = caffe_pb2.NetStateRule() include_param.phase = caffe_pb2.TEST accuracy_layer.include._values.append(include_param)
def BinaryData_OpticalFlow(net, **kwargs): ''' @brief Setup network inputs for optical flow @returns A list of single-blob network INPUT and LABEL ''' samples = [] if kwargs['rendertype'] == 'CLEAN' or kwargs['rendertype'] == 'BOTH': samples += (Sample((Entry('cleanImageL', 0), Entry('cleanImageL', +1), Entry('forwardFlowL', 0))), Sample((Entry('cleanImageL', 0), Entry('cleanImageL', -1), Entry('backwardFlowL', 0))), Sample((Entry('cleanImageR', 0), Entry('cleanImageR', +1), Entry('forwardFlowR', 0))), Sample((Entry('cleanImageR', 0), Entry('cleanImageR', -1), Entry('backwardFlowR', 0)))) if kwargs['rendertype'] == 'FINAL' or kwargs['rendertype'] == 'BOTH': samples += (Sample((Entry('finalImageL', 0), Entry('finalImageL', +1), Entry('forwardFlowL', 0))), Sample((Entry('finalImageL', 0), Entry('finalImageL', -1), Entry('backwardFlowL', 0))), Sample((Entry('finalImageR', 0), Entry('finalImageR', +1), Entry('forwardFlowR', 0))), Sample((Entry('finalImageR', 0), Entry('finalImageR', -1), Entry('backwardFlowR', 0)))) nout = NumberOfEntries(samples) if 'output_index' in kwargs: nout += 1 del kwargs['output_index'] return Layers.BinaryData( net, nout=nout, include=(Proto.NetStateRule(phase=kwargs['phase']), ), data_param=DataParams(samples, **kwargs))
def inputConvert(layer, net, sol): # add layer to caffe net alayer = net.layer.add() # layer checkpoint setting alayer.name = layer["name"] # name alayer.type = "Data" # type alayer.top.extend(["data"]) # top # need to be considered???????????? alayer.top.extend(["label"]) # top # need to be considered???????????? # include{ phase } if "option" in layer["attributes"]: temp = caffe_pb2.NetStateRule() if layer["attributes"]["option"].lower() == "datasets": temp.phase = 0 elif layer["attributes"]["option"].lower() == "test": temp.phase = 1 alayer.include.extend([temp]) # data_param{} # source if "train_data" in layer["attributes"]: alayer.data_param.source = layer["attributes"]["train_data"] # batch_size if "batch_size" in layer["attributes"]: alayer.data_param.batch_size = layer["attributes"]["batch_size"] # solver checkpoint setting # solver_mode if "mode" in layer["attributes"]: if layer["attributes"]["mode"].lower() == "cpu": sol.solver_mode = 0 elif layer["attributes"]["mode"].lower() == "gpu": sol.solver_mode = 1 else: sol.solver_mode = 1 # max_iter if "iteration" in layer["attributes"]: sol.max_iter = layer["attributes"]["iteration"] # default value!!!!!!!! alayer.data_param.backend = 0
def PhilData_OpticalFlow(net, **kwargs): ''' @brief Setup PhilDataLayer for optical flow @returns A list of layer output blobs ''' data_param = {'source' : kwargs['source'], 'backend' : Params.Data.LMDB, 'batch_size' : kwargs['batch_size'], 'encoding' : (Proto.DataParameter.UINT8, Proto.DataParameter.UINT8, Proto.DataParameter.UINT16FLOW, Proto.DataParameter.BOOL1), 'slice_point': (3, 6, 8), 'verbose' : kwargs['verbose'], 'rand_permute' : kwargs['rand_permute'], 'rand_permute_seed' : kwargs['rand_permute_seed']} if 'preselection_file' in kwargs: data_param['preselection_file'] = kwargs['preselection_file'] if 'preselection_label' in kwargs: data_param['preselection_label'] = kwargs['preselection_label'] ## Always returns (img_from, img_to, flow, occlusion) return Layers.PhilData(net, nout=4, include=(Proto.NetStateRule(phase=kwargs['phase']),), data_param=data_param)
def to_pbuf_message( self, # pylint: disable=R0912, R0915 layerindex, preceeding_layer, net_input): r""" Create a protobuf specification of this layer. It automatically wires together preceeding and following layers, if ``tops`` or ``bottoms`` are not set. This does not work with multiple in- or outputs. :param layerindex: int >= 0. The index of this layer. Is used to generate the layer name. :param preceeding_layer: :class:`barrista.design.LayerSpecification`. The preceeding layer to create the wiring with. :param net_input: string. The name of the network input (used for the first layer input). """ assert layerindex >= 0 assert self.type is not None if layerindex != 0: assert preceeding_layer is not None # Prepare the arguments. kwargs = dict() # Bottom. pbbottom = [] omit_bottom = False if self.bottoms is None: if preceeding_layer is None: if net_input is not None and len(net_input) > 0: pbbottom = [net_input[0]] else: omit_bottom = True else: if preceeding_layer.tops is None: if preceeding_layer.name is None: pbbottom = ['_layer_{0}'.format(layerindex - 1)] else: pbbottom = [preceeding_layer.name] else: pbbottom = [preceeding_layer.tops[0]] else: preplist = self.bottoms[:] mapidx = 0 for btidx, btname in enumerate(preplist): if btname is None: if preceeding_layer.tops is not None: preplist[btidx] = preceeding_layer.tops[mapidx] else: preplist[btidx] = '_layer_{0}'.format(layerindex - 1) mapidx += 1 pbbottom = preplist if not omit_bottom: kwargs['bottom'] = pbbottom # Top. pbtop = [] if self.tops is None: if self.name is None: pbtop = ['_layer_{0}'.format(layerindex)] else: pbtop = [self.name] else: pbtop = self.tops kwargs['top'] = pbtop # Name. pbname = self.name if pbname is None: pbname = '_layer_{0}'.format(layerindex) kwargs['name'] = pbname if self.phase is not None: kwargs['phase'] = self.phase # include. include_kwargs = dict() if self.include_phase is not None: include_kwargs['phase'] = self.include_phase if self.include_stages is not None and len(self.include_stages) > 0: include_kwargs['stage'] = self.include_stages if self.include_min_level is not None: include_kwargs['min_level'] = self.include_min_level if self.include_max_level is not None: include_kwargs['max_level'] = self.include_max_level if len(include_kwargs) > 0: kwargs['include'] = [_caffe_pb2.NetStateRule(**include_kwargs)] kwargs['type'] = self.type if self.params is not None: kwargs['param'] = self.params if _HAS_PROPAGATE_DOWN: kwargs['propagate_down'] = self.propagate_down if self.loss_param is not None: kwargs['loss_param'] = self.loss_param kwargs['loss_weight'] = self.loss_weights for add_pname in self._additional_parameters: kwargs[add_pname] = getattr(self, add_pname) layerMessage = _caffe_pb2.LayerParameter(**kwargs) assert layerMessage.IsInitialized() return layerMessage
# Create network file net = caffe.proto.caffe_pb2.NetParameter() output_dir = os.path.join(config['output_dir'], config['name']) # Insert data layers train_layer = net.layer.add() train_layer.name = "input" for i in range(config['num_inputs']): train_layer.top.append("im{}".format(i+1)) train_layer.top.append("label") train_layer.type = "Python" train_layer.python_param.module = "input_image_tuple" train_layer.python_param.layer = "InputImageTuple" include_param = caffe_pb2.NetStateRule() include_param.phase = caffe_pb2.TRAIN train_layer.include.extend([include_param]) channels = 1 if config['color']: channels = 3 python_params = {'keys_file': config['train_keys'], 'label_file': config['train_labels'], 'base_dir': config['data_dir'], 'channel_split': config['channel_split'], 'direct': True, 'shuffle': True, 'saliency_dir': os.path.join(output_dir, 'vis'), 'data_shape': [channels, 227, 227],