class Network:
def __init__(self):
self.name = ""
self.input = Data()
self.layers = []
def construct_from_json(self, json):
if "name" in json:
self.name = json["name"]
assert "input" in json
self.input = Data()
self.input.name = json['input']
self.input.set_shape(json["input_dim"])
data_set = [self.input]
for jlayer in json["layer"]:
# infer shape of output is conducted in the procedure
layer = Layer.create_from_json(jlayer, data_set)
self.layers.append(layer)
def init_caffe_model(self, model):
for layer_id in range(len(self.layers)):
name = self.layers[layer_id].name
# print 'layer id: %d layer name: %s' % (layer_id, name)
find = False
for i in range(len(model.layer)):
if name == model.layer[i].name:
self.layers[layer_id].init_data_by_caffe_model(model.layer[i])
find = True
break
if find is False:
print 'layer %s is not found' % name
def create_from_json(json, data_set):
layer = ReluLayer()
layer.name = json["name"]
input_name = json["bottom"]
input_data = Data()
for data in data_set:
if input_name == data.get_name():
input_data = data
break
ni, ci, hi, wi = input_data.get_shape()
no = ni
co = ci
ho = hi
wo = wi
output_name = json["top"]
output_data = Data()
output_data.set_name(output_name)
output_data.set_shape([no, co, ho, wo])
data_set.append(output_data)
if "dropout_param" in json:
if "dropout_ratio" in json["dropout_param"]:
self.dropout_ratio == json["dropout_param"]["dropout_ratio"]
layer.bottom = [input_data]
layer.top = [output_data]
return layer
def create_from_json(json, data_set):
layer = PoolLayer()
layer.name = json["name"]
params = json["pooling_param"]
layer.sx = layer.sy = params["stride"]
layer.kx = layer.ky = params["kernel_size"]
if params['pool'] == 'MAX':
layer.pool_type = PoolLayer.PoolType.MAX
elif params['pool'] == 'AVE':
layer.pool_type = PoolLayer.PoolType.AVG
else:
raise Exception("Unknown pool type")
input_name = json["bottom"]
input_data = Data()
for data in data_set:
if input_name == data.get_name():
input_data = data
break
ni, ci, hi, wi = input_data.get_shape()
no = ni
co = ci
ho = int(math.ceil((hi - layer.ky) * 1. / layer.sy + 1))
wo = int(math.ceil((wi - layer.kx) * 1. / layer.sx + 1))
output_name = json["top"]
output_data = Data()
output_data.set_name(output_name)
output_data.set_shape([no, co, ho, wo])
data_set.append(output_data)
layer.bottom = [input_data]
layer.top = [output_data]
return layer
def construct_from_json(self, json):
if "name" in json:
self.name = json["name"]
assert "input" in json
self.input = Data()
self.input.name = json['input']
self.input.set_shape(json["input_dim"])
data_set = [self.input]
for jlayer in json["layer"]:
# infer shape of output is conducted in the procedure
layer = Layer.create_from_json(jlayer, data_set)
self.layers.append(layer)
def create_from_json(json, data_set):
layer = EltwiseLayer()
layer.name = json["name"]
input_names = json["bottom"]
input_data = []
for input_name in input_names:
for data in data_set:
if input_name == data.get_name():
input_data.append(data)
break
ni, ci, hi, wi = input_data[0].get_shape()
no = ni
co = ci
ho = hi
wo = wi
output_name = json["top"]
output_data = Data()
output_data.set_name(output_name)
output_data.set_shape([no, co, ho, wo])
data_set.append(output_data)
layer.bottom = input_data
layer.top = [output_data]
return layer
def create_from_json(json, data_set):
layer = SoftmaxLayer()
layer.name = json["name"]
input_name = json["bottom"]
input_data = Data()
for data in data_set:
if input_name == data.get_name():
input_data = data
break
ni, ci, hi, wi = input_data.get_shape()
no = ni
co = ci
ho = hi
wo = wi
output_name = json["top"]
output_data = Data()
output_data.set_name(output_name)
output_data.set_shape([no, co, ho, wo])
data_set.append(output_data)
layer.bottom = [input_data]
layer.top = [output_data]
return layer
def create_from_json(json, data_set):
layer = InnerProductLayer()
layer.name = json["name"]
layer.layer_type = LayerType.INNER_PRODUCT
if "inner_product_param" in json:
params = json["inner_product_param"]
if 'num_output' in params:
layer.co = params['num_output']
input_name = json["bottom"]
input_data = Data()
for data in data_set:
if input_name == data.get_name():
input_data = data
break
ni, ci, hi, wi = input_data.get_shape()
no = ni
output_name = json["top"]
output_data = Data()
output_data.set_name(output_name)
output_data.set_shape([ni, layer.co, 1, 1])
data_set.append(output_data)
weight_data = Data()
weight_data.set_name(layer.name + "_weight")
weight_data.set_shape([layer.co, ci, hi, wi])
data_set.append(weight_data)
layer.bottom = [input_data]
layer.weight = [weight_data]
layer.top = [output_data]
if not (('inner_product_param') in json and
('bias_term' in json['inner_product_param']) and
(json['inner_product_param']['bias_term'] is False)):
bias_data = Data()
bias_data.set_name(layer.name + "_bias")
bias_data.set_shape([1, layer.co, 1, 1])
layer.bias = [bias_data]
data_set.append(bias_data)
return layer
def create_from_json(json, data_set):
layer = ScaleLayer()
layer.name = json["name"]
input_name = json["bottom"]
input_data = Data()
for data in data_set:
if input_name == data.get_name():
input_data = data
break
ni, ci, hi, wi = input_data.get_shape()
no = ni
co = ci
ho = hi
wo = wi
output_name = json["top"]
output_data = Data()
output_data.set_name(output_name)
output_data.set_shape([no, co, ho, wo])
data_set.append(output_data)
alpha_data = Data()
alpha_data.set_name(layer.name + "_alpha")
alpha_data.set_shape([1, co, 1, 1])
data_set.append(alpha_data)
beta_data = Data()
beta_data.set_name(layer.name + "_beta")
beta_data.set_shape([1, co, 1, 1])
data_set.append(beta_data)
layer.bottom = [input_data]
layer.alpha = [alpha_data]
layer.beta = [beta_data]
layer.top = [output_data]
return layer
def create_from_json(json, data_set):
layer = BatchNormLayer()
layer.name = json["name"]
input_name = json["bottom"]
input_data = Data()
for data in data_set:
if input_name == data.get_name():
input_data = data
break
ni, ci, hi, wi = input_data.get_shape()
no = ni
co = ci
ho = hi
wo = wi
output_name = json["top"]
output_data = Data()
output_data.set_name(output_name)
output_data.set_shape([no, co, ho, wo])
data_set.append(output_data)
mean_data = Data()
mean_data.set_name(layer.name + "_mean")
mean_data.set_shape([1, co, 1, 1])
data_set.append(mean_data)
vari_data = Data()
vari_data.set_name(layer.name + "_vari")
vari_data.set_shape([1, co, 1, 1])
data_set.append(vari_data)
layer.bottom = [input_data]
layer.vari = [vari_data]
layer.mean = [mean_data]
layer.top = [output_data]
return layer
def create_from_json(json, data_set):
layer = ConvLayer()
layer.layer_type = LayerType.CONVOLUTION
layer.name = json["name"]
if "convolution_param" in json:
params = json["convolution_param"]
if 'stride' in params:
layer.sx = layer.sy = params['stride']
if 'pad' in params:
layer.pad = params['pad']
if 'kernel_size' in params:
layer.kx = layer.ky = params['kernel_size']
if 'num_output' in params:
layer.co = params['num_output']
input_name = json["bottom"]
input_data = Data()
for data in data_set:
if input_name == data.get_name():
input_data = data
break
ni, ci, hi, wi = input_data.get_shape()
no = ni
ho = (hi + layer.pad * 2 - layer.ky) / layer.sy + 1
wo = (wi + layer.pad * 2 - layer.kx) / layer.sx + 1
output_name = json["top"]
output_data = Data()
output_data.set_name(output_name)
output_data.set_shape([no, layer.co, ho, wo])
data_set.append(output_data)
weight_data = Data()
weight_data.set_name(layer.name + "_weight")
weight_data.set_shape([layer.co, ci, layer.kx, layer.ky])
data_set.append(weight_data)
layer.bottom = [input_data]
layer.weight = [weight_data]
layer.top = [output_data]
if not (('convolution_param') in json and
('bias_term' in json['convolution_param']) and
(json['convolution_param']['bias_term'] is False)):
bias_data = Data()
bias_data.set_name(layer.name + "_bias")
bias_data.set_shape([1, layer.co, 1, 1])
data_set.append(bias_data)
layer.bias = [bias_data]
return layer
def __init__(self):
self.name = ""
self.input = Data()
self.layers = []