"""Formats a value input for gen_nn_ops."""

# Performance is fast-pathed for common cases:

# `None`, `list`, `tuple` and `int`.

if value is None:

return [1] * (n + 2)

# Always convert `value` to a `list`.

if isinstance(value, list):

pass

elif isinstance(value, tuple):

value = list(value)

elif isinstance(value, int):

value = [value]

elif not isinstance(value, collections_abc.Sized):

value = [value]

else:

value = list(value) # Try casting to a list.

len_value = len(value)

# Fully specified, including batch and channel dims.

if len_value == n + 2:

return value

# Apply value to spatial dims only.

if len_value == 1:

value = value * n # Broadcast to spatial dimensions.

elif len_value != n:

raise ValueError(f"{name} should be of length 1, {n} or {n + 2}. "

f"Received: {name}={value} of length {len_value}")

# Add batch and channel dims (always 1).

if channel_index == 1:

return [1, 1] + value

else:

input, # pylint: disable=redefined-builtin

filter, # pylint: disable=redefined-builtin

padding,

data_format=None, # pylint: disable=redefined-builtin

strides=None,

name=None):

"""Computes sums of N-D convolutions (actually cross correlation).

with ops.name_scope(name, "non_atrous_convolution", [input, filter]) as scope:

input = ops.convert_to_tensor(input, name="input") # pylint: disable=redefined-builtin

input_shape = input.shape

filter = ops.convert_to_tensor(filter, name="filter") # pylint: disable=redefined-builtin

filter_shape = filter.shape

op = _NonAtrousConvolution(

input_shape,

filter_shape=filter_shape,

padding=padding,

data_format=data_format,

strides=strides,

name=scope)

"""Helper class for _non_atrous_convolution.

def __init__(

self,

input_shape,

filter_shape,

padding,

data_format=None,

strides=None,

name=None,

num_batch_dims=1):

# filter shape is always rank num_spatial_dims + 2

# and num_spatial_dims == input_shape.ndims - num_batch_dims - 1

if input_shape.ndims is not None:

filter_shape = filter_shape.with_rank(

input_shape.ndims - num_batch_dims + 1)

self.padding = padding

self.name = name

# input shape is == num_spatial_dims + num_batch_dims + 1

# and filter_shape is always rank num_spatial_dims + 2

if filter_shape.ndims is not None:

input_shape = input_shape.with_rank(

filter_shape.ndims + num_batch_dims - 1)

if input_shape.ndims is None:

raise ValueError(

"Rank of convolution must be known. "

f"Received: input_shape={input_shape} of rank {input_shape.rank}")

if input_shape.ndims < 3 or input_shape.ndims - num_batch_dims + 1 > 5:

raise ValueError(

"`input_shape.rank - num_batch_dims + 1` must be at least 3 and at "

f"most 5. Received: input_shape.rank={input_shape.rank} and "

f"num_batch_dims={num_batch_dims}")

conv_dims = input_shape.ndims - num_batch_dims - 1

if strides is None:

strides = [1] * conv_dims

elif len(strides) != conv_dims:

raise ValueError(

f"`len(strides)` should be {conv_dims}. "

f"Received: strides={strides} of length {len(strides)}")

if conv_dims == 1:

# conv1d uses the 2-d data format names

if data_format is None:

data_format = "NWC"

elif data_format not in {"NCW", "NWC", "NCHW", "NHWC"}:

raise ValueError("`data_format` must be 'NWC' or 'NCW'. "

f"Received: data_format={data_format}")

self.strides = strides[0]

self.data_format = data_format

self.conv_op = self._conv1d

elif conv_dims == 2:

if data_format is None or data_format == "NHWC":

data_format = "NHWC"

strides = [1] + list(strides) + [1]

elif data_format == "NCHW":

strides = [1, 1] + list(strides)

else:

raise ValueError("`data_format` must be 'NHWC' or 'NCHW'. "

f"Received: data_format={data_format}")

self.strides = strides

self.data_format = data_format

self.conv_op = conv2d

elif conv_dims == 3:

if data_format is None or data_format == "NDHWC":

strides = [1] + list(strides) + [1]

elif data_format == "NCDHW":

strides = [1, 1] + list(strides)

else:

raise ValueError("`data_format` must be 'NDHWC' or 'NCDHW'. "

f"Received: data_format={data_format}")

self.strides = strides

self.data_format = data_format

self.conv_op = _conv3d_expanded_batch

# Note that we need this adapter since argument names for conv1d don't match

# those for gen_nn_ops.conv2d and gen_nn_ops.conv3d.

# pylint: disable=redefined-builtin

def _conv1d(self, input, filter, strides, padding, data_format, name):

return conv1d(

value=input,

filters=filter,

stride=strides,

padding=padding,

data_format=data_format,

name=name)

# pylint: enable=redefined-builtin

def __call__(self, inp, filter): # pylint: disable=redefined-builtin

return self.conv_op(

input=inp,

filter=filter,

strides=self.strides,

padding=self.padding,

data_format=self.data_format,

"""Returns `unsqueeze_batch(op(squeeze_batch(inp)))`.

with ops.name_scope(name, "squeeze_batch_dims", [inp]):

inp = ops.convert_to_tensor(inp, name="input")

shape = inp.shape

inner_shape = shape[-inner_rank:]

if not inner_shape.is_fully_defined():

inner_shape = array_ops.shape(inp)[-inner_rank:]

batch_shape = shape[:-inner_rank]

if not batch_shape.is_fully_defined():

batch_shape = array_ops.shape(inp)[:-inner_rank]

if isinstance(inner_shape, tensor_shape.TensorShape):

inp_reshaped = array_ops.reshape(inp, [-1] + inner_shape.as_list())

else:

inp_reshaped = array_ops.reshape(

inp, array_ops.concat(([-1], inner_shape), axis=-1))

out_reshaped = op(inp_reshaped)

out_inner_shape = out_reshaped.shape[-inner_rank:]

if not out_inner_shape.is_fully_defined():

out_inner_shape = array_ops.shape(out_reshaped)[-inner_rank:]

out = array_ops.reshape(

out_reshaped, array_ops.concat((batch_shape, out_inner_shape), axis=-1))

out.set_shape(inp.shape[:-inner_rank] + out.shape[-inner_rank:])

input, # pylint: disable=redefined-builtin

filters, # pylint: disable=redefined-builtin

strides,

padding,

data_format,

dilations,

name=None):

"""Computes the grayscale dilation of 4-D `input` and 3-D `filters` tensors.

if data_format != "NHWC":

raise ValueError("`data_format` values other than 'NHWC' are not "

f"supported. Received: data_format={data_format}")

return gen_nn_ops.dilation2d(input=input,

filter=filters,

strides=strides,

rates=dilations,

padding=padding,

input, # pylint: disable=redefined-builtin

filter=None, # pylint: disable=redefined-builtin

strides=None,

rates=None,

padding=None,

name=None,

filters=None,

dilations=None):

filter = deprecated_argument_lookup("filters", filters, "filter", filter)

rates = deprecated_argument_lookup("dilations", dilations, "rates", rates)

input, # pylint: disable=redefined-builtin

dilation_rate,

padding,

op,

filter_shape=None,

spatial_dims=None,

data_format=None):

"""Performs `op` on the space-to-batch representation of `input`.

input = ops.convert_to_tensor(input, name="input") # pylint: disable=redefined-builtin

input_shape = input.shape

def build_op(num_spatial_dims, padding):

return lambda inp, _: op(inp, num_spatial_dims, padding)

new_op = _WithSpaceToBatch(

input_shape,

dilation_rate,

padding,

build_op,

filter_shape=filter_shape,

spatial_dims=spatial_dims,

data_format=data_format)

"""Helper class for with_space_to_batch.

def __init__(self,

input_shape,

dilation_rate,

padding,

build_op,

filter_shape=None,

spatial_dims=None,

data_format=None,

num_batch_dims=1):

"""Helper class for _with_space_to_batch."""

dilation_rate = ops.convert_to_tensor(

dilation_rate, dtypes.int32, name="dilation_rate")

if dilation_rate.shape.ndims not in (None, 1):

raise ValueError(

"`dilation_rate.shape.rank` must be 1. Received: "

f"dilation_rate={dilation_rate} of rank {dilation_rate.shape.rank}")

if not dilation_rate.shape.is_fully_defined():

raise ValueError(

"`dilation_rate.shape` must be fully defined. Received: "

f"dilation_rate={dilation_rate} with shape "

f"{dilation_rate.shape}")

num_spatial_dims = dilation_rate.shape.dims[0].value

if data_format is not None and data_format.startswith("NC"):

starting_spatial_dim = num_batch_dims + 1

else:

starting_spatial_dim = num_batch_dims

if spatial_dims is None:

spatial_dims = range(starting_spatial_dim,

num_spatial_dims + starting_spatial_dim)

orig_spatial_dims = list(spatial_dims)

spatial_dims = sorted(set(int(x) for x in orig_spatial_dims))

if spatial_dims != orig_spatial_dims or any(x < 1 for x in spatial_dims):

raise ValueError(

"`spatial_dims` must be a monotonically increasing sequence of "

f"positive integers. Received: spatial_dims={orig_spatial_dims}")

if data_format is not None and data_format.startswith("NC"):

expected_input_rank = spatial_dims[-1]

else:

expected_input_rank = spatial_dims[-1] + 1

try:

input_shape.with_rank_at_least(expected_input_rank)

except ValueError:

raise ValueError(

f"`input.shape.rank` must be at least {expected_input_rank}. "

f"Received: input.shape={input_shape} with rank {input_shape.rank}")

const_rate = tensor_util.constant_value(dilation_rate)

rate_or_const_rate = dilation_rate

if const_rate is not None:

rate_or_const_rate = const_rate

if np.any(const_rate < 1):

raise ValueError(

"`dilation_rate` must be positive. "

f"Received: dilation_rate={const_rate}")

if np.all(const_rate == 1):

self.call = build_op(num_spatial_dims, padding)

return

padding, explicit_paddings = convert_padding(padding)

# We have two padding contributions. The first is used for converting "SAME"

# to "VALID". The second is required so that the height and width of the

# zero-padded value tensor are multiples of rate.

# Padding required to reduce to "VALID" convolution

if padding == "SAME":

if filter_shape is None:

raise ValueError(

"`filter_shape` must be specified for `padding='SAME'`. "

f"Received: filter_shape={filter_shape} and padding={padding}")

filter_shape = ops.convert_to_tensor(filter_shape, name="filter_shape")

const_filter_shape = tensor_util.constant_value(filter_shape)

if const_filter_shape is not None:

filter_shape = const_filter_shape

self.base_paddings = _with_space_to_batch_base_paddings(

const_filter_shape, num_spatial_dims, rate_or_const_rate)

else:

self.num_spatial_dims = num_spatial_dims

self.rate_or_const_rate = rate_or_const_rate

self.base_paddings = None

elif padding == "VALID":

self.base_paddings = np.zeros([num_spatial_dims, 2], np.int32)

elif padding == "EXPLICIT":

base_paddings = (np.array(explicit_paddings)

.reshape([num_spatial_dims + 2, 2]))

# Remove batch and channel dimensions

if data_format is not None and data_format.startswith("NC"):

self.base_paddings = base_paddings[2:]

else:

self.base_paddings = base_paddings[1:-1]

else:

raise ValueError("`padding` must be one of 'SAME' or 'VALID'. "

f"Received: padding={padding}")

self.input_shape = input_shape

self.spatial_dims = spatial_dims

self.dilation_rate = dilation_rate

self.data_format = data_format

self.op = build_op(num_spatial_dims, "VALID")

self.call = self._with_space_to_batch_call

def _with_space_to_batch_call(self, inp, filter): # pylint: disable=redefined-builtin

"""Call functionality for with_space_to_batch."""

# Handle input whose shape is unknown during graph creation.

input_spatial_shape = None

input_shape = self.input_shape

spatial_dims = self.spatial_dims

if input_shape.ndims is not None:

input_shape_list = input_shape.as_list()

input_spatial_shape = [input_shape_list[i] for i in spatial_dims]

if input_spatial_shape is None or None in input_spatial_shape:

input_shape_tensor = array_ops.shape(inp)

input_spatial_shape = array_ops_stack.stack(

[input_shape_tensor[i] for i in spatial_dims])

base_paddings = self.base_paddings

if base_paddings is None:

# base_paddings could not be computed at build time since static filter

# shape was not fully defined.

filter_shape = array_ops.shape(filter)

base_paddings = _with_space_to_batch_base_paddings(

filter_shape, self.num_spatial_dims, self.rate_or_const_rate)

paddings, crops = array_ops.required_space_to_batch_paddings(

input_shape=input_spatial_shape,

base_paddings=base_paddings,

block_shape=self.dilation_rate)

dilation_rate = _with_space_to_batch_adjust(self.dilation_rate, 1,

spatial_dims)

paddings = _with_space_to_batch_adjust(paddings, 0, spatial_dims)

crops = _with_space_to_batch_adjust(crops, 0, spatial_dims)

input_converted = array_ops.space_to_batch_nd(

input=inp, block_shape=dilation_rate, paddings=paddings)

result = self.op(input_converted, filter)

result_converted = array_ops.batch_to_space_nd(

input=result, block_shape=dilation_rate, crops=crops)

# Recover channel information for output shape if channels are not last.

if self.data_format is not None and self.data_format.startswith("NC"):

if not result_converted.shape.dims[1].value and filter is not None:

output_shape = result_converted.shape.as_list()

output_shape[1] = filter.shape[-1]

result_converted.set_shape(output_shape)

return result_converted

def __call__(self, inp, filter): # pylint: disable=redefined-builtin

rate_or_const_rate):

"""Helper function to compute base_paddings."""

# Spatial dimensions of the filters and the upsampled filters in which we

# introduce (rate - 1) zeros between consecutive filter values.

filter_spatial_shape = filter_shape[:num_spatial_dims]

pad_extra_shape = (filter_spatial_shape - 1) * rate_or_const_rate

# When full_padding_shape is odd, we pad more at end, following the same

# convention as conv2d.

pad_extra_start = pad_extra_shape // 2

pad_extra_end = pad_extra_shape - pad_extra_start

base_paddings = array_ops_stack.stack(

[[pad_extra_start[i], pad_extra_end[i]] for i in range(num_spatial_dims)])

"""Returns an `adjusted` version of `orig` based on `spatial_dims`.

fill_dims = orig.get_shape().as_list()[1:]

dtype = orig.dtype.as_numpy_dtype

parts = []

const_orig = tensor_util.constant_value(orig)

const_or_orig = const_orig if const_orig is not None else orig

prev_spatial_dim = 0

i = 0

while i < len(spatial_dims):

start_i = i

start_spatial_dim = spatial_dims[i]

if start_spatial_dim > 1:

# Fill in any gap from the previous spatial dimension (or dimension 1 if

# this is the first spatial dimension) with `fill_value`.

parts.append(

np.full(

[start_spatial_dim - 1 - prev_spatial_dim] + fill_dims,

fill_value,

dtype=dtype))

# Find the largest value of i such that:

# [spatial_dims[start_i], ..., spatial_dims[i]]

# == [start_spatial_dim, ..., start_spatial_dim + i - start_i],

# i.e. the end of a contiguous group of spatial dimensions.

while (i + 1 < len(spatial_dims) and

spatial_dims[i + 1] == spatial_dims[i] + 1):

i += 1

parts.append(const_or_orig[start_i:i + 1])

prev_spatial_dim = spatial_dims[i]

i += 1

if const_orig is not None:

return np.concatenate(parts)

else:

"""Helper function for verifying strides and dilation_rate arguments.