o NeN@sdZddlZddlZddlmmZddlm Z ddZ dddZ dd d Z d d Z   d ddZddZddZddZddZddZddZddZdS)!z%Utilities used by convolution layers.N)backendcCs|dkr|dkr dS|dkrdS|dkrdStd|d |d kr<|dkr(d S|dkr.d S|dkr4d Std|d td|d)N channels_lastZNWCZNHWCZNDHWCzInput rank not supported: z. Expected values are [3, 4, 5]channels_firstZNCWZNCHWZNCDHWzInvalid data_format: z9. Expected values are ["channels_first", "channels_last"]) ValueError) data_formatndimr FD:\Projects\ConvertPro\env\Lib\site-packages\keras/utils/conv_utils.pyconvert_data_formats.   r Fc Csd|d|d|}t|tr|f|}n@zt|}Wn ty't|wt||kr2t||D]!}zt|Wq4ttfyU|d|dt|7}t|w|rbdd|D}d}n d d|D}d }|r||d |d |d 7}t||S)aTransforms non-negative/positive integer/integers into an integer tuple. Args: value: The value to validate and convert. Could an int, or any iterable of ints. n: The size of the tuple to be returned. name: The name of the argument being validated, e.g. "strides" or "kernel_size". This is only used to format error messages. allow_zero: Default to False. A ValueError will raised if zero is received and this param is False. Returns: A tuple of n integers. Raises: ValueError: If something else than an int/long or iterable thereof or a negative value is passed. zThe `z` argument must be a tuple of z integers. Received: zincluding element z of type cSsh|]}|dkr|qSrr .0vr r r fz"normalize_tuple..z>= 0cSsh|]}|dkr|qSrr rr r r rirz> 0z including z( that does not satisfy the requirement `z`.) isinstanceinttuple TypeErrorrlentype) valuennameZ allow_zero error_msgZ value_tupleZ single_valueZunqualified_valuesZreq_msgr r r normalize_tuple9sJ      rcCst|durdS|dvs J||d|d}|dvr|}n|dkr(||d}n |dkr2||d}||d|S)a:Determines output length of a convolution given input length. Args: input_length: integer. filter_size: integer. padding: one of "same", "valid", "full", "causal" stride: integer. dilation: dilation rate, integer. Returns: The output length (integer). N>validcausalsamefullr)r"r!r r#r ) input_length filter_sizepaddingstridedilationZdilated_filter_size output_lengthr r r conv_output_lengthvs   r*cCs`|durdS|dvs J|dkr|d}n|dkrd}n|dkr$|d}|d|d||S) aDetermines input length of a convolution given output length. Args: output_length: integer. filter_size: integer. padding: one of "same", "valid", "full". stride: integer. Returns: The input length (integer). N>r r"r#r"r rr#rr )r)r%r&r'padr r r conv_input_lengths   r-cCs|dvsJ|dur dS||d|d}|durE|dkr+||t||d}|S|dkr;||||d}|S|dkrC||}|S|dkrN|d}n|dkrUd}n|dkr]|d}|d||d||}|S) aDetermines output length of a transposed convolution given input length. Args: input_length: Integer. filter_size: Integer. padding: one of `"same"`, `"valid"`, `"full"`. output_padding: Integer, amount of padding along the output dimension. Can be set to `None` in which case the output length is inferred. stride: Integer. dilation: Integer. Returns: The output length (integer). >r r"r#Nrr rr#r+r")max)r$r%r&Zoutput_paddingr'r(lengthr,r r r deconv_output_lengths.   r0cCs2|durt}|}|dvrtd||S)N>rrzWThe `data_format` argument must be one of "channels_first", "channels_last". Received: )rZimage_data_formatlowerr)rr r r r normalize_data_formatsr2cCs4t|ttfr |S|}|dvrtd||S)N>r r!r"zqThe `padding` argument must be a list/tuple or one of "valid", "same" (or "causal", only for `Conv1D). Received: )rlistrr1r)rr&r r r normalize_paddingsr4cCs|dvr td|dt|}t|tr|f|}t|tr$|f|}t|}t|}||ks4||krAtd|d|d|t||||}||}t|tj} dd|D} t j | D]} t ||| ||} t j | D]} d | | | <qnq_| S) aCompute a mask representing the connectivity of a convolution operation. Assume a convolution with given parameters is applied to an input having N spatial dimensions with `input_shape = (d_in1, ..., d_inN)` to produce an output with shape `(d_out1, ..., d_outN)`. This method returns a boolean array of shape `(d_in1, ..., d_inN, d_out1, ..., d_outN)` with `True` entries indicating pairs of input and output locations that are connected by a weight. Example: >>> input_shape = (4,) >>> kernel_shape = (2,) >>> strides = (1,) >>> padding = "valid" >>> conv_kernel_mask(input_shape, kernel_shape, strides, padding) array([[ True, False, False], [ True, True, False], [False, True, True], [False, False, True]]) where rows and columns correspond to inputs and outputs respectively. Args: input_shape: tuple of size N: `(d_in1, ..., d_inN)`, spatial shape of the input. kernel_shape: tuple of size N, spatial shape of the convolutional kernel / receptive field. strides: tuple of size N, strides along each spatial dimension. padding: type of padding, string `"same"` or `"valid"`. `"valid"` means no padding. `"same"` results in padding evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. Returns: A boolean 2N-D `np.ndarray` of shape `(d_in1, ..., d_inN, d_out1, ..., d_outN)`, where `(d_out1, ..., d_outN)` is the spatial shape of the output. `True` entries in the mask represent pairs of input-output locations that are connected by a weight. Raises: ValueError: if `input_shape`, `kernel_shape` and `strides` don't have the same number of dimensions. NotImplementedError: if `padding` is not in {`"same"`, `"valid"`}. >r r" Padding type 8 not supported. Only "valid" and "same" are implemented.UNumber of strides, input and kernel dimensions must all match. Received: stride_dims= , in_dims=, kernel_dims=cSg|]}t|qSr rangerdimr r r @z$conv_kernel_mask..T) NotImplementedErrorrrrrconv_output_shapenpZzerosbool itertoolsproductconv_connected_inputs) input_shape kernel_shapestridesr&in_dims kernel_dims stride_dims output_shapeZ mask_shapemaskoutput_axes_ticksoutput_positioninput_axes_ticksinput_positionr r r conv_kernel_masksF/      rTc csb|dvr td|dt|}t|tr|f|}t|tr%|f|}t|}t|} ||ks5| |krBtd| d|d|t||||} dd| D} |d krYd d } n|d krbd d } ntd|dtj| D]?} t||| ||}tj|D]/}t |D](}t |D]!}t j | | || | |d}t j | ||| ||d}||fVqqq~qodS)a'Yields output-input tuples of indices in a CNN layer. The generator iterates over all `(output_idx, input_idx)` tuples, where `output_idx` is an integer index in a flattened tensor representing a single output image of a convolutional layer that is connected (via the layer weights) to the respective single input image at `input_idx` Example: >>> input_shape = (2, 2) >>> kernel_shape = (2, 1) >>> strides = (1, 1) >>> padding = "valid" >>> filters_in = 1 >>> filters_out = 1 >>> data_format = "channels_last" >>> list(conv_kernel_idxs(input_shape, kernel_shape, strides, padding, ... filters_in, filters_out, data_format)) [(0, 0), (0, 2), (1, 1), (1, 3)] Args: input_shape: tuple of size N: `(d_in1, ..., d_inN)`, spatial shape of the input. kernel_shape: tuple of size N, spatial shape of the convolutional kernel / receptive field. strides: tuple of size N, strides along each spatial dimension. padding: type of padding, string `"same"` or `"valid"`. `"valid"` means no padding. `"same"` results in padding evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. filters_in: `int`, number if filters in the input to the layer. filters_out: `int', number if filters in the output of the layer. data_format: string, "channels_first" or "channels_last". Yields: The next tuple `(output_idx, input_idx)`, where `output_idx` is an integer index in a flattened tensor representing a single output image of a convolutional layer that is connected (via the layer weights) to the respective single input image at `input_idx`. Raises: ValueError: if `data_format` is neither `"channels_last"` nor `"channels_first"`, or if number of strides, input, and kernel number of dimensions do not match. NotImplementedError: if `padding` is neither `"same"` nor `"valid"`. )r"r r5r6r7r8r9cSr:r r;r=r r r r?r@z$conv_kernel_idxs..rcSs |f|SNr Z spatial_idxZ filter_idxr r r s z"conv_kernel_idxs..rcSs ||fSrUr rVr r r rWsz Data format `zK` not recognized.`data_format` must be "channels_first" or "channels_last".)Z multi_indexdimsN) rArrrrrBrErFrGr<rCZravel_multi_index)rHrIrJr&Z filters_inZ filters_outr rKrLrMrNrPZ concat_idxsrQrRrSZf_inZf_outZout_idxZin_idxr r r conv_kernel_idxsKsl8           rYc Csg}t|}t|D]8}t||d}|||} ||||} |dkr*| |7} td| |} t||| | } |t| | q |S)a%Return locations of the input connected to an output position. Assume a convolution with given parameters is applied to an input having N spatial dimensions with `input_shape = (d_in1, ..., d_inN)`. This method returns N ranges specifying the input region that was convolved with the kernel to produce the output at position `output_position = (p_out1, ..., p_outN)`. Example: >>> input_shape = (4, 4) >>> kernel_shape = (2, 1) >>> output_position = (1, 1) >>> strides = (1, 1) >>> padding = "valid" >>> conv_connected_inputs(input_shape, kernel_shape, output_position, ... strides, padding) [range(1, 3), range(1, 2)] Args: input_shape: tuple of size N: `(d_in1, ..., d_inN)`, spatial shape of the input. kernel_shape: tuple of size N, spatial shape of the convolutional kernel / receptive field. output_position: tuple of size N: `(p_out1, ..., p_outN)`, a single position in the output of the convolution. strides: tuple of size N, strides along each spatial dimension. padding: type of padding, string `"same"` or `"valid"`. `"valid"` means no padding. `"same"` results in padding evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. Returns: N ranges `[[p_in_left1, ..., p_in_right1], ..., [p_in_leftN, ..., p_in_rightN]]` specifying the region in the input connected to output_position. r+r r)rr<rr.minappend) rHrIrQrJr&rangesZndimsdZ left_shiftZ right_shiftcenterstartendr r r rGs(  rGcs@tt}fdd|Dtfdd|DS)aReturn the output shape of an N-D convolution. Forces dimensions where input is empty (size 0) to remain empty. Args: input_shape: tuple of size N: `(d_in1, ..., d_inN)`, spatial shape of the input. kernel_shape: tuple of size N, spatial shape of the convolutional kernel / receptive field. strides: tuple of size N, strides along each spatial dimension. padding: type of padding, string `"same"` or `"valid"`. `"valid"` means no padding. `"same"` results in padding evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. Returns: tuple of size N: `(d_out1, ..., d_outN)`, spatial shape of the output. cs&g|]}t|||qSr )r*rr])rHrIr&rJr r r? sz%conv_output_shape..cs$g|]}|dkr dn|qSrr ra)rHrNr r r?s$)r<rr)rHrIrJr&rXr )rHrIrNr&rJr rBs rBc Cs@td|j}|| d}|st|| d}|d| }|s3t|d| }t|tjrEt|dg|}nt|tjdg|fdd}||}|j| d}|smt|| d}t|tj||fdd} | |jd| | j| d| WdS1swYdS)a.Returns `unsqueeze_batch(op(squeeze_batch(inp)))`. Where `squeeze_batch` reshapes `inp` to shape `[prod(inp.shape[:-inner_rank])] + inp.shape[-inner_rank:]` and `unsqueeze_batch` does the reverse reshape but on the output. Args: inp: A tensor with dims `batch_shape + inner_shape` where `inner_shape` is length `inner_rank`. op: A callable that takes a single input tensor and returns a single. output tensor. inner_rank: A python integer. Returns: `unsqueeze_batch_op(squeeze_batch(inp))`. squeeze_batch_dimsN)Zaxis) tfZ name_scopeshapeZis_fully_definedrZ TensorShapeZreshapeas_listconcat set_shape) inpopZ inner_rankreZ inner_shapeZ batch_shapeZ inp_reshapedZ out_reshapedZout_inner_shapeoutr r r rbs.  &$rb)F)r)Nrr)__doc__rEnumpyrCZtensorflow.compat.v2compatv2rdZkerasrr rr*r-r0r2r4rTrYrGrBrbr r r r s(  = 4  Vr<