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")

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

filter_shape = filter.get_shape().with_rank(input.get_shape().ndims)

input_shape = input.get_shape().with_rank(filter_shape.ndims)

if input_shape.ndims is None:

raise ValueError("Rank of convolution must be known")

if input_shape.ndims < 3 or input_shape.ndims > 5:

raise ValueError(

"`input` and `filter` must have rank at least 3 and at most 5")

conv_dims = input_shape.ndims - 2

if strides is None:

strides = [1] * conv_dims

elif len(strides) != conv_dims:

raise ValueError("len(strides)=%d, but should be %d" %

(len(strides), conv_dims))

if conv_dims == 1:

# conv1d uses the 2-d data format names

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

data_format_2d = "NHWC"

elif data_format == "NCW":

data_format_2d = "NCHW"

else:

raise ValueError("data_format must be \"NWC\" or \"NCW\".")

return conv1d(

value=input,

filters=filter,

stride=strides[0],

padding=padding,

data_format=data_format_2d,

name=scope)

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\".")

return gen_nn_ops.conv2d(

input=input,

filter=filter,

strides=strides,

padding=padding,

data_format=data_format,

name=name)

elif conv_dims == 3:

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

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

else:

raise ValueError("data_format must be \"NDHWC\".")

return gen_nn_ops.conv3d(

input=input,

filter=filter,

strides=strides,

padding=padding,

spatial_dims=None):

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

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

dilation_rate = ops.convert_to_tensor(dilation_rate,

dtypes.int32,

name="dilation_rate")

try:

rate_shape = dilation_rate.get_shape().with_rank(1)

except ValueError:

raise ValueError("rate must be rank 1")

if not dilation_rate.get_shape().is_fully_defined():

raise ValueError("rate must have known shape")

num_spatial_dims = rate_shape[0].value

if spatial_dims is None:

spatial_dims = range(1, num_spatial_dims + 1)

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 montonically increasing sequence of positive integers") # pylint: disable=line-too-long

last_spatial_dim = spatial_dims[-1]

try:

input.get_shape().with_rank_at_least(last_spatial_dim + 1)

except ValueError:

ValueError("input tensor must have rank %d at least" %

(last_spatial_dim + 1))

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")

if np.all(const_rate == 1):

return op(input, num_spatial_dims, 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 SAME 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

# 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]

dilated_filter_spatial_shape = (filter_spatial_shape +

(filter_spatial_shape - 1) *

(rate_or_const_rate - 1))

pad_extra_shape = dilated_filter_spatial_shape - 1

# 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.pack([[pad_extra_start[i], pad_extra_end[i]]

for i in range(num_spatial_dims)])

elif padding == "VALID":

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

else:

raise ValueError("Invalid padding method %r" % padding)

# Handle input whose shape is unknown during graph creation.

input_spatial_shape = None

if input.get_shape().ndims is not None:

input_shape_list = input.get_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_spatial_shape = array_ops.gather(array_ops.shape(input), spatial_dims)

paddings, crops = array_ops.required_space_to_batch_paddings(

input_shape=input_spatial_shape,

base_paddings=base_paddings,

block_shape=dilation_rate)

def adjust(orig, fill_value):

"""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:

return array_ops.concat(0, parts)

dilation_rate = adjust(dilation_rate, 1)

paddings = adjust(paddings, 0)

crops = adjust(crops, 0)

input_converted = array_ops.space_to_batch_nd(

input=input,

block_shape=dilation_rate,

paddings=paddings)

result = op(input_converted, num_spatial_dims, "VALID")

result_converted = array_ops.batch_to_space_nd(

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

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

if dilation_rate is None:

dilation_rate = [1] * num_spatial_dims

elif len(dilation_rate) != num_spatial_dims:

raise ValueError("len(dilation_rate)=%d but should be %d" %

(len(dilation_rate), num_spatial_dims))

dilation_rate = np.array(dilation_rate, dtype=np.int32)

if np.any(dilation_rate < 1):

raise ValueError("all values of dilation_rate must be positive")

if strides is None:

strides = [1] * num_spatial_dims

elif len(strides) != num_spatial_dims:

raise ValueError("len(strides)=%d but should be %d" %

(len(strides), num_spatial_dims))

strides = np.array(strides, dtype=np.int32)

if np.any(strides < 1):

raise ValueError("all values of strides must be positive")

if np.any(strides > 1) and np.any(dilation_rate > 1):

raise ValueError(

"strides > 1 not supported in conjunction with dilation_rate > 1")

padding, strides=None, dilation_rate=None,

name=None, data_format=None):

# pylint: disable=line-too-long

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

# pylint: enable=line-too-long

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

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

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

num_total_dims = filter.get_shape().ndims

if num_total_dims is None:

num_total_dims = input.get_shape().ndims

if num_total_dims is None:

raise ValueError("rank of input or filter must be known")

num_spatial_dims = num_total_dims - 2

try:

input.get_shape().with_rank(num_spatial_dims + 2)

except ValueError:

ValueError("input tensor must have rank %d" % (num_spatial_dims + 2))

try:

filter.get_shape().with_rank(num_spatial_dims + 2)

except ValueError:

ValueError("filter tensor must have rank %d" % (num_spatial_dims + 2))

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

input_channels_dim = input.get_shape()[num_spatial_dims + 1]

spatial_dims = range(1, num_spatial_dims+1)

else:

input_channels_dim = input.get_shape()[1]

spatial_dims = range(2, num_spatial_dims+2)

if not input_channels_dim.is_compatible_with(filter.get_shape()[

num_spatial_dims]):

raise ValueError(

"number of input channels does not match corresponding dimension of filter, "

"{} != {}".format(input_channels_dim, filter.get_shape()[

num_spatial_dims]))

strides, dilation_rate = _get_strides_and_dilation_rate(

num_spatial_dims, strides, dilation_rate)

def op(input_converted, _, padding):

return _non_atrous_convolution(

input=input_converted,

filter=filter,

padding=padding,

data_format=data_format,

strides=strides,

name=name)

return with_space_to_batch(

input=input,

filter_shape=array_ops.shape(filter),

spatial_dims=spatial_dims,

dilation_rate=dilation_rate,

padding=padding,

window_shape,

pooling_type,

padding,

dilation_rate=None,

strides=None,

name=None,

data_format=None):

# pylint: disable=line-too-long

"""Performs an N-D pooling operation.

# pylint: enable=line-too-long

with ops.name_scope(name, "%s_pool" %

(pooling_type.lower()), [input]) as scope:

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

num_spatial_dims = len(window_shape)

if num_spatial_dims < 1 or num_spatial_dims > 3:

raise ValueError("It is required that 1 <= num_spatial_dims <= 3.")

input.get_shape().with_rank(num_spatial_dims + 2)

strides, dilation_rate = _get_strides_and_dilation_rate(

num_spatial_dims, strides, dilation_rate)

if padding == "SAME" and np.any(dilation_rate > 1):

raise ValueError(

"pooling with SAME padding is not implemented for dilation_rate > 1")

if np.any(strides > window_shape):

raise ValueError(

"strides > window_shape not supported due to inconsistency between "

"CPU and GPU implementations")

pooling_ops = {("MAX", 1): max_pool,

("MAX", 2): max_pool,

("MAX", 3): max_pool3d, # pylint: disable=undefined-variable

("AVG", 1): avg_pool,

("AVG", 2): avg_pool,

("AVG", 3): avg_pool3d, # pylint: disable=undefined-variable

}

op_key = (pooling_type, num_spatial_dims)

if op_key not in pooling_ops:

raise ValueError("%d-D %s pooling is not supported." %

(op_key[1], op_key[0]))

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

adjusted_window_shape = [1] + list(window_shape) + [1]

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

spatial_dims = range(1, num_spatial_dims + 1)

else:

adjusted_window_shape = [1, 1] + list(window_shape)

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

spatial_dims = range(2, num_spatial_dims + 2)

if num_spatial_dims == 3:

if data_format is not None and data_format != "NDHWC":

raise ValueError("data_format must be \"NDHWC\".")

data_format_kwargs = dict()

elif num_spatial_dims == 1:

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

data_format_kwargs = dict(data_format="NHWC")

elif data_format == "NCW":

data_format_kwargs = dict(data_format="NCHW")

else:

raise ValueError("data_format must be either \"NWC\" or \"NCW\".")

adjusted_window_shape = [1] + adjusted_window_shape

adjusted_strides = [1] + adjusted_strides

else:

data_format_kwargs = dict(data_format=data_format)

def op(converted_input, _, converted_padding): # pylint: disable=missing-docstring

if num_spatial_dims == 1:

converted_input = array_ops.expand_dims(converted_input,

spatial_dims[0])

result = pooling_ops[op_key](converted_input,

adjusted_window_shape,

adjusted_strides,

converted_padding,

name=scope,

**data_format_kwargs)

if num_spatial_dims == 1:

result = array_ops.squeeze(result, [spatial_dims[0]])

return result

return with_space_to_batch(

input=input,

dilation_rate=dilation_rate,

padding=padding,

op=op,

spatial_dims=spatial_dims,

"""Atrous convolution (a.k.a. convolution with holes or dilated convolution).

with ops.name_scope(name, "atrous_conv2d", [value, filters]) as name:

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

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

if not value.get_shape()[3].is_compatible_with(filters.get_shape()[2]):

raise ValueError(

"value's input channels does not match filters' input channels, "

"{} != {}".format(value.get_shape()[3], filters.get_shape()[2]))

if rate < 1:

raise ValueError("rate {} cannot be less than one".format(rate))

if rate == 1:

value = gen_nn_ops.conv2d(input=value,

filter=filters,

strides=[1, 1, 1, 1],

padding=padding)

return value

# 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":

# Handle filters whose shape is unknown during graph creation.

if filters.get_shape().is_fully_defined():

filter_shape = filters.get_shape().as_list()

else:

filter_shape = array_ops.shape(filters)

filter_height, filter_width = filter_shape[0], filter_shape[1]

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

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

filter_height_up = filter_height + (filter_height - 1) * (rate - 1)

filter_width_up = filter_width + (filter_width - 1) * (rate - 1)

pad_height = filter_height_up - 1

pad_width = filter_width_up - 1

# When pad_height (pad_width) is odd, we pad more to bottom (right),

# following the same convention as conv2d().

pad_top = pad_height // 2

pad_bottom = pad_height - pad_top

pad_left = pad_width // 2

pad_right = pad_width - pad_left

elif padding == "VALID":

pad_top = 0

pad_bottom = 0

pad_left = 0

pad_right = 0

else:

raise ValueError("Invalid padding")

# Handle input whose shape is unknown during graph creation.

if value.get_shape().is_fully_defined():

value_shape = value.get_shape().as_list()

else:

value_shape = array_ops.shape(value)

in_height = value_shape[1] + pad_top + pad_bottom

in_width = value_shape[2] + pad_left + pad_right

# More padding so that rate divides the height and width of the input.

pad_bottom_extra = (rate - in_height % rate) % rate

pad_right_extra = (rate - in_width % rate) % rate

# The paddings argument to space_to_batch includes both padding components.

space_to_batch_pad = [[pad_top, pad_bottom + pad_bottom_extra],

[pad_left, pad_right + pad_right_extra]]

value = array_ops.space_to_batch(input=value,

paddings=space_to_batch_pad,

block_size=rate)

value = gen_nn_ops.conv2d(input=value,

filter=filters,

strides=[1, 1, 1, 1],

padding="VALID",

name=name)

# The crops argument to batch_to_space is just the extra padding component.

batch_to_space_crop = [[0, pad_bottom_extra], [0, pad_right_extra]]

value = array_ops.batch_to_space(input=value,