BVhIdZddlZddlZddlmZddlmZddlmZddl m Z dZ dZ dd Z d Z dd Zd Zd ZdZdZdZdZdZy)z%Utilities used by convolution layers.N)ops) tensor_shape)backend) array_opsc|dk(r|dk(ry|dk(ry|dk(rytd||d k(r|dk(ry |dk(ry |dk(ry td|td |)N channels_lastNWCNHWCNDHWCzInput rank not supported:channels_firstNCWNCHWNCDHWzInvalid data_format:) ValueError) data_formatndims X/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/keras/utils/conv_utils.pyconvert_data_formatrsyO# qy      2D 99&& qy      2D 99 +[ 99c (t|tr|f|zS t|}t ||k7r,t d|zdzt |zdzt |z|D]} t||S#t$r-t d|zdzt |zdzt |zwxYw#ttf$rWt d|zdzt |zdzt |zdzt |zdzdzt t|zwxYw)aTransforms a single integer or iterable of 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. Returns: A tuple of n integers. Raises: ValueError: If something else than an int/long or iterable thereof was passed. zThe `z` argument must be a tuple of z integers. Received: z including element z of type ) isinstanceinttuple TypeErrorrstrlentype)valuenname value_tuple single_values rnormalize_tupler'2sv"s 8a<F%Lk ;1 w~(HH1v 78:=e*E FF#8 8 L8  F w~(HH1v 78:=e*E FFF) $84*JJQ "9:fullsamevalidcausal)r*r,r+r)) input_length filter_sizepaddingstridedilationdilated_filter_size output_lengths rconv_output_lengthr6Ys  7 77 7#{Q8a<&HH "" M' #66:M& #66:M & 1 $ //rcp|y|dvsJ|dk(r|dz}n|dk(rd}n |dk(r|dz }|dz |zdzz |zS) zDetermines 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)r-r.)r5r0r1r2pads rconv_input_lengthr:ssj  - -- -   C' C& /C ! v %C /+ ==rc|dvsJ|y||dz |dz zz}|=|dk(r||zt||z dz}|S|dk(r||z||zdz z }|S|dk(r||z}S|dk(r|dz}n|dk(rd}n |dk(r|dz }|dz |z|zdzz |z}|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+Nr-r+rr)r8r*)max)r/r0r1output_paddingr2r3lengthr9s rdeconv_output_lengthr?s( - -- - {Q8a<@@+'f$s;+?'CCf - F f$(rrzWThe `data_format` argument must be one of "channels_first", "channels_last". Received: )rimage_data_formatlowerrr)r"rs rnormalize_data_formatrCsP ]  % % 'E +;; EZ  !! rct|ttfr|S|j}|dvrt dt |z|S)N>r*r+r,zqThe `padding` argument must be a list/tuple or one of "valid", "same" (or "causal", only for `Conv1D). Received: )rlistrrBrr)r"r1s rnormalize_paddingrFsNe}% L KKM' // "$'L1 22 .rc,|dvrtd|zt|}t|tr|f|z}t|tr|f|z}t|}t|}||k7s||k7rt d|||fzt ||||}||z}t j|t j} |D cgc] } t| } } tj| D]0} t||| ||} tj| D] }d| || z< 2| Scc} w)a@Compute 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+GPadding type %s not supported. Only "valid" and "same" are implemented.TNumber of strides, input and kernel dimensions must all match. Received: %d, %d, %d.T) NotImplementedErrorr rrrconv_output_shapenpzerosbool_range itertoolsproductconv_connected_inputs) input_shape kernel_shapestridesr1in_dims kernel_dims stride_dims output_shape mask_shapemaskdimoutput_axes_ticksoutput_positioninput_axes_ticksinput_positions rconv_kernel_maskrasS\ %% 13:; <<  ' c" ?W,Lj7"GL!+G +G{g5 4!7K89 ::#; gwO,\)* *bhh '$-9:cuSz::"**,=>4o,[,-4/3d>O +,44 +;s6Dc #K|dvrtd|zt|}t|tr|f|z}t|tr|f|z}t|}t|} ||k7s| |k7rt d| ||fzt ||||} | D cgc] } t | } } |dk(rd} n|dk(rd} nt d|ztj| D]}t|||||}tj|D]r}t |D]b}t |D]R}tj| ||| | | }tj| ||| || }||fTdty cc} ww) aYields 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+rHrIrc|f|zSNr. spatial_idx filter_idxs rz"conv_kernel_idxs..hs :-+2Mrrc||fzSrdr.res rrhz"conv_kernel_idxs..js + 2MrzXData format %s not recognized.`data_format` must be "channels_first" or "channels_last".) multi_indexdimsN) rJr rrrrKrOrPrQrRrLravel_multi_index)rSrTrUr1 filters_in filters_outrrVrWrXrYr\r] concat_idxsr^r_r`f_inf_outout_idxin_idxs rconv_kernel_idxsrt!sb %% 13:; <<  ' c" ?W,Lj7"GL!+G +G{g5 4!7K89 ::#; gwO,-9:cuSz::$$MKo%MK (*56 77#**,=> "o,[,- " #"$;' "E((%ou=|[9;'''%nd;{J79&&! ! "" " ";sB E6E1!CE6cg}t|}t|D]l}t||dz }|||z } ||||z} |dk(r| |z } td| |z } t ||| | z} |j t| | n|S)aReturn 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. r8r+r)r rOrr<minappend) rSrTr^rUr1rangesndimsd left_shift right_shiftcenterstartends rrRrRsN & k % < %a\!_q()Jq/J.K Q '!* ,F' f 6J& 'E k!nf{2 3C MM%s#$ % -rc tt|}|Dcgc]}t|||||||}}t|Dcgc]}||dk(rdn||c}}|Scc}wcc}w)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. r)rOr r6r)rSrTrUr1rkrzrYs rrKrKs& s< !$ Qa'71:N,>BCKNa q\!_4CE,   Ds A!A&cNtjd5|j}|| d}|jst j|| d}|d| }|jst j|d| }t |t jr)t j|dg|jz}n.t j|t jdg|fd}||}|j| d}|jst j|| d}t j|t j||fd} | j|jd| | j| dz| cdddS#1swYyxYw)aReturns `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)axis) r name_scope_v2shapeis_fully_definedrrr TensorShapereshapeas_listconcat set_shape) inpop inner_rankr inner_shape batch_shape inp_reshaped out_reshapedout_inner_shapeouts rrrs" -. IIE %K  ' ' )OOC(*6k *%K  ' ' )OOC(:+6k+|778&&sRD;3F3F3H,HIl&& y"{ 3"=?ll#L"((*6O  + + -! 5zklCo   i&& _'EBO QCMM#))Lj[)CIIzkl,CCD 7s E;FF$)r-)Nrr-)__doc__rPnumpyrLtensorflow.python.frameworkrrtensorflow.python.kerasrtensorflow.python.opsrrr'r6r:r?rCrFrartrRrKrr.rrrsj,+4++:.$N04>6)- !"# .bL^["|8v:,r