o Ö2úhªÀã@sÀdZddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd l mZdd l mZGd d „d eƒZGd d„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd „d eƒZGd!d"„d"eƒZGd#d$„d$eƒZGd%d&„d&eƒZGd'd(„d(eƒZGd)d*„d*eƒZGd+d,„d,eƒZ Gd-d.„d.eƒZ!eZ"eZ#eZ$eZ%eZ&eZ'eZ(eZ)e!Z*eZ+eZ,e Z-dS)/zPooling layers.éN)Ú tensor_shape)Úbackend)ÚLayer)Ú InputSpec)Ú conv_utils)Ú array_ops)Úmath_ops)ÚnncóBeZdZdZ  d ‡fdd„ Zdd„Zd d „Z‡fd d „Z‡ZS)Ú Pooling1DaŒPooling 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. ÚvalidÚ channels_lastNc ó„tt|ƒjdd|i|¤Ž|durt ¡}|dur|}||_t |dd¡|_t |dd¡|_ t  |¡|_ t  |¡|_ tdd|_dS)NÚnameéÚ pool_sizeÚstridesé©Úndim©)Úsuperr Ú__init__rÚimage_data_formatÚ pool_functionrÚnormalize_tuplerrÚnormalize_paddingÚpaddingÚnormalize_data_formatÚ data_formatrÚ input_spec©ÚselfrrrrrrÚkwargs©Ú __class__rúa/var/www/html/chatgem/venv/lib/python3.10/site-packages/tensorflow/python/keras/layers/pooling.pyr4ó  zPooling1D.__init__cCsN|jdkrdnd}t ||¡}|j||jd|jd|j|jd}t ||¡S)Nr ér©r)rrr)rrÚ expand_dimsrrrrÚsqueeze)r"ÚinputsÚpad_axisÚoutputsrrr&ÚcallCs û zPooling1D.callcCsŠt |¡ ¡}|jdkr|d}|d}n|d}|d}t ||jd|j|jd¡}|jdkr;t |d||g¡St |d||g¡S)NÚchannels_firstr(rr© rÚ TensorShapeÚas_listrrÚconv_output_lengthrrr)r"Ú input_shapeÚstepsÚfeaturesÚlengthrrr&Úcompute_output_shapeNs  ý zPooling1D.compute_output_shapecó@|j|j|j|jdœ}tt|ƒ ¡}tt|  ¡ƒt|  ¡ƒƒS)N)rrrr) rrrrrr Ú get_configÚdictÚlistÚitems©r"ÚconfigÚ base_configr$rr&r;_óüzPooling1D.get_config©r r N© Ú__name__Ú __module__Ú __qualname__Ú__doc__rr/r9r;Ú __classcell__rrr$r&r sþ r có&eZdZdZ  d‡fdd„ Z‡ZS) Ú MaxPooling1Da% Max pooling operation for 1D temporal data. Downsamples the input representation by taking the maximum value over a spatial window of size `pool_size`. The window is shifted by `strides`. The resulting output, when using the `"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]) >>> 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)`. r(Nr r c ó2tt|ƒjtjtjddf||||dœ|¤ŽdS)NÚmax©Ú pool_mode©rrrr)rrKrÚ functoolsÚpartialrÚpool2d©r"rrrrr#r$rr&r¹s ÿû úzMaxPooling1D.__init__©r(Nr r ©rErFrGrHrrIrrr$r&rKjs NÿrKcrJ) Ú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)`. r(Nr r c rL)NÚavgrNrP)rrWrrQrRrrSrTr$rr&r)s ÿû úzAveragePooling1D.__init__rUrVrrr$r&rWÅs cÿrWcsBeZdZdZ  d ‡fdd„ Zdd„Zdd „Z‡fd d „Z‡ZS) Ú 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. r Nc r)Nrr(rrérr)rrYrrrrrrrrrrrrrr r!r$rr&rMr'zPooling2D.__init__c Csd|jdkrd|jd}d|jd}n d|j}d|j}|j||||j ¡t |jd¡d}|S)Nr r))rrrZ)Úksizerrr)rrrrrÚupperrÚconvert_data_format©r"r,Ú pool_shaperr.rrr&r/\s    ûzPooling2D.callcCs´t |¡ ¡}|jdkr|d}|d}n|d}|d}t ||jd|j|jd¡}t ||jd|j|jd¡}|jdkrMt |d|d||g¡St |d|||dg¡S)Nr0r(rrrr1)r"r5ÚrowsÚcolsrrr&r9ks&  ÿÿ ÿÿzPooling2D.compute_output_shapecr:©N)rrrr) rrrrrrYr;r<r=r>r?r$rr&r;~rBzPooling2D.get_config)r NNrDrrr$r&rY4sþrYcó*eZdZdZ    d‡fdd„ Z‡ZS)Ú 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. ©r(r(Nr c ó(tt|ƒjtjf||||dœ|¤ŽdS©NrP)rrdrr Úmax_poolrTr$rr&ró ÿý ýzMaxPooling2D.__init__©reNr NrVrrr$r&rd‰s|ürdcrc)ÚAveragePooling2DaAverage pooling operation for spatial data. Downsamples the input along its spatial dimensions (height and width) by taking the average 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 `"valid"` padding option has a 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]) >>> 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)`. reNr c rfrg)rrkrr Úavg_poolrTr$rr&rvrizAveragePooling2D.__init__rjrVrrr$r&rkseürkcr )Ú 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. r r Nc r)Nrrrrérr)rrmrrrrrrrrrrrrrr r!r$rr&rr'zPooling3D.__init__cCsdd|jd}d|jd}|jdkrt |d¡}|j||||j ¡d}|jdkr0t |d¡}|S)Nr)r0)rr(rrZr)r[rr)rrZrr(r)rrrrÚ transposerrr\r^rrr&r/¬s  ü  zPooling3D.callcCsæt |¡ ¡}|jdkr|d}|d}|d}n |d}|d}|d}t ||jd|j|jd¡}t ||jd|j|jd¡}t ||jd|j|jd¡}|jdkret |d|d|||g¡St |d||||dg¡S)Nr0r(rrZrrr1)r"r5Úlen_dim1Úlen_dim2Úlen_dim3rrr&r9Às0   ÿ ÿ ÿ ÿÿzPooling3D.compute_output_shapecr:rb) rrrrrrmr;r<r=r>r?r$rr&r;×rBzPooling3D.get_configrCrDrrr$r&rm‚sþrmcrc)Ú MaxPooling3DaÊMax 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) ``` ©r(r(r(Nr c rfrg)rrsrr Ú max_pool3drTr$rr&rrizMaxPooling3D.__init__©rtNr NrVrrr$r&rsâó:ürscrc)ÚAveragePooling3DaÒAverage pooling operation for 3D data (spatial or spatio-temporal). Downsamples the input along its spatial dimensions (depth, height, and width) by taking the average 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.AveragePooling3D(pool_size=3) outputs = layer(inputs) # Shape: (batch_size, 10, 10, 10, 3) ``` rtNr c rfrg)rrxrr Ú avg_pool3drTr$rr&rbrizAveragePooling3D.__init__rvrVrrr$r&rx(rwrxcó>eZdZdZd ‡fdd„ Zdd„Zdd „Z‡fd d „Z‡ZS) ÚGlobalPooling1Dz6Abstract class for different global pooling 1D layers.r Fc s8tt|ƒjdi|¤Žtdd|_t |¡|_||_dS)Nrrr) rr{rrr rrrÚkeepdims©r"rr|r#r$rr&rqó   zGlobalPooling1D.__init__cCs€t |¡ ¡}|jdkr&|jrt |d|ddg¡St |d|dg¡S|jr5t |dd|dg¡St |d|dg¡S)Nr0rrr(©rr2r3rr|©r"r5rrr&r9ws z$GlobalPooling1D.compute_output_shapecCót‚©N©ÚNotImplementedError©r"r,rrr&r/„ózGlobalPooling1D.callcó8|j|jdœ}tt|ƒ ¡}tt| ¡ƒt| ¡ƒƒS©N)rr|)rr|rr{r;r<r=r>r?r$rr&r;‡ózGlobalPooling1D.get_config)r F© rErFrGrHrr9r/r;rIrrr$r&r{ns  r{cs6eZdZdZd ‡fdd„ Zd dd„Zd dd „Z‡ZS) Ú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)` r c s$tt|ƒjdd|i|¤Žd|_dS)NrTr)rr‹rÚsupports_masking)r"rr#r$rr&r¾sÿ zGlobalAveragePooling1D.__init__NcCs„|jdkrdnd}|dur9t ||dj¡}t ||jdkr dnd¡}||9}tj|||jdtj |||jdStj |||jdS)Nr rr(r©Úaxisr|) rrÚcastÚdtyperr*rÚsumr|Ú reduce_sumÚmean)r"r,ÚmaskÚ steps_axisrrr&r/Ãs ÿþÿþzGlobalAveragePooling1D.callcCsdSr‚r)r"r,r”rrr&Ú compute_maskÑr†z#GlobalAveragePooling1D.compute_mask)r r‚)rErFrGrHrr/r–rIrrr$r&r‹s 0 r‹c@óeZdZdZdd„ZdS)Ú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)` cCs$|jdkrdnd}tj|||jdS)Nr rr(r©rrrMr|)r"r,r•rrr&r/ szGlobalMaxPooling1D.callN©rErFrGrHr/rrrr&r˜Õs 6r˜crz) ÚGlobalPooling2Dz9Abstract class for different global pooling 2D layers. NFc ó8tt|ƒjdi|¤Žt |¡|_tdd|_||_dS)NrZrr) rr›rrrrrr r|r}r$rr&rr~zGlobalPooling2D.__init__cCs„t |¡ ¡}|jdkr'|jrt |ddd|dg¡St |d|dg¡S|jr7t |d|dddg¡St |d|dg¡S)Nr rrrrr€rrr&r9s z$GlobalPooling2D.compute_output_shapecCrr‚rƒr…rrr&r/(r†zGlobalPooling2D.callcr‡rˆ)rr|rr›r;r<r=r>r?r$rr&r;+r‰zGlobalPooling2D.get_config©NFrŠrrr$r&r›s  r›c@r—)ÚGlobalAveragePooling2Da…Global 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)` cCó6|jdkrtj|ddg|jdStj|ddg|jdS©Nr rr(rr©rrr“r|r…rrr&r/^ó zGlobalAveragePooling2D.callNršrrrr&rž1ó ,ržc@r—)Ú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)` cCrŸr r™r…rrr&r/’r¢zGlobalMaxPooling2D.callNršrrrr&r¤er£r¤crz) ÚGlobalPooling3Dz6Abstract class for different global pooling 3D layers.NFc rœ)Nrnrr) rr¥rrrrrr r|r}r$rr&rœr~zGlobalPooling3D.__init__cCsˆt |¡ ¡}|jdkr(|jrt |dddd|dg¡St |d|dg¡S|jr9t |d|ddddg¡St |d|dg¡S)Nr rrrZrr€rrr&r9¢s ÿÿz$GlobalPooling3D.compute_output_shapecCrr‚rƒr…rrr&r/±r†zGlobalPooling3D.callcr‡rˆ)rr|rr¥r;r<r=r>r?r$rr&r;´r‰zGlobalPooling3D.get_configrrŠrrr$r&r¥™s r¥c@r—)Ú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)` cCó6|jdkrtj|gd¢|jdStj|gd¢|jdS©Nr )rr(rr)r(rrZr¡r…rrr&r/ár¢zGlobalAveragePooling3D.callNršrrrr&r¦ºó &r¦c@r—)Ú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)` cCr§r¨r™r…rrr&r/r¢zGlobalMaxPooling3D.callNršrrrr&rªèr©rª).rHrQÚtensorflow.python.frameworkrÚtensorflow.python.kerasrÚ)tensorflow.python.keras.engine.base_layerrÚ)tensorflow.python.keras.engine.input_specrÚtensorflow.python.keras.utilsrÚtensorflow.python.opsrrr r rKrWrYrdrkrmrsrxr{r‹r˜r›ržr¤r¥r¦rªÚ AvgPool1DÚ MaxPool1DÚ AvgPool2DÚ MaxPool2DÚ AvgPool3DÚ MaxPool3DÚGlobalMaxPool1DÚGlobalMaxPool2DÚGlobalMaxPool3DÚGlobalAvgPool1DÚGlobalAvgPool2DÚGlobalAvgPool3Drrrr&ÚsR        M[oU q`FFH< 44!.0