def to_proto(self):
"""Serialize to the proto.
Returns
-------
LayerParameter
The ``LayerParameter`` protocol buffer.
"""
proto = caffe_pb2.LayerParameter()
proto.CopyFrom(self._proto)
for blob in self._blobs:
value = blob['data'].get_value()
if str(value.dtype) == 'float32':
blob_proto = caffe_pb2.BlobProto(
data=value.flatten(),
shape=caffe_pb2.BlobShape(dim=value.shape))
elif str(value.dtype) == 'float64':
blob_proto = caffe_pb2.BlobProto(
double_data=value.flatten(),
shape=caffe_pb2.BlobShape(dim=value.shape))
else:
raise ValueError('Either float32 or float64 blob is required.')
proto.blobs.extend([blob_proto])
return proto
def _to_proto(self, layers, names, autonames):
if self in layers:
return
bottom_names = []
for inp in self.inputs:
inp._to_proto(layers, names, autonames)
bottom_names.append(layers[inp.fn].top[inp.n])
layer = caffe_pb2.LayerParameter()
layer.type = self.type_name
layer.bottom.extend(bottom_names)
if self.in_place:
layer.top.extend(layer.bottom)
else:
for top in self.tops:
layer.top.append(self._get_top_name(top, names, autonames))
layer.name = self._get_name(names, autonames)
for k, v in self.params.items():
# special case to handle generic *params
if k.endswith('param'):
assign_proto(layer, k, v)
else:
try:
assign_proto(getattr(
layer, _param_names[self.type_name] + '_param'), k, v)
except (AttributeError, KeyError):
assign_proto(layer, k, v)
layers[self] = layer
def __init__(self, *args):
"""Create a ``Net``.
Parameters
----------
net_file : str
The path of text proto file to load network.
param_file : str, optional
The path of binary proto file to load parameters.
phase : {'TRAIN', 'TEST'}, optional
The optional phase tag.
"""
if len(args) == 2:
(net_file, self._phase), param_file = args, None
elif len(args) == 3:
net_file, param_file, self._phase = args
else:
raise ValueError('Excepted 2 or 3 args.')
self._blobs = {}
self._layers = []
self._layer_blobs = []
self._losses = []
self._params = []
self._blob_dict = None
self._param_dict = None
self._input_list = None
self._output_list = None
# Parse the network file
with open(net_file, 'r') as f:
self._proto = text_format.Parse(f.read(), caffe_pb2.NetParameter())
# Construct the layer class from proto
for layer_param in self._proto.layer:
if not self._filter_layer(layer_param):
continue
cls = getattr(layer_factory, layer_param.type)
with context.name_scope(layer_param.name):
self._layers.append(cls(layer_param))
# Prepare for the legacy net inputs
if len(self._proto.input) > 0:
layer_param = caffe_pb2.LayerParameter(
name='data',
type='Input',
top=self._proto.input,
input_param=caffe_pb2.InputParameter(
shape=self._proto.input_shape))
cls = getattr(layer_factory, layer_param.type)
with context.name_scope(layer_param.name):
self._layers.insert(0, cls(layer_param))
# Call layers sequentially to get outputs
self._setup()
# Collect losses and parameters
for layer in self._proto.layer:
if not self._filter_layer(layer):
continue
self._collect_losses_and_params(layer)
# Load the pre-trained weights if necessary
if param_file is not None:
self.copy_from(param_file)
def param_name_dict():
"""Find out the correspondence between layer names and parameter names."""
layer = caffe_pb2.LayerParameter()
# Get all parameter names (typically underscore case) and corresponding
# type names (typically camel case), which contain the layer names
# (note that not all parameters correspond to layers, but we'll ignore that).
param_names = [f.name for f in layer.DESCRIPTOR.fields if f.name.endswith('_param')]
param_type_names = [type(getattr(layer, s)).__name__ for s in param_names]
# Strip the final '_param' or 'Parameter'.
param_names = [s[:-len('_param')] for s in param_names]
param_type_names = [s[:-len('Parameter')] for s in param_type_names]
return dict(zip(param_type_names, param_names))
def __init__(self, network_file, phase='TEST', weights=None):
"""Create a ``Net``.
Parameters
----------
network_file : str
The path of text proto file to load network.
phase : str, optional, default='TEST'
The execution phase.
weights : str, optional
The path of binary proto file to load weights.
"""
# Parse the network file.
with open(network_file, 'r') as f:
self._proto = google.protobuf.text_format.Parse(
f.read(), caffe_pb2.NetParameter())
self._phase = phase
self._layers = []
self._learnable_blobs = []
self._net_blobs = dict()
self._net_outputs = set()
# Construct the layers from proto.
layer_names = []
for layer_param in self._proto.layer:
if not self._filter_layer(layer_param):
continue
try:
layer_index = layer_names.index(layer_param.name)
call_layer = self._layers[layer_index]
except ValueError:
call_layer = None
layer_names.append(layer_param.name)
cls = getattr(layer_factory, layer_param.type)
self._layers.append(cls(layer_param))
self._layers[-1]._call_layer = call_layer
# Add an input layer for the legacy inputs.
if len(self._proto.input) > 0:
layer_param = caffe_pb2.LayerParameter(
name='data',
type='Input',
top=self._proto.input,
input_param=caffe_pb2.InputParameter(
shape=self._proto.input_shape))
cls = getattr(layer_factory, layer_param.type)
with context.name_scope(layer_param.name):
self._layers.insert(0, cls(layer_param))
# Connect layers to get outputs.
self._init()
# Load the pre-trained weights if necessary
if weights is not None:
self.copy_from(weights)