def _calculate_inout_shape(self, input_tensor):
assert input_tensor.num_dims == 4, "[MaxPooling2D]: shape of input tensor is wrong"
input_b = input_tensor.batch_shape[0]
input_d = input_tensor.batch_shape[1]
input_h = input_tensor.batch_shape[2]
input_w = input_tensor.batch_shape[3]
assert input_h != 0, "wrong input_h"
assert input_w != 0, "wrong input_w"
assert input_d != 0, "wrong input_d"
#calculate padding for same
if (self.padding == 'same'):
if (input_h % self.stride[0] == 0):
padding_h = max(self.kernel_size[0] - self.stride[0], 0)
else:
padding_h = max(self.kernel_size[0] - (input_h % self.stride[0]), 0)
if (input_w % self.stride[1] == 0):
padding_w = max(self.kernel_size[1] - self.stride[1], 0)
else:
padding_w = max(self.kernel_size[1] - (input_w % self.stride[1]), 0)
self.padding = (padding_h//2, padding_w//2)
fflogger.debug("pool2d same padding %s" %( str(self.padding)))
self.input_shape = (input_b, input_d, input_w, input_h)
self.in_channels = input_d
self.out_channels = input_d
output_h = 1 + math.floor((input_h + 2 * self.padding[0] - self.kernel_size[0]) / self.stride[0])
output_w = 1 + math.floor((input_w + 2 * self.padding[1] - self.kernel_size[1]) / self.stride[1])
output_d = self.out_channels
self.output_shape = (input_b, output_d, output_h, output_w)
fflogger.debug("pool2d input %s, output %s" %( str(self.input_shape), str(self.output_shape)))
def _calculate_inout_shape(self, input_tensor):
input_shape = input_tensor.batch_shape
self.input_shape = input_shape
flat_size = 1
for i in range(1, len(input_shape)):
flat_size *= input_shape[i]
self.output_shape = (input_shape[0], flat_size)
fflogger.debug("flat input %s, output %s" %
(str(self.input_shape), str(self.output_shape)))
def _calculate_inout_shape(self, input_tensor):
assert input_tensor.num_dims == 2, "[Embedding]: shape of input tensor is wrong"
input_b = input_tensor.batch_shape[0]
in_dim = input_tensor.batch_shape[1]
assert in_dim != 0, "wrong in_dim"
assert self.input_length == in_dim, "wrong input_w"
self.output_shape = (input_b, self.out_channels)
self.input_shape = (input_b, self.input_length)
fflogger.debug("embedding input %s, output %s" %
(str(self.input_shape), str(self.output_shape)))
def _calculate_inout_shape(self, input_tensor):
assert input_tensor.num_dims == 2, "[Dense]: shape of input tensor is wrong"
input_b = input_tensor.batch_shape[0]
in_dim = input_tensor.batch_shape[1]
assert in_dim != 0, "wrong in_dim"
if (self.in_channels != 0): # check if user input is correct
assert self.in_channels == in_dim, "wrong input_w"
self.output_shape = (input_b, self.out_channels)
self.input_shape = (input_b, in_dim)
self.in_channels = in_dim
fflogger.debug("dense input %s, output %s" %
(str(self.input_shape), str(self.output_shape)))
def __init__(self, inputs, outputs, name=None):
super(Model, self).__init__(name)
if (isinstance(inputs, list) == False):
inputs = [inputs]
self._input_tensors = inputs
for input_tensor in inputs:
self._input_layers.append(input_tensor.from_layer)
self._output_tensor = outputs
self.__traverse_dag_dfs()
fflogger.debug("nb_layers %d" % (self._nb_layers))
def _calculate_inout_shape(self, input_tensors):
if (input_tensors[0].num_dims == 2):
output_shape = [input_tensors[0].batch_shape[0], 0]
for input_tensor in input_tensors:
output_shape[self.axis] += input_tensor.batch_shape[self.axis]
self.output_shape = (output_shape[0], output_shape[1])
elif (input_tensors[0].num_dims == 4):
output_shape = [
input_tensors[0].batch_shape[0], 0,
input_tensors[0].batch_shape[2],
input_tensors[0].batch_shape[3]
]
for input_tensor in input_tensors:
output_shape[self.axis] += input_tensor.batch_shape[self.axis]
self.output_shape = (output_shape[0], output_shape[1],
output_shape[2], output_shape[3])
else:
assert 0, "un-supported dims"
fflogger.debug("concat output %s" % (str(self.output_shape)))
self.input_shape = input_tensors[0].batch_shape
def summary(self, line_length=None, positions=None, print_fn=None):
if line_length != None:
assert 0, "line_length is not supported"
if print_fn != None:
assert 0, "print_fn is not supported"
model_summary = "Layer (type)\t\tOutput Shape\t\tInput Shape\tConnected to\n"
for layer in self._input_layers:
layer_summary = layer.get_summary()
model_summary += layer_summary
for layer in self._layers:
fflogger.debug(str(layer))
for prev_layer in layer.prev_layers:
fflogger.debug("\tprev: %s" % (str(prev_layer)))
for next_layer in layer.next_layers:
fflogger.debug("\tnext: %s" % (str(next_layer)))
layer_summary = layer.get_summary()
model_summary += layer_summary
return model_summary
def compile(self,
optimizer,
loss=None,
metrics=None,
loss_weights=None,
weighted_metrics=None,
run_eagerly=None,
comp_mode=ff.CompMode.TRAINING,
**kwargs):
if loss_weights != None:
assert 0, "loss_weights is not supported"
if weighted_metrics != None:
assert 0, "weighted_metrics is not supported"
if run_eagerly != None:
assert 0, "run_eagerly is not supported"
assert loss != None, "loss is None"
if isinstance(loss, keras_losses.Loss) == True:
self._loss = loss
elif loss == 'categorical_crossentropy':
self._loss = keras_losses.CategoricalCrossentropy()
elif loss == 'sparse_categorical_crossentropy':
self._loss = keras_losses.SparseCategoricalCrossentropy()
self._label_type = ff.DataType.DT_INT32
elif loss == 'mean_squared_error':
self._loss = keras_losses.MeanSquaredError()
else:
assert 0, 'Unsupported loss'
assert metrics != None, "metrics is None"
assert isinstance(metrics, list) == True, 'Metrics should be a list'
for metric in metrics:
if isinstance(metric, keras_metrics.Metric) == True:
self._metrics.append(metric)
elif metric == 'accuracy':
self._metrics.append(keras_metrics.Accuracy())
elif metric == 'categorical_crossentropy':
self._metrics.append(keras_metrics.CategoricalCrossentropy())
elif metric == 'sparse_categorical_crossentropy':
self._metrics.append(
keras_metrics.SparseCategoricalCrossentropy())
elif metric == 'mean_squared_error':
self._metrics.append(keras_metrics.MeanSquaredError())
elif metric == 'root_mean_squared_error':
self._metrics.append(keras_metrics.RootMeanSquaredError())
elif metric == 'mean_absolute_error':
self._metrics.append(keras_metrics.MeanAbsoluteError())
else:
assert 0, 'Unsupported metric'
self._ffmodel = ff.FFModel(self._ffconfig)
self._create_input_tensors()
self._create_flexflow_layers()
self._verify_output_tensors()
self._verify_input_tensors()
self._ffoptimizer = optimizer
self._create_optimizer()
metrics_type = []
for metric in self._metrics:
metrics_type.append(metric.type)
self._ffmodel.optimizer = optimizer.ffhandle
self._ffmodel.compile(loss_type=self._loss.type,
metrics=metrics_type,
comp_mode=comp_mode)
self._create_label_tensor()
fflogger.debug("%s, %s, %s, %s" %
(str(self._input_tensors[0]), str(self._output_tensor),
str(self._input_tensors[0].ffhandle),
str(self._output_tensor.ffhandle)))
def _calculate_inout_shape(self, input_tensors):
assert len(input_tensors) == 2, "check input_tensors"
self.input_shape = input_tensors[0].batch_shape
self.output_shape = input_tensors[0].batch_shape
fflogger.debug("multiply output %s" % (str(self.output_shape)))
