~WhNdZddlZddlZddlmcmZddlm Z dZ ddZ ddZ d Z dd Zd Zd Zd ZdZdZdZdZdS)z%Utilities used by convolution layers.N)backendc|dkr+|dkrdS|dkrdS|dkrdStd|d |d kr+|dkrd S|dkrd S|dkrd Std|d td|d)N channels_lastNWCNHWCNDHWCzInput rank not supported: z. Expected values are [3, 4, 5]channels_firstNCWNCHWNCDHWzInvalid data_format: z9. Expected values are ["channels_first", "channels_last"]) ValueError) data_formatndims \/var/www/html/movieo_spanner_bot/venv/lib/python3.11/site-packages/keras/utils/conv_utils.pyconvert_data_formatrso%% 1995 QYY6 QYY70T000  ( ( ( 1995 QYY6 QYY70T000   FK F F F   Fc d|d|d|}t|tr|f|z}n t|}n#t$rt |wxYwt ||krt ||D]N} t|#ttf$r(|d|dt |z }t |wxYw|rd|D}d}nd|D}d }|r|d |d |d z }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 ch|] }|dk| Sr.0vs r z"normalize_tuple..fs>>>AAarz>= 0ch|] }|dk| Srrrs rrz"normalize_tuple..is???AQarz> 0z including z( that does not satisfy the requirement `z`.) isinstanceinttuple TypeErrorrlentype) valuenname allow_zero error_msg value_tuple single_valueunqualified_valuesreq_msgs rnormalize_tupler.9s* ' ' 'A ' '$ ' ' %,hl  (,,KK ( ( (Y'' ' ( {  q Y'' '' , ,L ,L!!!! * , , ,111 ..11 !+++  ,>>>>>?????$ C, C C7> C C C ### s9A=B  9Cc|dS|dvsJ||dz |dz zz}|dvr|}n|dkr ||z dz}n|dkr||zdz }||zdz |zS)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>fullsamevalidcausalr/)r2r4r3r1r) input_length filter_sizepaddingstridedilationdilated_filter_size output_lengths rconv_output_lengthr<vst 9 9 9 9 9%qX\(JJ$$$$ G  $'::Q> F  $'::Q> F "Q &6 11rcx|dS|dvsJ|dkr|dz}n|dkrd}n |dkr|dz }|dz |zd|zz |zS) 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>r1r2r3r2r3rr1r/r)r;r6r7r8pads rconv_input_lengthr@s|t / / / / /&Q G   F  Ao A  '!c' 1K ??rc$|dvsJ|dS||dz |dz zz}|A|dkr||zt||z dz}nU|dkr||z||zdz z }n@|dkr||z}n4|dkr|dz}n|dkrd}n |dkr|dz }|dz |z|zd|zz |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). >r1r2r3Nr/r3rr1r>r2)max)r5r6r7output_paddingr8r9lengthr?s rdeconv_output_lengthrEs, / / / / /tqX\ BBK g  !F*Sv1Eq-I-IIFF   !F*f{.BQ.FGFF   !F*F f  "CC   CC   /CA  '+ 5C ?. P  Mrc|tj}|}|dvrtd||S)N>rr zWThe `data_format` argument must be one of "channels_first", "channels_last". Received: )rimage_data_formatlowerr)r%rs rnormalize_data_formatrIs] })++++--K=== Dr2r3r4zqThe `padding` argument must be a list/tuple or one of "valid", "same" (or "causal", only for `Conv1D). Received: )rlistr!rHr)r%r7s rnormalize_paddingrLsa%$'' kkmmG111 #  # #   Nrc6|dvrtd|dt|}t|tr|f|z}t|tr|f|z}t|}t|}||ks||krt d|d|d|t ||||}||z}t j|t} d|D} tj | D].} t||| ||} tj | D] } d| | | z< /| 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"`}. >r2r3 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=c,g|]}t|Srrangerdims r z$conv_kernel_mask..@<<<s<<>> 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"`. )r2r3rNrOrPrQrRc,g|]}t|SrrTrVs rrXz$conv_kernel_idxs..rYrr c|f|zSNr spatial_idx filter_idxs rz"conv_kernel_idxs..s ZMK,Grrc||fzSrsrrts rrwz"conv_kernel_idxs..sk E 7 rz Data format `zK` not recognized.`data_format` must be "channels_first" or "channels_last".) multi_indexdimsN) rZr#rr rr[r_r`rarUr\ravel_multi_index)rbrcrdr7 filters_in filters_outrrerfrgrhrk concat_idxsrlrmrnf_inf_outout_idxin_idxs rconv_kernel_idxsrKsp'''! 7G 7 7 7   +G,$$1$0 '3'*w&l##Kg,,Kg!7!7 <,7 < < < <.9 < <   %\7GL=<|<<<&&& G G    ' '   IK I I I   %,.?@,,0   (/1AB , ,Nj)) , ,";// , ,E 2$/K$G$G([{CCG 1$/K$E$E([jAAF#F+++++ , , , ,,rchg}t|}t|D]}t||dz }|||z } ||||z} |dkr| |z } td| |z } t ||| | z} |t| | |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>r3r)r#rUr rBminappend) rbrcrlrdr7rangesndimsd left_shift right_shiftcenterstartends rrarasPF   E 5\\ ) )a1,-- "1o 2  #gaj0 g   j FAv *+++a.&;"677 eE3''(((( Mrctt}fd|Dtfd|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. c Xg|]&}t|||'Sr)r<)rrrbrcr7rds rrXz%conv_output_shape.. sC  ;q><?GWQZPPrc<g|]}|dkrdn|Srr)rrrbrhs rrXz%conv_output_shape..s/EEE1k!n!!|AEEEr)rUr#r!)rbrcrdr7rzrhs```` @rr[r[s& \"" # #DLEEEEEEEEL rctjd5|j}|| d}|stj|| d}|d| }|stj|d| }t |tjr,tj|dg|z}n,tj|tjdg|fd}||}|j| d}|stj|| d}tj|tj||fd} | |jd| | j| dz| cdddS#1swxYwYdS)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)axis) tf name_scopeshapeis_fully_definedr TensorShapereshapeas_listconcat set_shape) inpop inner_rankr inner_shape batch_shape inp_reshaped out_reshapedout_inner_shapeouts rrrs" + , , ZKLL) ++-- 6(3-- 5KLj[L) ++-- 6(3-- * 5K k2> 2 2 :cB4+2E2E2G2G+GHHLL:RYk2<<<Lr,'' &,j[\\://11 C h|44j[\\BOj ")[/$BLLL   ci * - :+,,0GGHHH;sFGGG)F)r/)Nrr/)__doc__r_numpyr\tensorflow.compat.v2compatv2rkerasrrr.r<r@rErIrLrorrar[rrrrrs9,+!!!!!!!!!   @::::z22224@@@8  1111h      SSSlo,o,o,d999x<.....r