"""Base layer class.

def __init__(self, trainable=True, name=None, dtype=None,

activity_regularizer=None, **kwargs):

# We use a kwargs dict here because these kwargs only exist

# for compatibility reasons.

# The list of kwargs is subject to changes in the future.

# We do not want to commit to it or to expose the list to users at all.

# Note this is exactly as safe as defining kwargs in the function signature,

# the only difference being that the list of valid kwargs is defined

# below rather rather in the signature, and default values are defined

# in calls to kwargs.get().

allowed_kwargs = {

'_scope',

'_reuse',

'input_shape', # For compatibility with Keras `Sequential` model.

'batch_size', # For compatibility with Keras `Sequential` model.

}

for kwarg in kwargs:

if kwarg not in allowed_kwargs:

raise TypeError('Keyword argument not understood:', kwarg)

# Mutable properties

self.trainable = trainable

self.built = False

self.input_spec = None

self._activity_regularizer = activity_regularizer

self._trainable_weights = []

self._non_trainable_weights = []

self._updates = []

self._losses = []

self._reuse = kwargs.get('_reuse')

self._graph = ops.get_default_graph()

self._per_input_losses = {}

self._per_input_updates = {}

self._dtype = None if dtype is None else dtypes.as_dtype(dtype).name

self._compute_previous_mask = ('mask' in estimator_util.fn_args(self.call)

or hasattr(self, 'compute_mask'))

# These lists will be filled via successive calls

# to self._add_inbound_node().

self._inbound_nodes = []

self._outbound_nodes = []

# Determine layer name (non-unique).

if isinstance(name, vs.VariableScope):

base_name = name.name

else:

base_name = name

self._name = name

if not name:

base_name = _to_snake_case(self.__class__.__name__)

self._name = _unique_layer_name(base_name)

self._base_name = base_name

# Determine variable scope.

scope = kwargs.get('_scope')

if scope:

self._scope = next(vs.variable_scope(scope).gen)

else:

self._scope = None

# Set `_batch_input_shape` attribute

# for compatibility with Keras `Sequential` model.

if 'input_shape' in kwargs:

batch_size = kwargs.get('batch_size')

self._batch_input_shape = (batch_size,) + tuple(kwargs['input_shape'])

@property

def dtype(self):

return self._dtype

@property

def name(self):

return self._name

@property

def activity_regularizer(self):

"""Optional regularizer function for the output of this layer."""

return self._activity_regularizer

@property

def scope_name(self):

if not self._scope:

raise ValueError('No name available for layer scope because the layer "' +

self._name + '" has not been used yet. The scope name ' +

' is determined the first time the layer instance is ' +

'called. You must therefore call the layer before ' +

'querying `scope_name`.')

return self._scope.name

@property

def trainable_weights(self):

return self._trainable_weights if self.trainable else []

@property

def non_trainable_weights(self):

if self.trainable:

return self._non_trainable_weights

else:

return self._trainable_weights + self._non_trainable_weights

@property

def trainable_variables(self):

return self.trainable_weights

@property

def non_trainable_variables(self):

return self.non_trainable_weights

@property

def weights(self):

"""Returns the list of all layer variables/weights.

return self.trainable_weights + self.non_trainable_weights

@property

def variables(self):

"""Returns the list of all layer variables/weights.

return self.weights

@property

def updates(self):

if context.in_eager_mode():

raise RuntimeError('Layer.updates not supported in Eager mode.')

return self._updates

def add_update(self, updates, inputs=None):

"""Add update op(s), potentially dependent on layer inputs.

if context.in_eager_mode():

raise RuntimeError('Layer.add_update not supported in Eager mode.')

updates = _to_list(updates)

if not updates:

return

self._updates += updates

if inputs is not None:

inputs = _to_list(inputs)

if not inputs:

inputs = None

if inputs is not None:

# We compute an ID that uniquely identifies the list of tensors.

# This ID is order-sensitive.

inputs_hash = _object_list_uid(inputs)

else:

inputs_hash = None

if inputs_hash not in self._per_input_updates:

self._per_input_updates[inputs_hash] = []

self._per_input_updates[inputs_hash] += updates

def get_updates_for(self, inputs):

"""Retrieves updates relevant to a specific set of inputs.

if context.in_eager_mode():

raise RuntimeError('Layer.get_updates_for not supported in Eager mode.')

if inputs is not None:

inputs = _to_list(inputs)

if not inputs:

inputs = None

if inputs is not None:

inputs_hash = _object_list_uid(inputs)

else:

inputs_hash = None

return self._per_input_updates.get(inputs_hash, [])

@property

def losses(self):

if context.in_eager_mode():

raise RuntimeError('Layer.losses not supported in Eager mode.')

return self._losses

def add_loss(self, losses, inputs=None):

"""Add loss tensor(s), potentially dependent on layer inputs.

if context.in_eager_mode():

raise RuntimeError('Layer.add_loss not supported in Eager mode.')

losses = _to_list(losses)

if not losses:

return

self._losses += losses

if inputs is not None:

inputs = _to_list(inputs)

if not inputs:

inputs = None

if inputs is not None:

# We compute an ID that uniquely identifies the list of tensors.

# This ID is order-sensitive.

inputs_hash = _object_list_uid(inputs)

else:

inputs_hash = None

if inputs_hash not in self._per_input_losses:

self._per_input_losses[inputs_hash] = []

self._per_input_losses[inputs_hash] += losses

_add_elements_to_collection(losses, ops.GraphKeys.REGULARIZATION_LOSSES)

def get_losses_for(self, inputs):

"""Retrieves losses relevant to a specific set of inputs.

if context.in_eager_mode():

raise RuntimeError('Layer.get_losses_for not supported in Eager mode.')

if inputs is not None:

inputs = _to_list(inputs)

if not inputs:

inputs = None

if inputs is not None:

inputs_hash = _object_list_uid(inputs)

else:

inputs_hash = None

return self._per_input_losses.get(inputs_hash, [])

def build(self, _):

"""Creates the variables of the layer."""

self.built = True

def call(self, inputs, **kwargs): # pylint: disable=unused-argument

"""The logic of the layer lives here.

return inputs

def _compute_output_shape(self, input_shape):

"""Computes the output shape of the layer given the input shape.

return input_shape

def _set_scope(self, scope=None):

if self._scope is None:

# If constructed with _scope=None, lazy setting of scope.

if self._reuse:

self._scope = next(vs.variable_scope(

scope if scope is not None else self._base_name).gen)

else:

self._scope = next(vs.variable_scope(

scope, default_name=self._base_name).gen)

def add_variable(self, name, shape, dtype=None,

initializer=None, regularizer=None,

trainable=True, constraint=None):

"""Adds a new variable to the layer, or gets an existing one; returns it.

# Note that we currently don't support variable regularization in Eager

# mode. An alternative is for users to directly compute these losses before

# performing a backward pass.

if context.in_graph_mode():

existing_variables = set(tf_variables.global_variables())

else:

existing_variables = []

if regularizer is not None:

raise RuntimeError('Variable regularization not supported in Eager '

'mode.')

if dtype is None:

dtype = self.dtype or dtypes.float32

self._set_scope(None)

with vs.variable_scope(

self._scope, reuse=(self.built or self._reuse)) as scope:

with ops.name_scope(scope.original_name_scope):

variable = vs.get_variable(name,

shape=shape,

initializer=initializer,

dtype=dtypes.as_dtype(dtype),

constraint=constraint,

trainable=trainable and self.trainable)

if variable in existing_variables:

return variable

if regularizer:

# To match the behavior of tf.get_variable(), we only

# apply regularization if the variable is newly created.

if isinstance(variable, tf_variables.PartitionedVariable):

for v in variable:

with ops.colocate_with(v.op):

with ops.name_scope(name + '/Regularizer'):

regularization = regularizer(v)

if regularization is not None:

self.add_loss(regularization)

else:

with ops.colocate_with(variable.op):

with ops.name_scope(name + '/Regularizer'):

regularization = regularizer(variable)

if regularization is not None:

self.add_loss(regularization)

if trainable:

self._trainable_weights.append(variable)

else:

self._non_trainable_weights.append(variable)

return variable

def __call__(self, inputs, *args, **kwargs):

"""Wraps `call`, applying pre- and post-processing steps.

self._set_scope(kwargs.pop('scope', None))

in_graph_mode = context.in_graph_mode()

# Ensure the Layer, if being reused, is working with inputs from

# the same graph as where it was created.

if in_graph_mode:

try:

ops._get_graph_from_inputs(nest.flatten(inputs), graph=self.graph) # pylint: disable=protected-access

except ValueError as e:

raise ValueError('Input graph and Layer graph are not the same: %s' % e)

user_kwargs = copy.copy(kwargs)

# Handle Keras mask propagation from previous layer to current layer.

previous_mask = None

if (not hasattr(self, '_compute_previous_mask') or

self._compute_previous_mask):

previous_mask = _collect_previous_mask(inputs)

if ('mask' in estimator_util.fn_args(self.call) and

'mask' not in kwargs and

not _is_all_none(previous_mask)):

# The previous layer generated a mask, and mask was not explicitly pass

# to __call__, hence we set previous_mask as the default value.

kwargs['mask'] = previous_mask

with vs.variable_scope(

self._scope, reuse=(self.built or self._reuse)) as scope:

with ops.name_scope(scope.original_name_scope):

if not self.built:

if not in_graph_mode:

# Activity regularization is currently unsupported in Eager mode.

if self._activity_regularizer:

raise ValueError('activity_regularizer currently unsupported in '

'Eager mode. Found an activity_regularizer in '

'%s(%s).' % (self.__class__.__name__, self))

# TODO(agarwal): support _keras_history in Eager mode.

for x in _to_list(inputs):

if hasattr(x, '_keras_history'):

raise ValueError('_keras_history currently unsupported in '

'Eager mode. Found _keras_history in %s while '

'executing __call__ for %s(%s)' %

(x, self.__class_.__name__, self))

# Check input assumptions set before layer building, e.g. input rank.

self._assert_input_compatibility(inputs)

input_list = nest.flatten(inputs)

if input_list and self._dtype is None:

try:

self._dtype = input_list[0].dtype.name

except AttributeError:

pass

input_shapes = [x.get_shape() for x in input_list]

if len(input_shapes) == 1:

self.build(input_shapes[0])

else:

self.build(input_shapes)

if 'scope' in estimator_util.fn_args(self.call):

kwargs['scope'] = scope

# Check input assumptions set after layer building, e.g. input shape.

if in_graph_mode:

self._assert_input_compatibility(inputs)

outputs = self.call(inputs, *args, **kwargs)

if outputs is None:

raise ValueError('A layer\'s `call` method should return a Tensor '

'or a list of Tensors, not None.')

if in_graph_mode:

# Apply activity regularization.

# Note that it should be applied every time the layer creates a new

# output, since it is output-specific.

if self._activity_regularizer:

output_list = _to_list(outputs)

for output in output_list:

with ops.name_scope('ActivityRegularizer'):

activity_regularization = self._activity_regularizer(output)

self.add_loss(activity_regularization)

# Handle mask computation and propagation to the next layer.

if hasattr(self, 'compute_mask'):

output_mask = self.compute_mask(inputs, previous_mask)

if isinstance(outputs, list):

if output_mask is None:

output_mask = [None for _ in range(len(outputs))]

for x, m in zip(outputs, output_mask):

x._keras_mask = m # pylint: disable=protected-access

else:

outputs._keras_mask = output_mask # pylint: disable=protected-access

if in_graph_mode:

# If all input tensors have history metadata,

# we update the output tensors

# with corresponding history metadata, thus eventually allowing to use

# these tensors to instantiate a Network.

if _have_all_keras_metadata(inputs):

# If the layer returns tensors from its inputs, unmodified,

# we copy them to avoid loss of tensor metadata.

output_ls = _to_list(outputs)

inputs_ls = _to_list(inputs)

output_ls_copy = []

for x in output_ls:

if x in inputs_ls:

with ops.name_scope(scope.original_name_scope):

x = array_ops.identity(x)

output_ls_copy.append(x)

if len(output_ls_copy) == 1:

outputs = output_ls_copy[0]

else:

outputs = output_ls_copy

# Add an inbound node to the layer, so it can keep track of this call.

# This updates the layer history of the output tensor(s).

self._add_inbound_node(

input_tensors=inputs, output_tensors=outputs, arguments=user_kwargs)

# Update global default collections.

_add_elements_to_collection(self.updates, ops.GraphKeys.UPDATE_OPS)

self.built = True

return outputs

@property

def graph(self):

if context.in_eager_mode():

raise RuntimeError('Layer.graph not supported in Eager mode.')

return self._graph

def __deepcopy__(self, memo):

no_copy = set(['_graph'])

shallow_copy = set(['_scope'])

cls = self.__class__

result = cls.__new__(cls)

memo[id(self)] = result

for k, v in self.__dict__.items():

if k in no_copy:

setattr(result, k, v)

elif k in shallow_copy:

setattr(result, k, copy.copy(v))

elif _is_tensor_or_tensor_list(v):

setattr(result, k, v)

else:

setattr(result, k, copy.deepcopy(v, memo))

return result

def apply(self, inputs, *args, **kwargs):

"""Apply the layer on a input.

return self.__call__(inputs, *args, **kwargs)

def _add_inbound_node(self,

input_tensors,

output_tensors,

arguments=None):

"""Internal method to create an inbound node for the layer.

assert context.in_graph_mode()

input_tensors = _to_list(input_tensors)

output_tensors = _to_list(output_tensors)

# Collect input tensor(s) coordinates.

inbound_layers = []

node_indices = []

tensor_indices = []

for x in input_tensors:

assert hasattr(x, '_keras_history')

inbound_layer, node_index, tensor_index = x._keras_history # pylint: disable=protected-access

inbound_layers.append(inbound_layer)

node_indices.append(node_index)

tensor_indices.append(tensor_index)

# Create node, add it to inbound nodes.

Node(

self,

inbound_layers=inbound_layers,

node_indices=node_indices,

tensor_indices=tensor_indices,

input_tensors=input_tensors,

output_tensors=output_tensors,

arguments=arguments)

# Update tensor history metadata.

for i in range(len(output_tensors)):

# The metadata attribute consists of 1) a layer instance

# 2) a node index for the layer, 3) a tensor index for the node.

# The allows layer reuse (multiple nodes per layer) and multi-output

# or multi-input layers (e.g. a layer can return multiple tensors,

# and each can be sent to a different layer).

output_tensors[i]._keras_history = (self, len(self._inbound_nodes) - 1, i) # pylint: disable=protected-access

def _get_node_attribute_at_index(self, node_index, attr, attr_name):

"""Private utility to retrieves an attribute (e.g. inputs) from a node.

assert context.in_graph_mode()

if not self._inbound_nodes:

raise RuntimeError('The layer has never been called '

'and thus has no defined ' + attr_name + '.')

if not len(self._inbound_nodes) > node_index:

raise ValueError('Asked to get ' + attr_name + ' at node ' +

str(node_index) + ', but the layer has only ' +

str(len(self._inbound_nodes)) + ' inbound nodes.')

values = getattr(self._inbound_nodes[node_index], attr)

if len(values) == 1:

return values[0]

else:

return values

def get_input_shape_at(self, node_index):

"""Retrieves the input shape(s) of a layer at a given node.

if context.in_eager_mode():

raise RuntimeError(

'Layer.get_input_shape_at not supported in Eager mode.')

return self._get_node_attribute_at_index(node_index, 'input_shapes',

'input shape')

def get_output_shape_at(self, node_index):

"""Retrieves the output shape(s) of a layer at a given node.

if context.in_eager_mode():

raise RuntimeError(

'Layer.get_output_shape_at not supported in Eager mode.')

return self._get_node_attribute_at_index(node_index, 'output_shapes',

'output shape')

def get_input_at(self, node_index):

"""Retrieves the input tensor(s) of a layer at a given node.

if context.in_eager_mode():

raise RuntimeError('Layer.get_input_at not supported in Eager mode.')

return self._get_node_attribute_at_index(node_index, 'input_tensors',

'input')

def get_output_at(self, node_index):

"""Retrieves the output tensor(s) of a layer at a given node.

if context.in_eager_mode():

raise RuntimeError('Layer.get_output_at not supported in Eager mode.')

return self._get_node_attribute_at_index(node_index, 'output_tensors',

'output')

@property

def input(self):

"""Retrieves the input tensor(s) of a layer.

if context.in_eager_mode():

raise RuntimeError('Layer.input not supported in Eager mode.')

if not self._inbound_nodes:

raise AttributeError('Layer ' + self.name +

' is not connected, no input to return.')

return self._get_node_attribute_at_index(0, 'input_tensors', 'input')

@property

def output(self):

"""Retrieves the output tensor(s) of a layer.

if context.in_eager_mode():

raise RuntimeError('Layer.output not supported in Eager mode.')

if not self._inbound_nodes:

raise AttributeError('Layer ' + self.name + ' has no inbound nodes.')

return self._get_node_attribute_at_index(0, 'output_tensors', 'output')

@property

def input_shape(self):

"""Retrieves the input shape(s) of a layer.

if context.in_eager_mode():

raise RuntimeError('Layer.input_shape not supported in Eager mode.')

if not self._inbound_nodes:

raise AttributeError('The layer has never been called '

'and thus has no defined input shape.')

all_input_shapes = set(

[str(node.input_shapes) for node in self._inbound_nodes])

if len(all_input_shapes) == 1:

input_shapes = self._inbound_nodes[0].input_shapes

if len(input_shapes) == 1:

return tuple(tensor_shape.TensorShape(input_shapes[0]).as_list())

else:

return [

tuple(tensor_shape.TensorShape(shape).as_list())

for shape in input_shapes

]

else:

raise AttributeError('The layer "' + str(self.name) +

' has multiple inbound nodes, '

'with different input shapes. Hence '

'the notion of "input shape" is '

'ill-defined for the layer. '

'Use `get_input_shape_at(node_index)` '

'instead.')

def count_params(self):

"""Count the total number of scalars composing the weights.

if not self.built:

if self.__class__.__name__ == 'Sequential':

self.build() # pylint: disable=no-value-for-parameter

else:

raise ValueError('You tried to call `count_params` on ' + self.name +

', but the layer isn\'t built. '

'You can build it manually via: `' + self.name +

'.build(batch_input_shape)`.')

weight_shapes = [w.get_shape().as_list() for w in self.weights]

return int(sum([np.prod(w) for w in weight_shapes]))

@property

def output_shape(self):

"""Retrieves the output shape(s) of a layer.

if context.in_eager_mode():

raise RuntimeError('Layer.output_shape not supported in Eager mode.')

if not self._inbound_nodes:

raise AttributeError('The layer has never been called '

'and thus has no defined output shape.')

all_output_shapes = set(

[str(node.output_shapes) for node in self._inbound_nodes])

if len(all_output_shapes) == 1:

output_shapes = self._inbound_nodes[0].output_shapes

if len(output_shapes) == 1:

return tuple(tensor_shape.TensorShape(output_shapes[0]).as_list())

else:

return [

tuple(tensor_shape.TensorShape(shape).as_list())

for shape in output_shapes

]

else:

raise AttributeError('The layer "%s"'

' has multiple inbound nodes, '

'with different output shapes. Hence '

'the notion of "output shape" is '

'ill-defined for the layer. '

'Use `get_output_shape_at(node_index)` '

'instead.' % self.name)

@property

def inbound_nodes(self):

"""Deprecated, do NOT use! Only for compatibility with external Keras."""

return self._inbound_nodes

@property

def outbound_nodes(self):

"""Deprecated, do NOT use! Only for compatibility with external Keras."""

return self._outbound_nodes

def _assert_input_compatibility(self, inputs):

"""Checks compatibility between the layer and provided inputs.

if not self.input_spec:

return