BVh,dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd l mZdd l mZGd d eZGd deZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGdd eZGd!d"eZGd#d$eZGd%d&eZGd'd(eZGd)d*eZGd+d,eZ Gd-d.eZ!eZ"eZ#eZ$eZ%eZ&eZ'eZ(eZ)e!Z*eZ+eZ,e Z-y)/zPooling layers.N) tensor_shape)backend)Layer) InputSpec) conv_utils) array_ops)math_ops)nnc>eZdZdZ dfd ZdZdZfdZxZS) Pooling1DaPooling layer for arbitrary pooling functions, for 1D inputs. This class only exists for code reuse. It will never be an exposed API. Args: pool_function: The pooling function to apply, e.g. `tf.nn.max_pool2d`. pool_size: An integer or tuple/list of a single integer, representing the size of the pooling window. strides: An integer or tuple/list of a single integer, specifying the strides of the pooling operation. padding: A string. The padding method, either 'valid' or 'same'. Case-insensitive. data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, steps, features)` while `channels_first` corresponds to inputs with shape `(batch, features, steps)`. name: A string, the name of the layer. c ltt| dd|i||tj}||}||_t j|dd|_t j|dd|_ t j||_ t j||_ td|_y)Nname pool_sizestridesndim)superr __init__rimage_data_format pool_functionrnormalize_tuplerrnormalize_paddingpaddingnormalize_data_format data_formatr input_spec selfrrrrrrkwargs __class__s V/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/keras/layers/pooling.pyrzPooling1D.__init__4 )T#888--/kg&D// 1kJDN--gq)DDL//8DL!77 DDQ'DOc|jdk(rdnd}tj||}|j||jdz|j dz|j |j}tj||S)N channels_lastrr)rrr)rr expand_dimsrrrrsqueeze)r!inputspad_axisoutputss r$callzPooling1D.callCs}$$7qQH  " "68 4F    t# $$ !&G   Wh //r&ctj|j}|jdk(r |d}|d}n |d}|d}t j ||j d|j|jd}|jdk(rtj|d||gStj|d||gS)Nchannels_firstr)rr r TensorShapeas_listrrconv_output_lengthrrr)r! input_shapestepsfeatureslengths r$compute_output_shapezPooling1D.compute_output_shapeNs**;7??AK ++!neQh!neQh  * *5+/>>!+<+/<<+/<<?>> x = tf.constant([1., 2., 3., 4., 5.]) >>> x = tf.reshape(x, [1, 5, 1]) >>> max_pool_1d = tf.keras.layers.MaxPooling1D(pool_size=2, ... strides=1, padding='valid') >>> max_pool_1d(x) For example, for `strides=2` and `padding="valid"`: >>> x = tf.constant([1., 2., 3., 4., 5.]) >>> x = tf.reshape(x, [1, 5, 1]) >>> max_pool_1d = tf.keras.layers.MaxPooling1D(pool_size=2, ... strides=2, padding='valid') >>> max_pool_1d(x) For example, for `strides=1` and `padding="same"`: >>> x = tf.constant([1., 2., 3., 4., 5.]) >>> x = tf.reshape(x, [1, 5, 1]) >>> max_pool_1d = tf.keras.layers.MaxPooling1D(pool_size=2, ... strides=1, padding='same') >>> max_pool_1d(x) Args: pool_size: Integer, size of the max pooling window. strides: Integer, or None. Specifies how much the pooling window moves for each pooling step. If None, it will default to `pool_size`. padding: One of `"valid"` or `"same"` (case-insensitive). `"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. data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, steps, features)` while `channels_first` corresponds to inputs with shape `(batch, features, steps)`. Input shape: - If `data_format='channels_last'`: 3D tensor with shape `(batch_size, steps, features)`. - If `data_format='channels_first'`: 3D tensor with shape `(batch_size, features, steps)`. Output shape: - If `data_format='channels_last'`: 3D tensor with shape `(batch_size, downsampled_steps, features)`. - If `data_format='channels_first'`: 3D tensor with shape `(batch_size, features, downsampled_steps)`. c ~tt| tjt j df||||d|y)Nmax pool_moderrrr)rrNr functoolspartialrpool2dr!rrrrr"r#s r$rzMaxPooling1D.__init__sC ,&'..E:   r&r)NrEr(rGrHrIrJrrKrLs@r$rNrNjsL\+/,;  r&rNc(eZdZdZ dfd ZxZS)AveragePooling1Da Average pooling for temporal data. Downsamples the input representation by taking the average value over the window defined by `pool_size`. The window is shifted by `strides`. The resulting output when using "valid" padding option has a shape of: `output_shape = (input_shape - pool_size + 1) / strides)` The resulting output shape when using the "same" padding option is: `output_shape = input_shape / strides` For example, for strides=1 and padding="valid": >>> x = tf.constant([1., 2., 3., 4., 5.]) >>> x = tf.reshape(x, [1, 5, 1]) >>> x >>> avg_pool_1d = tf.keras.layers.AveragePooling1D(pool_size=2, ... strides=1, padding='valid') >>> avg_pool_1d(x) For example, for strides=2 and padding="valid": >>> x = tf.constant([1., 2., 3., 4., 5.]) >>> x = tf.reshape(x, [1, 5, 1]) >>> x >>> avg_pool_1d = tf.keras.layers.AveragePooling1D(pool_size=2, ... strides=2, padding='valid') >>> avg_pool_1d(x) For example, for strides=1 and padding="same": >>> x = tf.constant([1., 2., 3., 4., 5.]) >>> x = tf.reshape(x, [1, 5, 1]) >>> x >>> avg_pool_1d = tf.keras.layers.AveragePooling1D(pool_size=2, ... strides=1, padding='same') >>> avg_pool_1d(x) Args: pool_size: Integer, size of the average pooling windows. strides: Integer, or None. Factor by which to downscale. E.g. 2 will halve the input. If None, it will default to `pool_size`. padding: One of `"valid"` or `"same"` (case-insensitive). `"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. data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, steps, features)` while `channels_first` corresponds to inputs with shape `(batch, features, steps)`. Input shape: - If `data_format='channels_last'`: 3D tensor with shape `(batch_size, steps, features)`. - If `data_format='channels_first'`: 3D tensor with shape `(batch_size, features, steps)`. Output shape: - If `data_format='channels_last'`: 3D tensor with shape `(batch_size, downsampled_steps, features)`. - If `data_format='channels_first'`: 3D tensor with shape `(batch_size, features, downsampled_steps)`. c ~tt| tjt j df||||d|y)NavgrQrS)rr[rrTrUrrVrWs r$rzAveragePooling1D.__init__)sB D*'..E:   r&rXrYrLs@r$r[r[saF+/,;r&r[c>eZdZdZ dfd ZdZdZfdZxZS) Pooling2Da^Pooling layer for arbitrary pooling functions, for 2D inputs (e.g. images). This class only exists for code reuse. It will never be an exposed API. Args: pool_function: The pooling function to apply, e.g. `tf.nn.max_pool2d`. pool_size: An integer or tuple/list of 2 integers: (pool_height, pool_width) specifying the size of the pooling window. Can be a single integer to specify the same value for all spatial dimensions. strides: An integer or tuple/list of 2 integers, specifying the strides of the pooling operation. Can be a single integer to specify the same value for all spatial dimensions. padding: A string. The padding method, either 'valid' or 'same'. Case-insensitive. data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, height, width)`. name: A string, the name of the layer. c ltt| dd|i||tj}||}||_t j|dd|_t j|dd|_ t j||_ t j||_ td|_y)Nrr)rrrr)rr_rrrrrrrrrrrrrrr s r$rzPooling2D.__init__Mr%r&c B|jdk(r%d|jzdz}d|jzdz}nd|jz}d|jz}|j||||jj t j|jd}|S)Nr(r*)rrra)ksizerrr)rrrrrupperrconvert_data_formatr!r- pool_shaperr/s r$r0zPooling2D.call\s ?*$..(4/jt||#d*gDNN*j%g   ""$2243C3CQG !IG Nr&ctj|j}|jdk(r |d}|d}n |d}|d}t j ||j d|j|jd}t j ||j d|j|jd}|jdk(rtj|d|d||gStj|d|||dgS)Nr2r)rrrr3)r!r7rowscolss r$r;zPooling2D.compute_output_shapeks **;7??AK ++ ^d ^d ^d ^d  ( (t~~a/@$,,)-a :D  ( (t~~a/@$,,)-a :D ++  % % q>;q>4 688 % % q>4{1~ 688r&c|j|j|j|jd}tt |}tt|jt|jzSN)rrrr) rrrrrr_r=r>r?r@rAs r$r=zPooling2D.get_config~b^^<<<<'' F  435K [&&()D,@@ AAr&)rENNrFrLs@r$r_r_4s+2-1 ( 8&BBr&r_c,eZdZdZ dfd ZxZS) MaxPooling2DaJMax pooling operation for 2D spatial data. Downsamples the input along its spatial dimensions (height and width) by taking the maximum value over an input window (of size defined by `pool_size`) for each channel of the input. The window is shifted by `strides` along each dimension. The resulting output, when using the `"valid"` padding option, has a spatial shape (number of rows or columns) of: `output_shape = math.floor((input_shape - pool_size) / strides) + 1` (when `input_shape >= pool_size`) The resulting output shape when using the `"same"` padding option is: `output_shape = math.floor((input_shape - 1) / strides) + 1` For example, for `strides=(1, 1)` and `padding="valid"`: >>> x = tf.constant([[1., 2., 3.], ... [4., 5., 6.], ... [7., 8., 9.]]) >>> x = tf.reshape(x, [1, 3, 3, 1]) >>> max_pool_2d = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), ... strides=(1, 1), padding='valid') >>> max_pool_2d(x) For example, for `strides=(2, 2)` and `padding="valid"`: >>> x = tf.constant([[1., 2., 3., 4.], ... [5., 6., 7., 8.], ... [9., 10., 11., 12.]]) >>> x = tf.reshape(x, [1, 3, 4, 1]) >>> max_pool_2d = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), ... strides=(2, 2), padding='valid') >>> max_pool_2d(x) Usage Example: >>> input_image = tf.constant([[[[1.], [1.], [2.], [4.]], ... [[2.], [2.], [3.], [2.]], ... [[4.], [1.], [1.], [1.]], ... [[2.], [2.], [1.], [4.]]]]) >>> output = tf.constant([[[[1], [0]], ... [[0], [1]]]]) >>> model = tf.keras.models.Sequential() >>> model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2), ... input_shape=(4, 4, 1))) >>> model.compile('adam', 'mean_squared_error') >>> model.predict(input_image, steps=1) array([[[[2.], [4.]], [[4.], [4.]]]], dtype=float32) For example, for stride=(1, 1) and padding="same": >>> x = tf.constant([[1., 2., 3.], ... [4., 5., 6.], ... [7., 8., 9.]]) >>> x = tf.reshape(x, [1, 3, 3, 1]) >>> max_pool_2d = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), ... strides=(1, 1), padding='same') >>> max_pool_2d(x) Args: pool_size: integer or tuple of 2 integers, window size over which to take the maximum. `(2, 2)` will take the max value over a 2x2 pooling window. If only one integer is specified, the same window length will be used for both dimensions. strides: Integer, tuple of 2 integers, or None. Strides values. Specifies how far the pooling window moves for each pooling step. If None, it will default to `pool_size`. padding: One of `"valid"` or `"same"` (case-insensitive). `"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. data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, height, width)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be "channels_last". Input shape: - If `data_format='channels_last'`: 4D tensor with shape `(batch_size, rows, cols, channels)`. - If `data_format='channels_first'`: 4D tensor with shape `(batch_size, channels, rows, cols)`. Output shape: - If `data_format='channels_last'`: 4D tensor with shape `(batch_size, pooled_rows, pooled_cols, channels)`. - If `data_format='channels_first'`: 4D tensor with shape `(batch_size, channels, pooled_rows, pooled_cols)`. Returns: A tensor of rank 4 representing the maximum pooled values. See above for output shape. c Ttt| tjf||||d|yNrS)rrorr max_poolrWs r$rzMaxPooling2D.__init__s4  ,& <W[<5;= pool_size`) The resulting output shape when using the `"same"` padding option is: `output_shape = math.floor((input_shape - 1) / strides) + 1` For example, for `strides=(1, 1)` and `padding="valid"`: >>> x = tf.constant([[1., 2., 3.], ... [4., 5., 6.], ... [7., 8., 9.]]) >>> x = tf.reshape(x, [1, 3, 3, 1]) >>> avg_pool_2d = tf.keras.layers.AveragePooling2D(pool_size=(2, 2), ... strides=(1, 1), padding='valid') >>> avg_pool_2d(x) For example, for `stride=(2, 2)` and `padding="valid"`: >>> x = tf.constant([[1., 2., 3., 4.], ... [5., 6., 7., 8.], ... [9., 10., 11., 12.]]) >>> x = tf.reshape(x, [1, 3, 4, 1]) >>> avg_pool_2d = tf.keras.layers.AveragePooling2D(pool_size=(2, 2), ... strides=(2, 2), padding='valid') >>> avg_pool_2d(x) For example, for `strides=(1, 1)` and `padding="same"`: >>> x = tf.constant([[1., 2., 3.], ... [4., 5., 6.], ... [7., 8., 9.]]) >>> x = tf.reshape(x, [1, 3, 3, 1]) >>> avg_pool_2d = tf.keras.layers.AveragePooling2D(pool_size=(2, 2), ... strides=(1, 1), padding='same') >>> avg_pool_2d(x) Args: pool_size: integer or tuple of 2 integers, factors by which to downscale (vertical, horizontal). `(2, 2)` will halve the input in both spatial dimension. If only one integer is specified, the same window length will be used for both dimensions. strides: Integer, tuple of 2 integers, or None. Strides values. If None, it will default to `pool_size`. padding: One of `"valid"` or `"same"` (case-insensitive). `"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. data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, height, width)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be "channels_last". Input shape: - If `data_format='channels_last'`: 4D tensor with shape `(batch_size, rows, cols, channels)`. - If `data_format='channels_first'`: 4D tensor with shape `(batch_size, channels, rows, cols)`. Output shape: - If `data_format='channels_last'`: 4D tensor with shape `(batch_size, pooled_rows, pooled_cols, channels)`. - If `data_format='channels_first'`: 4D tensor with shape `(batch_size, channels, pooled_rows, pooled_cols)`. c Ttt| tjf||||d|yrq)rrurr avg_poolrWs r$rzAveragePooling2D.__init__vs5  D* <W[<5;eZdZdZ dfd ZdZdZfdZxZS) Pooling3DavPooling layer for arbitrary pooling functions, for 3D inputs. This class only exists for code reuse. It will never be an exposed API. Args: pool_function: The pooling function to apply, e.g. `tf.nn.max_pool2d`. pool_size: An integer or tuple/list of 3 integers: (pool_depth, pool_height, pool_width) specifying the size of the pooling window. Can be a single integer to specify the same value for all spatial dimensions. strides: An integer or tuple/list of 3 integers, specifying the strides of the pooling operation. Can be a single integer to specify the same value for all spatial dimensions. padding: A string. The padding method, either 'valid' or 'same'. Case-insensitive. data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, depth, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, depth, height, width)`. name: A string, the name of the layer. c ltt| dd|i||tj}||}||_t j|dd|_t j|dd|_ t j||_ t j||_ td|_y)Nrrrrrr)rryrrrrrrrrrrrrrrr s r$rzPooling3D.__init__r%r&c<d|jzdz}d|jzdz}|jdk(rtj|d}|j ||||j j}|jdk(rtj|d}|S)Nr*r2)rr)rrar)rcrr)rrarr)r)rrrr transposerrrdrfs r$r0zPooling3D.calls&-JT\\!D(G ++""6?;f   ""$ !&G  ++##G_=g Nr&ctj|j}|jdk(r|d}|d}|d}n|d}|d}|d}t j ||j d|j|jd}t j ||j d|j|jd}t j ||j d|j|jd}|jdk(r tj|d|d|||gStj|d||||dgS)Nr2r)rrarrr3)r!r7len_dim1len_dim2len_dim3s r$r;zPooling3D.compute_output_shapesT**;7??AK ++QhQhQhQhQhQh,,Xt~~a7H-1\\4<<?LH,,Xt~~a7H-1\\4<<?LH,,Xt~~a7H-1\\4<<?LH ++  % % q>;q>8Xx HJJ % % q>8XxQ HJJr&c|j|j|j|jd}tt |}tt|jt|jzSrl) rrrrrryr=r>r?r@rAs r$r=zPooling3D.get_configrmr&rDrFrLs@r$ryrys,6-< ((J.BBr&ryc,eZdZdZ dfd ZxZS) MaxPooling3DaMax pooling operation for 3D data (spatial or spatio-temporal). Downsamples the input along its spatial dimensions (depth, height, and width) by taking the maximum value over an input window (of size defined by `pool_size`) for each channel of the input. The window is shifted by `strides` along each dimension. Args: pool_size: Tuple of 3 integers, factors by which to downscale (dim1, dim2, dim3). `(2, 2, 2)` will halve the size of the 3D input in each dimension. strides: tuple of 3 integers, or None. Strides values. padding: One of `"valid"` or `"same"` (case-insensitive). `"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. data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be "channels_last". Input shape: - If `data_format='channels_last'`: 5D tensor with shape: `(batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)` - If `data_format='channels_first'`: 5D tensor with shape: `(batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3)` Output shape: - If `data_format='channels_last'`: 5D tensor with shape: `(batch_size, pooled_dim1, pooled_dim2, pooled_dim3, channels)` - If `data_format='channels_first'`: 5D tensor with shape: `(batch_size, channels, pooled_dim1, pooled_dim2, pooled_dim3)` Example: ```python depth = 30 height = 30 width = 30 input_channels = 3 inputs = tf.keras.Input(shape=(depth, height, width, input_channels)) layer = tf.keras.layers.MaxPooling3D(pool_size=3) outputs = layer(inputs) # Shape: (batch_size, 10, 10, 10, 3) ``` c Ttt| tjf||||d|yrq)rrrr max_pool3drWs r$rzMaxPooling3D.__init__s4  ,& <W[<5;r?r@rAs r$r=zGlobalPooling1D.get_configO!--4== IF9;K [&&()D,@@ AAr&)r(F rGrHrIrJrr;r0r=rKrLs@r$rrns"> JBBr&rc4eZdZdZdfd ZddZddZxZS)GlobalAveragePooling1DaWGlobal average pooling operation for temporal data. Examples: >>> input_shape = (2, 3, 4) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.GlobalAveragePooling1D()(x) >>> print(y.shape) (2, 4) Args: data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, steps, features)` while `channels_first` corresponds to inputs with shape `(batch, features, steps)`. keepdims: A boolean, whether to keep the temporal dimension or not. If `keepdims` is `False` (default), the rank of the tensor is reduced for spatial dimensions. If `keepdims` is `True`, the temporal dimension are retained with length 1. The behavior is the same as for `tf.reduce_mean` or `np.mean`. Call arguments: inputs: A 3D tensor. mask: Binary tensor of shape `(batch_size, steps)` indicating whether a given step should be masked (excluded from the average). Input shape: - If `data_format='channels_last'`: 3D tensor with shape: `(batch_size, steps, features)` - If `data_format='channels_first'`: 3D tensor with shape: `(batch_size, features, steps)` Output shape: - If `keepdims`=False: 2D tensor with shape `(batch_size, features)`. - If `keepdims`=True: - If `data_format='channels_last'`: 3D tensor with shape `(batch_size, 1, features)` - If `data_format='channels_first'`: 3D tensor with shape `(batch_size, features, 1)` c >tt| dd|i|d|_y)NrTr)rrrsupports_masking)r!rr"r#s r$rzGlobalAveragePooling1D.__init__s* $0;[;39; Dr&c|jdk(rdnd}|tj||dj}t j ||jdk(rdnd}||z}t j|||jtj|||jz St j|||jS)Nr(rr)raxisr) rr castdtyperr+rsumr reduce_summean)r!r-mask steps_axiss r$r0zGlobalAveragePooling1D.calls&&/9qJ  ]]4 1d  " " T%%8aAd nf [[ z=="$,$7$7dmm%=== \\&zDMM JJr&cyrr)r!r-rs r$ compute_maskz#GlobalAveragePooling1D.compute_masks r&)r(r)rGrHrIrJrr0rrKrLs@r$rrs.`! Kr&rceZdZdZdZy)GlobalMaxPooling1Da,Global max pooling operation for 1D temporal data. Downsamples the input representation by taking the maximum value over the time dimension. For example: >>> x = tf.constant([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]]) >>> x = tf.reshape(x, [3, 3, 1]) >>> x >>> max_pool_1d = tf.keras.layers.GlobalMaxPooling1D() >>> max_pool_1d(x) Args: data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, steps, features)` while `channels_first` corresponds to inputs with shape `(batch, features, steps)`. keepdims: A boolean, whether to keep the temporal dimension or not. If `keepdims` is `False` (default), the rank of the tensor is reduced for spatial dimensions. If `keepdims` is `True`, the temporal dimension are retained with length 1. The behavior is the same as for `tf.reduce_max` or `np.max`. Input shape: - If `data_format='channels_last'`: 3D tensor with shape: `(batch_size, steps, features)` - If `data_format='channels_first'`: 3D tensor with shape: `(batch_size, features, steps)` Output shape: - If `keepdims`=False: 2D tensor with shape `(batch_size, features)`. - If `keepdims`=True: - If `data_format='channels_last'`: 3D tensor with shape `(batch_size, 1, features)` - If `data_format='channels_first'`: 3D tensor with shape `(batch_size, features, 1)` cl|jdk(rdnd}tj|||jS)Nr(rr)rrrrPr)r!r-rs r$r0zGlobalMaxPooling1D.call s-&&/9qJ ;;vJ GGr&NrGrHrIrJr0rr&r$rrs4lHr&rc:eZdZdZdfd ZdZdZfdZxZS)GlobalPooling2Dz9Abstract class for different global pooling 2D layers. c tt| di|tj||_t d|_||_y)Nrarr) rrrrrrrrrrs r$rzGlobalPooling2D.__init__; /4)3F3!77 DDQ'DODMr&ctj|j}|jdk(rH|jrtj|ddd|dgStj|d|dgS|jrtj|d|dddgStj|d|dgS)Nr(rrrrrs r$r;z$GlobalPooling2D.compute_output_shapes**;7??AK ?* ''QA{1~(NOO''QQ(HII ''QQA(NOO''QQ(HIIr&ctrrrs r$r0zGlobalPooling2D.call(rr&c|j|jd}tt|}t t |jt |jzSr)rrrrr=r>r?r@rAs r$r=zGlobalPooling2D.get_config+rr&NFrrLs@r$rrs$ JBBr&rceZdZdZdZy)GlobalAveragePooling2DaGlobal average pooling operation for spatial data. Examples: >>> input_shape = (2, 4, 5, 3) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.GlobalAveragePooling2D()(x) >>> print(y.shape) (2, 3) Args: data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, height, width)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be "channels_last". keepdims: A boolean, whether to keep the spatial dimensions or not. If `keepdims` is `False` (default), the rank of the tensor is reduced for spatial dimensions. If `keepdims` is `True`, the spatial dimensions are retained with length 1. The behavior is the same as for `tf.reduce_mean` or `np.mean`. Input shape: - If `data_format='channels_last'`: 4D tensor with shape `(batch_size, rows, cols, channels)`. - If `data_format='channels_first'`: 4D tensor with shape `(batch_size, channels, rows, cols)`. Output shape: - If `keepdims`=False: 2D tensor with shape `(batch_size, channels)`. - If `keepdims`=True: - If `data_format='channels_last'`: 4D tensor with shape `(batch_size, 1, 1, channels)` - If `data_format='channels_first'`: 4D tensor with shape `(batch_size, channels, 1, 1)` c|jdk(r$tj|ddg|jStj|ddg|jSNr(rr)rrrrrrrs r$r0zGlobalAveragePooling2D.call^sF ?* \\&1v FF \\&1v FFr&Nrrr&r$rr1s*XGr&rceZdZdZdZy)GlobalMaxPooling2DaXGlobal max pooling operation for spatial data. Examples: >>> input_shape = (2, 4, 5, 3) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.GlobalMaxPool2D()(x) >>> print(y.shape) (2, 3) Args: data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, height, width)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be "channels_last". keepdims: A boolean, whether to keep the spatial dimensions or not. If `keepdims` is `False` (default), the rank of the tensor is reduced for spatial dimensions. If `keepdims` is `True`, the spatial dimensions are retained with length 1. The behavior is the same as for `tf.reduce_max` or `np.max`. Input shape: - If `data_format='channels_last'`: 4D tensor with shape `(batch_size, rows, cols, channels)`. - If `data_format='channels_first'`: 4D tensor with shape `(batch_size, channels, rows, cols)`. Output shape: - If `keepdims`=False: 2D tensor with shape `(batch_size, channels)`. - If `keepdims`=True: - If `data_format='channels_last'`: 4D tensor with shape `(batch_size, 1, 1, channels)` - If `data_format='channels_first'`: 4D tensor with shape `(batch_size, channels, 1, 1)` c|jdk(r$tj|ddg|jStj|ddg|jSrrrs r$r0zGlobalMaxPooling2D.callsF ?* [[q!ft}} EE [[q!ft}} EEr&Nrrr&r$rres*XFr&rc:eZdZdZdfd ZdZdZfdZxZS)GlobalPooling3Dz6Abstract class for different global pooling 3D layers.c tt| di|tj||_t d|_||_y)Nr{rr) rrrrrrrrrrs r$rzGlobalPooling3D.__init__rr&ctj|j}|jdk(rI|jr tj|dddd|dgStj|d|dgS|jr tj|d|ddddgStj|d|dgS)Nr(rrrarrs r$r;z$GlobalPooling3D.compute_output_shapes**;7??AK ?* '' ^Q1k!n 57 7''QQ(HII '' ^[^Q1 57 7''QQ(HIIr&ctrrrs r$r0zGlobalPooling3D.callrr&c|j|jd}tt|}t t |jt |jzSr)rrrrr=r>r?r@rAs r$r=zGlobalPooling3D.get_configrr&rrrLs@r$rrs"> JBBr&rceZdZdZdZy)GlobalAveragePooling3Da9Global Average pooling operation for 3D data. Args: data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be "channels_last". keepdims: A boolean, whether to keep the spatial dimensions or not. If `keepdims` is `False` (default), the rank of the tensor is reduced for spatial dimensions. If `keepdims` is `True`, the spatial dimensions are retained with length 1. The behavior is the same as for `tf.reduce_mean` or `np.mean`. Input shape: - If `data_format='channels_last'`: 5D tensor with shape: `(batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)` - If `data_format='channels_first'`: 5D tensor with shape: `(batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3)` Output shape: - If `keepdims`=False: 2D tensor with shape `(batch_size, channels)`. - If `keepdims`=True: - If `data_format='channels_last'`: 5D tensor with shape `(batch_size, 1, 1, 1, channels)` - If `data_format='channels_first'`: 5D tensor with shape `(batch_size, channels, 1, 1, 1)` c|jdk(r$tj|gd|jStj|gd|jSNr()rr)rr)r)rrarrs r$r0zGlobalAveragePooling3D.calls> ?* \\&y4== II \\&y4== IIr&Nrrr&r$rrs$LJr&rceZdZdZdZy)GlobalMaxPooling3Da3Global Max pooling operation for 3D data. Args: data_format: A string, one of `channels_last` (default) or `channels_first`. The ordering of the dimensions in the inputs. `channels_last` corresponds to inputs with shape `(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels)` while `channels_first` corresponds to inputs with shape `(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)`. It defaults to the `image_data_format` value found in your Keras config file at `~/.keras/keras.json`. If you never set it, then it will be "channels_last". keepdims: A boolean, whether to keep the spatial dimensions or not. If `keepdims` is `False` (default), the rank of the tensor is reduced for spatial dimensions. If `keepdims` is `True`, the spatial dimensions are retained with length 1. The behavior is the same as for `tf.reduce_max` or `np.max`. Input shape: - If `data_format='channels_last'`: 5D tensor with shape: `(batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)` - If `data_format='channels_first'`: 5D tensor with shape: `(batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3)` Output shape: - If `keepdims`=False: 2D tensor with shape `(batch_size, channels)`. - If `keepdims`=True: - If `data_format='channels_last'`: 5D tensor with shape `(batch_size, 1, 1, 1, channels)` - If `data_format='channels_first'`: 5D tensor with shape `(batch_size, channels, 1, 1, 1)` c|jdk(r$tj|gd|jStj|gd|jSrrrs r$r0zGlobalMaxPooling3D.calls> ?* [[i$-- HH [[i$-- HHr&Nrrr&r$rrs$LIr&r).rJrTtensorflow.python.frameworkrtensorflow.python.kerasr)tensorflow.python.keras.engine.base_layerr)tensorflow.python.keras.engine.input_specrtensorflow.python.keras.utilsrtensorflow.python.opsrr r r rNr[r_roruryrrrrrrrrrrr AvgPool1D MaxPool1D AvgPool2D MaxPool2D AvgPool3D MaxPool3DGlobalMaxPool1DGlobalMaxPool2DGlobalMaxPool3DGlobalAvgPool1DGlobalAvgPool2DGlobalAvgPool3Drr&r$rsv4+;?4+*$JBJBZX9Xvlyl^RBRBjE<9EE_EP9H9HxBeB@1G_1Gh1F1FhBeBB+J_+J\+I+I`       $$$(((r&