B ӻd)@sdZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd l m Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZGddde Z eddGddde Z!eddGd d!d!e Z"ed"d#Gd$d%d%e Z#ed&d'Gd(d)d)e!Z$ed*d+Gd,d-d-e"Z%ed.d/Gd0d1d1e#Z&Gd2d3d3e Z'ed4d5Gd6d7d7e'Z(ed8d9Gd:d;d;e'Z)ed<Gd=d>d>e"Z*ed?Gd@dAdAe Z+edBGdCdDdDe Z,edEGdFdGdGe Z-edHGdIdJdJe Z.edKGdLdMdMe Z/edNGdOdPdPe Z0edQGdRdSdSe Z1edTGdUdVdVe Z2edWGdXdYdYe Z3e!Z4e"Z5e#Z6e(Z7e)Z8e%Z9e&Z:e%Z;ZdS)Zz9Keras convolution layers and image transformation layers.N)context) tensor_shape) activations)backend) constraints) initializers) regularizers)Layer) InputSpec)AveragePooling1D)AveragePooling2D)AveragePooling3D) MaxPooling1D) MaxPooling2D) MaxPooling3D) conv_utils)tf_utils) array_ops)nn)nn_ops) keras_exportcs~eZdZdZd fdd Zd d Zd d ZddZddZddZ ddZ fddZ ddZ ddZ ddZddZZS)!ConvaqAbstract N-D convolution layer (private, used as implementation base). This layer creates a convolution kernel that is convolved (actually cross-correlated) with the layer input to produce a tensor of outputs. If `use_bias` is True (and a `bias_initializer` is provided), a bias vector is created and added to the outputs. Finally, if `activation` is not `None`, it is applied to the outputs as well. Note: layer attributes cannot be modified after the layer has been called once (except the `trainable` attribute). Args: rank: An integer, the rank of the convolution, e.g. "2" for 2D convolution. filters: Integer, the dimensionality of the output space (i.e. the number of filters in the convolution). Could be "None", eg in the case of depth wise convolution. kernel_size: An integer or tuple/list of n integers, specifying the length of the convolution window. strides: An integer or tuple/list of n integers, specifying the stride length of the convolution. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: One of `"valid"`, `"same"`, or `"causal"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. `"causal"` results in causal (dilated) convolutions, e.g. `output[t]` does not depend on `input[t+1:]`. 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_size, ..., channels)` while `channels_first` corresponds to inputs with shape `(batch_size, channels, ...)`. Note: `channels_first` is only available on GPUs. dilation_rate: An integer or tuple/list of n integers, specifying the dilation rate to use for dilated convolution. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any `strides` value != 1. groups: A positive integer specifying the number of groups in which the input is split along the channel axis. Each group is convolved separately with `filters / groups` filters. The output is the concatenation of all the `groups` results along the channel axis. Input channels and `filters` must both be divisible by `groups`. activation: Activation function to use. If you don't specify anything, no activation is applied. use_bias: Boolean, whether the layer uses a bias. kernel_initializer: An initializer for the convolution kernel. If None, the default initializer (glorot_uniform) will be used. bias_initializer: An initializer for the bias vector. If None, the default initializer (zeros) will be used. kernel_regularizer: Optional regularizer for the convolution kernel. bias_regularizer: Optional regularizer for the bias vector. activity_regularizer: Optional regularizer function for the output. kernel_constraint: Optional projection function to be applied to the kernel after being updated by an `Optimizer` (e.g. used to implement norm constraints or value constraints for layer weights). The function must take as input the unprojected variable and must return the projected variable (which must have the same shape). Constraints are not safe to use when doing asynchronous distributed training. bias_constraint: Optional projection function to be applied to the bias after being updated by an `Optimizer`. validNTglorot_uniformzerosc sZtt|jf||t|d|||_t|trs     zConv._validate_initc Cs@t|}||}||jdkr6td|j|||j||j|jf}|jd||j |j |j d|j d|_ |jr|jd|jf|j|j|jd|j d|_nd|_|}t|jd||id|_|jd krd }nt|jtr|j}n|j}t|j}t|j}|jj}|d krd }t j!t"j#||||j$|d |_%d|_&dS)NrzThe number of input channels must be evenly divisible by the number of groups. Received groups={}, but the input has {} channels (full input shape is {}).kernelT)rshape initializer regularizer constraintrdtypebiasr#)r$axesr%ZVALIDrJZconv1d)r!r2 dilationsr4r)'r TensorShape_get_input_channelr0r.rHr r/ add_weightr7r9r;rQrLr6r8r:r<rR_get_channel_axisr r*r=r2r+strupperlistr"r!rE__name__ functoolspartialrZconvolution_v2rB_convolution_opbuilt) rC input_shapeZ input_channel kernel_shape channel_axisZ tf_paddingZ tf_dilationsZ tf_stridesZ tf_op_namerFrFrGbuilds`             z Conv.buildcs|j}jrt||}|j}jr|jj}jdkrjj rjt j dj df}||7}nN|dk r|djkrfdd}t j||jdd}ntj|j jd}tsԈ|}||jdk r|S|S)Nrr#cstj|jjdS)N)r4)rbias_addrRrB)o)rCrFrG _apply_fn szConv.call.._apply_fn)Z inner_rank)r4)rMr?rpad_compute_causal_paddingr_rLr6r*r@ZreshaperRr/rZsqueeze_batch_dimsrrerBrexecuting_eagerlycompute_output_shape set_shaper5)rCinputsraoutputsZ output_rankrRrg out_shaperF)rCrGcalls*      z Conv.callcsfddt|DS)Nc s8g|]0\}}tj|j|jj|j|dqS))r2stridedilation)rconv_output_lengthr r2r!r").0ilength)rCrFrG sz.Conv._spatial_output_shape..) enumerate)rCZspatial_input_shaperF)rCrG_spatial_output_shapes zConv._spatial_output_shapecCst|}t||jd}|jdkrVt|d||||d|jgSt|d||jg|||ddSdS)Nr channels_last)rrUas_listlenr*r4ryr/)rCra batch_rankrFrFrGrk's (zConv.compute_output_shapecCsdS)NFrF)rCrmrFrFrG_recreate_conv_op4szConv._recreate_conv_opcs|j|j|j|j|j|j|jt|j |j t |j t |j t|jt|jt|jt|jt|jd}tt|}tt|t|S)N)r/r r!r2r4r"r0r5r6r7r8r9r:rr;r<)r/r r!r2r4r"r0r serializer5r6rr7r8rr9r:rrr;r<r'r get_configdictr[items)rCconfig base_config)rErFrGr7s$       zConv.get_configcCs|jd|jdd}t|jdddkr0d}nt|jd}|jdkrhddgg||dgddgg}nddgg|ddg|dgg}|S)z;Calculates padding for 'causal' option for 1-d conv layers.rrZndimsNr#rz)r"r getattrrMr}r4)rCrmZleft_padr~Zcausal_paddingrFrFrGri]s  zConv._compute_causal_paddingcCs|jdkrd|jSdSdS)Nr&r{)r4r*)rCrFrFrGrXjs  zConv._get_channel_axiscCs,|}|j|jdkr tdt||S)NzDThe channel dimension of the inputs should be defined. Found `None`.)rXdimsvaluer.r-)rCrarcrFrFrGrVpszConv._get_input_channelcCs0|jdkrd}n|j}t|ttfs,|}|S)Nr%r)r2r+r[tuplerZ)rC op_paddingrFrFrG_get_padding_opws  zConv._get_padding_op)rrNrrNTrrNNNNNTNN)r\ __module__ __qualname____doc__r(r>rdrpryrkrrrirXrVr __classcell__rFrF)rErGr.s:=):$   & rzkeras.layers.Conv1Dzkeras.layers.Convolution1Dcs"eZdZdZd fd d ZZS) rJa1D convolution layer (e.g. temporal convolution). This layer creates a convolution kernel that is convolved with the layer input over a single spatial (or temporal) dimension to produce a tensor of outputs. If `use_bias` is True, a bias vector is created and added to the outputs. Finally, if `activation` is not `None`, it is applied to the outputs as well. When using this layer as the first layer in a model, provide an `input_shape` argument (tuple of integers or `None`, e.g. `(10, 128)` for sequences of 10 vectors of 128-dimensional vectors, or `(None, 128)` for variable-length sequences of 128-dimensional vectors. Examples: >>> # The inputs are 128-length vectors with 10 timesteps, and the batch size >>> # is 4. >>> input_shape = (4, 10, 128) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.Conv1D( ... 32, 3, activation='relu',input_shape=input_shape[1:])(x) >>> print(y.shape) (4, 8, 32) >>> # With extended batch shape [4, 7] (e.g. weather data where batch >>> # dimensions correspond to spatial location and the third dimension >>> # corresponds to time.) >>> input_shape = (4, 7, 10, 128) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.Conv1D( ... 32, 3, activation='relu', input_shape=input_shape[2:])(x) >>> print(y.shape) (4, 7, 8, 32) Args: filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). kernel_size: An integer or tuple/list of a single integer, specifying the length of the 1D convolution window. strides: An integer or tuple/list of a single integer, specifying the stride length of the convolution. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: One of `"valid"`, `"same"` or `"causal"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. `"causal"` results in causal (dilated) convolutions, e.g. `output[t]` does not depend on `input[t+1:]`. Useful when modeling temporal data where the model should not violate the temporal order. See [WaveNet: A Generative Model for Raw Audio, section 2.1](https://arxiv.org/abs/1609.03499). data_format: A string, one of `channels_last` (default) or `channels_first`. dilation_rate: an integer or tuple/list of a single integer, specifying the dilation rate to use for dilated convolution. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any `strides` value != 1. groups: A positive integer specifying the number of groups in which the input is split along the channel axis. Each group is convolved separately with `filters / groups` filters. The output is the concatenation of all the `groups` results along the channel axis. Input channels and `filters` must both be divisible by `groups`. activation: Activation function to use. If you don't specify anything, no activation is applied ( see `keras.activations`). use_bias: Boolean, whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix ( see `keras.initializers`). Defaults to 'glorot_uniform'. bias_initializer: Initializer for the bias vector ( see `keras.initializers`). Defaults to 'zeros'. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix (see `keras.regularizers`). bias_regularizer: Regularizer function applied to the bias vector ( see `keras.regularizers`). activity_regularizer: Regularizer function applied to the output of the layer (its "activation") ( see `keras.regularizers`). kernel_constraint: Constraint function applied to the kernel matrix ( see `keras.constraints`). bias_constraint: Constraint function applied to the bias vector ( see `keras.constraints`). Input shape: 3+D tensor with shape: `batch_shape + (steps, input_dim)` Output shape: 3+D tensor with shape: `batch_shape + (new_steps, filters)` `steps` value might have changed due to padding or strides. Returns: A tensor of rank 3 representing `activation(conv1d(inputs, kernel) + bias)`. Raises: ValueError: when both `strides > 1` and `dilation_rate > 1`. rrrzNTrrc sntt|jfd|||||||t|| t| t| t| t| t|t|t|d|dS)Nr)r*r/r r!r2r4r"r0r5r6r7r8r9r:rr;r<)r'rJr(rr)rrr)rCr/r r!r2r4r"r0r5r6r7r8r9r:rr;r<rD)rErFrGr(s&  zConv1D.__init__)rrrzrrNTrrNNNNN)r\rrrr(rrFrF)rErGrJsdrJzkeras.layers.Conv2Dzkeras.layers.Convolution2Dcs"eZdZdZd fd d ZZS) Conv2Da2D convolution layer (e.g. spatial convolution over images). This layer creates a convolution kernel that is convolved with the layer input to produce a tensor of outputs. If `use_bias` is True, a bias vector is created and added to the outputs. Finally, if `activation` is not `None`, it is applied to the outputs as well. When using this layer as the first layer in a model, provide the keyword argument `input_shape` (tuple of integers or `None`, does not include the sample axis), e.g. `input_shape=(128, 128, 3)` for 128x128 RGB pictures in `data_format="channels_last"`. You can use `None` when a dimension has variable size. Examples: >>> # The inputs are 28x28 RGB images with `channels_last` and the batch >>> # size is 4. >>> input_shape = (4, 28, 28, 3) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.Conv2D( ... 2, 3, activation='relu', input_shape=input_shape[1:])(x) >>> print(y.shape) (4, 26, 26, 2) >>> # With `dilation_rate` as 2. >>> input_shape = (4, 28, 28, 3) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.Conv2D( ... 2, 3, activation='relu', dilation_rate=2, input_shape=input_shape[1:])(x) >>> print(y.shape) (4, 24, 24, 2) >>> # With `padding` as "same". >>> input_shape = (4, 28, 28, 3) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.Conv2D( ... 2, 3, activation='relu', padding="same", input_shape=input_shape[1:])(x) >>> print(y.shape) (4, 28, 28, 2) >>> # With extended batch shape [4, 7]: >>> input_shape = (4, 7, 28, 28, 3) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.Conv2D( ... 2, 3, activation='relu', input_shape=input_shape[2:])(x) >>> print(y.shape) (4, 7, 26, 26, 2) Args: filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). kernel_size: An integer or tuple/list of 2 integers, specifying the height and width of the 2D convolution 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 convolution along the height and width. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: one of `"valid"` or `"same"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros 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_size, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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`. dilation_rate: an integer or tuple/list of 2 integers, specifying the dilation rate to use for dilated convolution. Can be a single integer to specify the same value for all spatial dimensions. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any stride value != 1. groups: A positive integer specifying the number of groups in which the input is split along the channel axis. Each group is convolved separately with `filters / groups` filters. The output is the concatenation of all the `groups` results along the channel axis. Input channels and `filters` must both be divisible by `groups`. activation: Activation function to use. If you don't specify anything, no activation is applied (see `keras.activations`). use_bias: Boolean, whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix (see `keras.initializers`). Defaults to 'glorot_uniform'. bias_initializer: Initializer for the bias vector (see `keras.initializers`). Defaults to 'zeros'. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix (see `keras.regularizers`). bias_regularizer: Regularizer function applied to the bias vector (see `keras.regularizers`). activity_regularizer: Regularizer function applied to the output of the layer (its "activation") (see `keras.regularizers`). kernel_constraint: Constraint function applied to the kernel matrix (see `keras.constraints`). bias_constraint: Constraint function applied to the bias vector (see `keras.constraints`). Input shape: 4+D tensor with shape: `batch_shape + (channels, rows, cols)` if `data_format='channels_first'` or 4+D tensor with shape: `batch_shape + (rows, cols, channels)` if `data_format='channels_last'`. Output shape: 4+D tensor with shape: `batch_shape + (filters, new_rows, new_cols)` if `data_format='channels_first'` or 4+D tensor with shape: `batch_shape + (new_rows, new_cols, filters)` if `data_format='channels_last'`. `rows` and `cols` values might have changed due to padding. Returns: A tensor of rank 4+ representing `activation(conv2d(inputs, kernel) + bias)`. Raises: ValueError: if `padding` is `"causal"`. ValueError: when both `strides > 1` and `dilation_rate > 1`. rrrNrTrrc sntt|jfd|||||||t|| t| t| t| t| t|t|t|d|dS)Nr#)r*r/r r!r2r4r"r0r5r6r7r8r9r:rr;r<)r'rr(rr)rrr)rCr/r r!r2r4r"r0r5r6r7r8r9r:rr;r<rD)rErFrGr(s&  zConv2D.__init__)rrNrrNTrrNNNNN)r\rrrr(rrFrF)rErGrswrzkeras.layers.Conv3Dzkeras.layers.Convolution3Dcs"eZdZdZd fd d ZZS) Conv3Da3D convolution layer (e.g. spatial convolution over volumes). This layer creates a convolution kernel that is convolved with the layer input to produce a tensor of outputs. If `use_bias` is True, a bias vector is created and added to the outputs. Finally, if `activation` is not `None`, it is applied to the outputs as well. When using this layer as the first layer in a model, provide the keyword argument `input_shape` (tuple of integers or `None`, does not include the sample axis), e.g. `input_shape=(128, 128, 128, 1)` for 128x128x128 volumes with a single channel, in `data_format="channels_last"`. Examples: >>> # The inputs are 28x28x28 volumes with a single channel, and the >>> # batch size is 4 >>> input_shape =(4, 28, 28, 28, 1) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.Conv3D( ... 2, 3, activation='relu', input_shape=input_shape[1:])(x) >>> print(y.shape) (4, 26, 26, 26, 2) >>> # With extended batch shape [4, 7], e.g. a batch of 4 videos of 3D frames, >>> # with 7 frames per video. >>> input_shape = (4, 7, 28, 28, 28, 1) >>> x = tf.random.normal(input_shape) >>> y = tf.keras.layers.Conv3D( ... 2, 3, activation='relu', input_shape=input_shape[2:])(x) >>> print(y.shape) (4, 7, 26, 26, 26, 2) Args: filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). kernel_size: An integer or tuple/list of 3 integers, specifying the depth, height and width of the 3D convolution 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 convolution along each spatial dimension. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: one of `"valid"` or `"same"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros 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_shape + (spatial_dim1, spatial_dim2, spatial_dim3, channels)` while `channels_first` corresponds to inputs with shape `batch_shape + (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". dilation_rate: an integer or tuple/list of 3 integers, specifying the dilation rate to use for dilated convolution. Can be a single integer to specify the same value for all spatial dimensions. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any stride value != 1. groups: A positive integer specifying the number of groups in which the input is split along the channel axis. Each group is convolved separately with `filters / groups` filters. The output is the concatenation of all the `groups` results along the channel axis. Input channels and `filters` must both be divisible by `groups`. activation: Activation function to use. If you don't specify anything, no activation is applied (see `keras.activations`). use_bias: Boolean, whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix (see `keras.initializers`). Defaults to 'glorot_uniform'. bias_initializer: Initializer for the bias vector (see `keras.initializers`). Defaults to 'zeros'. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix (see `keras.regularizers`). bias_regularizer: Regularizer function applied to the bias vector (see `keras.regularizers`). activity_regularizer: Regularizer function applied to the output of the layer (its "activation") (see `keras.regularizers`). kernel_constraint: Constraint function applied to the kernel matrix (see `keras.constraints`). bias_constraint: Constraint function applied to the bias vector (see `keras.constraints`). Input shape: 5+D tensor with shape: `batch_shape + (channels, conv_dim1, conv_dim2, conv_dim3)` if data_format='channels_first' or 5+D tensor with shape: `batch_shape + (conv_dim1, conv_dim2, conv_dim3, channels)` if data_format='channels_last'. Output shape: 5+D tensor with shape: `batch_shape + (filters, new_conv_dim1, new_conv_dim2, new_conv_dim3)` if data_format='channels_first' or 5+D tensor with shape: `batch_shape + (new_conv_dim1, new_conv_dim2, new_conv_dim3, filters)` if data_format='channels_last'. `new_conv_dim1`, `new_conv_dim2` and `new_conv_dim3` values might have changed due to padding. Returns: A tensor of rank 5+ representing `activation(conv3d(inputs, kernel) + bias)`. Raises: ValueError: if `padding` is "causal". ValueError: when both `strides > 1` and `dilation_rate > 1`. rrrrNrTrrc sntt|jfd|||||||t|| t| t| t| t| t|t|t|d|dS)N)r*r/r r!r2r4r"r0r5r6r7r8r9r:rr;r<)r'rr(rr)rrr)rCr/r r!r2r4r"r0r5r6r7r8r9r:rr;r<rD)rErFrGr(s&  zConv3D.__init__)rrNrrNTrrNNNNN)r\rrrr(rrFrF)rErGrsjrzkeras.layers.Conv1DTransposez#keras.layers.Convolution1DTransposecsFeZdZdZdfdd Zd d Zd d ZddZfddZZ S)Conv1DTransposeaTransposed convolution layer (sometimes called Deconvolution). The need for transposed convolutions generally arises from the desire to use a transformation going in the opposite direction of a normal convolution, i.e., from something that has the shape of the output of some convolution to something that has the shape of its input while maintaining a connectivity pattern that is compatible with said convolution. When using this layer as the first layer in a model, provide the keyword argument `input_shape` (tuple of integers or `None`, does not include the sample axis), e.g. `input_shape=(128, 3)` for data with 128 time steps and 3 channels. Args: filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). kernel_size: An integer length of the 1D convolution window. strides: An integer specifying the stride of the convolution along the time dimension. Specifying a stride value != 1 is incompatible with specifying a `dilation_rate` value != 1. Defaults to 1. padding: one of `"valid"` or `"same"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. output_padding: An integer specifying the amount of padding along the time dimension of the output tensor. The amount of output padding must be lower than the stride. If set to `None` (default), the output shape is inferred. 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_size, length, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, channels, length)`. dilation_rate: an integer, specifying the dilation rate to use for dilated convolution. Currently, specifying a `dilation_rate` value != 1 is incompatible with specifying a stride value != 1. Also dilation rate larger than 1 is not currently supported. activation: Activation function to use. If you don't specify anything, no activation is applied ( see `keras.activations`). use_bias: Boolean, whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix ( see `keras.initializers`). Defaults to 'glorot_uniform'. bias_initializer: Initializer for the bias vector ( see `keras.initializers`). Defaults to 'zeros'. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix (see `keras.regularizers`). bias_regularizer: Regularizer function applied to the bias vector ( see `keras.regularizers`). activity_regularizer: Regularizer function applied to the output of the layer (its "activation") (see `keras.regularizers`). kernel_constraint: Constraint function applied to the kernel matrix ( see `keras.constraints`). bias_constraint: Constraint function applied to the bias vector ( see `keras.constraints`). Input shape: 3D tensor with shape: `(batch_size, steps, channels)` Output shape: 3D tensor with shape: `(batch_size, new_steps, filters)` If `output_padding` is specified: ``` new_timesteps = ((timesteps - 1) * strides + kernel_size - 2 * padding + output_padding) ``` Returns: A tensor of rank 3 representing `activation(conv1dtranspose(inputs, kernel) + bias)`. Raises: ValueError: if `padding` is "causal". ValueError: when both `strides` > 1 and `dilation_rate` > 1. References: - [A guide to convolution arithmetic for deep learning]( https://arxiv.org/abs/1603.07285v1) - [Deconvolutional Networks]( https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf) rrNTrrc stt|jf||||||t|| t| t| t| t| t|t|t|d|||_|jdk rt |jdd|_xBt |j |jD]0\}}||krt dt|j dt|jqWdS)N)r/r r!r2r4r"r5r6r7r8r9r:rr;r<routput_paddingzStride z% must be greater than output padding )r'rr(rr)rrrrrr1zipr!r.rY)rCr/r r!r2rr4r"r5r6r7r8r9r:rr;r<rDrqout_pad)rErFrGr(s4   zConv1DTranspose.__init__c Cst|}t|dkr&tdt||}|j|jdkrFtdt||}t d||id|_ |j |j |f}|j d||j|j|jd|jd|_|jr|j d|j f|j|j|jd|jd|_nd|_d|_dS) Nrz1Inputs should have rank 3. Received input shape: zDThe channel dimension of the inputs should be defined. Found `None`.)ndimrSrLT)rrMrNrOrPrrQrR)rrUr}r.rYrXrrr-r r=r r/rWr7r9r;rQrLr6r8r:r<rRr`)rCrarc input_dimrbrFrFrGrds:     zConv1DTranspose.buildc Cs&t|}|d}|jdkr"d}nd}||}|jdkr>d}n |jd}tj||jd|j||jd|j dd}|jdkr||j |f}n |||j f}tj |jdd} t |} t j||j| |j|j| |j d} ts||j} | | |jr tj| |j| d } |jdk r"|| S| S) Nrr&r#r)r2rrqrrr)r)r!r2r4rT)r4)rrMr4rrdeconv_output_lengthr r2r!r"r/rAstackrZconv1d_transposerLrZrrjrkrlr6rrerRr5) rCrm inputs_shape batch_sizet_axisrvrZ out_length output_shaper4output_shape_tensorrnrorFrFrGrpsJ             zConv1DTranspose.callcCst|}t|}|jdkr*d\}}nd\}}|jdkrBd}n |jd}|j||<tj|||j d|j ||j d|j dd||<t|S)Nr&)rr#)r#rr)r2rrqrr) rrUr|r[r4rr/rrr r2r!r")rCrarc_axisrrrFrFrGrks"     z$Conv1DTranspose.compute_output_shapecstt|}|j|d<|S)Nr)r'rrr)rCr)rErFrGr2s zConv1DTranspose.get_config)rrNNrNTrrNNNNN) r\rrrr(rdrprkrrrFrF)rErGrAs&W"2rzkeras.layers.Conv2DTransposez#keras.layers.Convolution2DTransposecsFeZdZdZdfdd Zd d Zd d ZddZfddZZ S)Conv2DTransposeaTransposed convolution layer (sometimes called Deconvolution). The need for transposed convolutions generally arises from the desire to use a transformation going in the opposite direction of a normal convolution, i.e., from something that has the shape of the output of some convolution to something that has the shape of its input while maintaining a connectivity pattern that is compatible with said convolution. When using this layer as the first layer in a model, provide the keyword argument `input_shape` (tuple of integers or `None`, does not include the sample axis), e.g. `input_shape=(128, 128, 3)` for 128x128 RGB pictures in `data_format="channels_last"`. Args: filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). kernel_size: An integer or tuple/list of 2 integers, specifying the height and width of the 2D convolution 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 convolution along the height and width. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: one of `"valid"` or `"same"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. output_padding: An integer or tuple/list of 2 integers, specifying the amount of padding along the height and width of the output tensor. Can be a single integer to specify the same value for all spatial dimensions. The amount of output padding along a given dimension must be lower than the stride along that same dimension. If set to `None` (default), the output shape is inferred. 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_size, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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". dilation_rate: an integer or tuple/list of 2 integers, specifying the dilation rate to use for dilated convolution. Can be a single integer to specify the same value for all spatial dimensions. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any stride value != 1. activation: Activation function to use. If you don't specify anything, no activation is applied ( see `keras.activations`). use_bias: Boolean, whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix ( see `keras.initializers`). Defaults to 'glorot_uniform'. bias_initializer: Initializer for the bias vector ( see `keras.initializers`). Defaults to 'zeros'. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix (see `keras.regularizers`). bias_regularizer: Regularizer function applied to the bias vector ( see `keras.regularizers`). activity_regularizer: Regularizer function applied to the output of the layer (its "activation") (see `keras.regularizers`). kernel_constraint: Constraint function applied to the kernel matrix ( see `keras.constraints`). bias_constraint: Constraint function applied to the bias vector ( see `keras.constraints`). Input shape: 4D tensor with shape: `(batch_size, channels, rows, cols)` if data_format='channels_first' or 4D tensor with shape: `(batch_size, rows, cols, channels)` if data_format='channels_last'. Output shape: 4D tensor with shape: `(batch_size, filters, new_rows, new_cols)` if data_format='channels_first' or 4D tensor with shape: `(batch_size, new_rows, new_cols, filters)` if data_format='channels_last'. `rows` and `cols` values might have changed due to padding. If `output_padding` is specified: ``` new_rows = ((rows - 1) * strides[0] + kernel_size[0] - 2 * padding[0] + output_padding[0]) new_cols = ((cols - 1) * strides[1] + kernel_size[1] - 2 * padding[1] + output_padding[1]) ``` Returns: A tensor of rank 4 representing `activation(conv2dtranspose(inputs, kernel) + bias)`. Raises: ValueError: if `padding` is "causal". ValueError: when both `strides` > 1 and `dilation_rate` > 1. References: - [A guide to convolution arithmetic for deep learning](https://arxiv.org/abs/1603.07285v1) - [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf) rrrNTrrc stt|jf||||||t|| t| t| t| t| t|t|t|d|||_|jdk rt |jdd|_xBt |j |jD]0\}}||krt dt|j dt|jqWdS)N)r/r r!r2r4r"r5r6r7r8r9r:rr;r<r#rzStride z% must be greater than output padding )r'rr(rr)rrrrrr1rr!r.rY)rCr/r r!r2rr4r"r5r6r7r8r9r:rr;r<rDrqr)rErFrGr(s4   zConv2DTranspose.__init__c Cst|}t|dkr&tdt||}|j|jdkrFtdt||}t d||id|_ |j |j |f}|j d||j|j|jd|jd|_|jr|j d|j f|j|j|jd|jd|_nd|_d|_dS) Nz1Inputs should have rank 4. Received input shape: zDThe channel dimension of the inputs should be defined. Found `None`.)rrSrLT)rrMrNrOrPrrQrR)rrUr}r.rYrXrrr-r r=r r/rWr7r9r;rQrLr6r8r:r<rRr`)rCrarcrrbrFrFrGrds:     zConv2DTranspose.buildc Cst|}|d}|jdkr&d\}}nd\}}d\}}|jjdk r\|j}||}||}|dk rh|n||}|dk r||n||}|j\} } |j\} } |jdkrd} }n |j\} }tj || |j | | |j dd}tj || |j || |j dd}|jdkr||j ||f}n||||j f}t |}tj||j||j|j |j|j d}tsh||j}|||jrtj||jtj|jd d d }|jdk r||S|S) Nrr&)r#r)rr#)NN)r2rrqrrr)r!r2r4r"r)r)r4)rrMr4r*r|r r!rrrr2r"r/rrZconv2d_transposerLrrjrkrlr6rrerRrAr5)rCrmrrh_axisw_axisheightwidthrkernel_hkernel_wstride_hstride_w out_pad_h out_pad_w out_height out_widthrrrnrorFrFrGrpsh                  zConv2DTranspose.callc Cst|}t|}|jdkr,d\}}}n d\}}}|j\}}|j\}} |jdkr^d} } n |j\} } |j||<t j ||||j | ||j dd||<t j ||||j | | |j dd||<t|S)Nr&)rr#r)rrr#r)r2rrqrrr) rrUr|r[r4r r!rr/rrr2r") rCrarrrrrrrrrrrFrFrGrk@s4         z$Conv2DTranspose.compute_output_shapecstt|}|j|d<|S)Nr)r'rrr)rCr)rErFrGras zConv2DTranspose.get_config)rrNNrNTrrNNNNN) r\rrrr(rdrprkrrrFrF)rErGr8s&o"G!rzkeras.layers.Conv3DTransposez#keras.layers.Convolution3DTransposecsFeZdZdZdfdd Zd d Zd d ZddZfddZZ S)Conv3DTransposeaTransposed convolution layer (sometimes called Deconvolution). The need for transposed convolutions generally arises from the desire to use a transformation going in the opposite direction of a normal convolution, i.e., from something that has the shape of the output of some convolution to something that has the shape of its input while maintaining a connectivity pattern that is compatible with said convolution. When using this layer as the first layer in a model, provide the keyword argument `input_shape` (tuple of integers or `None`, does not include the sample axis), e.g. `input_shape=(128, 128, 128, 3)` for a 128x128x128 volume with 3 channels if `data_format="channels_last"`. Args: filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). kernel_size: An integer or tuple/list of 3 integers, specifying the depth, height and width of the 3D convolution 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 convolution along the depth, height and width. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: one of `"valid"` or `"same"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. output_padding: An integer or tuple/list of 3 integers, specifying the amount of padding along the depth, height, and width. Can be a single integer to specify the same value for all spatial dimensions. The amount of output padding along a given dimension must be lower than the stride along that same dimension. If set to `None` (default), the output shape is inferred. 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_size, depth, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, channels, depth, 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". dilation_rate: an integer or tuple/list of 3 integers, specifying the dilation rate to use for dilated convolution. Can be a single integer to specify the same value for all spatial dimensions. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any stride value != 1. activation: Activation function to use. If you don't specify anything, no activation is applied ( see `keras.activations`). use_bias: Boolean, whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix ( see `keras.initializers`). Defaults to 'glorot_uniform'. bias_initializer: Initializer for the bias vector ( see `keras.initializers`). Defaults to 'zeros'. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix ( see `keras.regularizers`). bias_regularizer: Regularizer function applied to the bias vector ( see `keras.regularizers`). activity_regularizer: Regularizer function applied to the output of the layer (its "activation") ( see `keras.regularizers`). kernel_constraint: Constraint function applied to the kernel matrix ( see `keras.constraints`). bias_constraint: Constraint function applied to the bias vector ( see `keras.constraints`). Input shape: 5D tensor with shape: `(batch_size, channels, depth, rows, cols)` if data_format='channels_first' or 5D tensor with shape: `(batch_size, depth, rows, cols, channels)` if data_format='channels_last'. Output shape: 5D tensor with shape: `(batch_size, filters, new_depth, new_rows, new_cols)` if data_format='channels_first' or 5D tensor with shape: `(batch_size, new_depth, new_rows, new_cols, filters)` if data_format='channels_last'. `depth` and `rows` and `cols` values might have changed due to padding. If `output_padding` is specified:: ``` new_depth = ((depth - 1) * strides[0] + kernel_size[0] - 2 * padding[0] + output_padding[0]) new_rows = ((rows - 1) * strides[1] + kernel_size[1] - 2 * padding[1] + output_padding[1]) new_cols = ((cols - 1) * strides[2] + kernel_size[2] - 2 * padding[2] + output_padding[2]) ``` Returns: A tensor of rank 5 representing `activation(conv3dtranspose(inputs, kernel) + bias)`. Raises: ValueError: if `padding` is "causal". ValueError: when both `strides` > 1 and `dilation_rate` > 1. References: - [A guide to convolution arithmetic for deep learning](https://arxiv.org/abs/1603.07285v1) - [Deconvolutional Networks](https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf) rrrrNTrrc stt|jf||||||t|| t| t| t| t| t|t|t|d|||_|jdk rt |jdd|_xBt |j |jD]0\}}||krt dt|j dt|jqWdS)N)r/r r!r2r4r"r5r6r7r8r9r:rr;r<rrzStride z% must be greater than output padding )r'rr(rr)rrrrrr1rr!r.rY)rCr/r r!r2rr4r"r5r6r7r8r9r:rr;r<rDrqr)rErFrGr(s4   zConv3DTranspose.__init__c Cst|}t|dkr$tdt||}|j|jdkrLtdt|t||}|j |j |f}t d||id|_ |j d||j|j|jd|jd|_|jr|j d|j f|j|j|jd|jd|_nd|_d|_dS) Nz0Inputs should have rank 5, received input shape:zCThe channel dimension of the inputs should be defined, found None: )rrSrLT)rMrNrOrPrrQrR)rrUr}r.rYrXrrr-r r/r r=rWr7r9r;rQrLr6r8r:r<rRr`)rCrarcrrbrFrFrGrd s<      zConv3DTranspose.buildc Cst|}|d}|jdkr(d\}}}n d\}}}||}||}||} |j\} } } |j\} }}|jdkrzd}}}n |j\}}}tj|| |j|| d}tj|| |j||d}tj| | |j||d}|jdkr||j |||f}dd| ||f}n|||||j f}d| ||df}t |}t j ||j ||tj|jdd|jd }tsd||j}|||jrt j||jtj|jd dd }|jdk r||S|S) Nrr&)r#rr)rr#r)r2rrqrr)r)r4r2r)r4)rrMr4r r!rrrr2r/rrZconv3d_transposerLrArZrrjrkrlr6rerRr5)rCrmrrd_axisrrdepthrrkernel_drrstride_drr out_pad_drrZ out_depthrrrr!rrnrorFrFrGrp/sl                zConv3DTranspose.callcCst|}t|}|jdkr.d\}}}}n d\}}}}|j\}}} |j\} } } |jdkrjd} }}n |j\} }}|j||<t j ||||j | | d||<t j ||||j || d||<t j ||| |j || d||<t|S)Nr&)rr#rr)rrr#r)r2rrq) rrUr|r[r4r r!rr/rrr2)rCrarrrrrrrrrrrrrrrFrFrGrkts<          z$Conv3DTranspose.compute_output_shapecs&tt|}|d|j|d<|S)Nr"r)r'rrpopr)rCr)rErFrGrs  zConv3DTranspose.get_config)rrNNrNTrrNNNNN) r\rrrr(rdrprkrrrFrF)rErGrgs&v"E%rcs>eZdZdZdfdd Zd d Zd d ZfddZZS) SeparableConvaAbstract base layer for separable nD convolution. This layer performs a depthwise convolution that acts separately on channels, followed by a pointwise convolution that mixes channels. If `use_bias` is True and a bias initializer is provided, it adds a bias vector to the output. It then optionally applies an activation function to produce the final output. Args: rank: An integer, the rank of the convolution, e.g. "2" for 2D convolution. filters: Integer, the dimensionality of the output space (i.e. the number of filters in the convolution). kernel_size: A tuple or list of integers specifying the spatial dimensions of the filters. Can be a single integer to specify the same value for all spatial dimensions. strides: A tuple or list of integers specifying the strides of the convolution. Can be a single integer to specify the same value for all spatial dimensions. Specifying any `stride` value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: One of `"valid"` or `"same"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros 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_size, ..., channels)` while `channels_first` corresponds to inputs with shape `(batch_size, channels, ...)`. dilation_rate: An integer or tuple/list of 2 integers, specifying the dilation rate to use for dilated convolution. Can be a single integer to specify the same value for all spatial dimensions. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any stride value != 1. depth_multiplier: The number of depthwise convolution output channels for each input channel. The total number of depthwise convolution output channels will be equal to `num_filters_in * depth_multiplier`. activation: Activation function to use. If you don't specify anything, no activation is applied ( see `keras.activations`). use_bias: Boolean, whether the layer uses a bias. depthwise_initializer: An initializer for the depthwise convolution kernel ( see `keras.initializers`). If None, then the default initializer ( 'glorot_uniform') will be used. pointwise_initializer: An initializer for the pointwise convolution kernel ( see `keras.initializers`). If None, then the default initializer ('glorot_uniform') will be used. bias_initializer: An initializer for the bias vector. If None, the default initializer ('zeros') will be used (see `keras.initializers`). depthwise_regularizer: Optional regularizer for the depthwise convolution kernel. pointwise_regularizer: Optional regularizer for the pointwise convolution kernel. bias_regularizer: Optional regularizer for the bias vector. activity_regularizer: Optional regularizer function for the output. depthwise_constraint: Optional projection function to be applied to the depthwise kernel after being updated by an `Optimizer` (e.g. used for norm constraints or value constraints for layer weights). The function must take as input the unprojected variable and must return the projected variable (which must have the same shape). Constraints are not safe to use when doing asynchronous distributed training. pointwise_constraint: Optional projection function to be applied to the pointwise kernel after being updated by an `Optimizer`. bias_constraint: Optional projection function to be applied to the bias after being updated by an `Optimizer`. trainable: Boolean, if `True` the weights of this layer will be marked as trainable (and listed in `layer.trainable_weights`). rrNTrrc stt|jf|||||||t| | t| t|t||||d|||_t| |_t| |_ t||_ t||_ t ||_ t ||_dS)N)r*r/r r!r2r4r"r5r6r8r:rr<rr)r'rr(rr)rrdepth_multiplierdepthwise_initializerpointwise_initializerdepthwise_regularizerpointwise_regularizerrdepthwise_constraintpointwise_constraint)rCr*r/r r!r2r4r"rr5r6rrr8rrr:rrrr<rrrD)rErFrGr(s0      zSeparableConv.__init__c Cst|}|}|j|jdkr*tdt||}t|jd||id|_ |j ||j f}d|j|j ||j f}|j d||j|j|jd|jd|_|j d||j|j|jd|jd|_|jr|j d |j f|j|j|jd|jd|_nd|_d|_dS) NzDThe channel dimension of the inputs should be defined. Found `None`.r#)rrS)rdepthwise_kernelT)rrMrNrOrPrrQpointwise_kernelrR)rrUrXrrr.r-r r*r=r rr/rWrrrrQrrrrrr6r8r:r<rRr`)rCrarcrdepthwise_kernel_shapeZpointwise_kernel_shaperFrFrGrdsJ      zSeparableConv.buildcCstdS)N)NotImplementedError)rCrmrFrFrGrpCszSeparableConv.callcs|j|j|j|j|j|j|jt|j |j t |j t |j t |jt|jt|jt|jt|jt|jt|jt|jd}tt|}tt|t|S)N)r/r r!r2r4rr"r5r6rrr8rrr:rrrr<)r/r r!r2r4rr"rrr5r6rrrr8rrrr:rrrrr<r'rrrr[r)rCrr)rErFrGrFs*          zSeparableConv.get_config)rrNrrNTrrrNNNNNNNTN) r\rrrr(rdrprrrFrF)rErGrs.E+rzkeras.layers.SeparableConv1Dz#keras.layers.SeparableConvolution1Dcs*eZdZdZd fdd Zd d ZZS) rKaWDepthwise separable 1D convolution. This layer performs a depthwise convolution that acts separately on channels, followed by a pointwise convolution that mixes channels. If `use_bias` is True and a bias initializer is provided, it adds a bias vector to the output. It then optionally applies an activation function to produce the final output. Args: filters: Integer, the dimensionality of the output space (i.e. the number of filters in the convolution). kernel_size: A single integer specifying the spatial dimensions of the filters. strides: A single integer specifying the strides of the convolution. Specifying any `stride` value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: One of `"valid"`, `"same"`, or `"causal"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. `"causal"` results in causal (dilated) convolutions, e.g. `output[t]` does not depend on `input[t+1:]`. 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_size, length, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, channels, length)`. dilation_rate: A single integer, specifying the dilation rate to use for dilated convolution. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any stride value != 1. depth_multiplier: The number of depthwise convolution output channels for each input channel. The total number of depthwise convolution output channels will be equal to `num_filters_in * depth_multiplier`. activation: Activation function to use. If you don't specify anything, no activation is applied ( see `keras.activations`). use_bias: Boolean, whether the layer uses a bias. depthwise_initializer: An initializer for the depthwise convolution kernel ( see `keras.initializers`). If None, then the default initializer ( 'glorot_uniform') will be used. pointwise_initializer: An initializer for the pointwise convolution kernel ( see `keras.initializers`). If None, then the default initializer ('glorot_uniform') will be used. bias_initializer: An initializer for the bias vector. If None, the default initializer ('zeros') will be used (see `keras.initializers`). depthwise_regularizer: Optional regularizer for the depthwise convolution kernel (see `keras.regularizers`). pointwise_regularizer: Optional regularizer for the pointwise convolution kernel (see `keras.regularizers`). bias_regularizer: Optional regularizer for the bias vector ( see `keras.regularizers`). activity_regularizer: Optional regularizer function for the output ( see `keras.regularizers`). depthwise_constraint: Optional projection function to be applied to the depthwise kernel after being updated by an `Optimizer` (e.g. used for norm constraints or value constraints for layer weights). The function must take as input the unprojected variable and must return the projected variable (which must have the same shape). Constraints are not safe to use when doing asynchronous distributed training ( see `keras.constraints`). pointwise_constraint: Optional projection function to be applied to the pointwise kernel after being updated by an `Optimizer` ( see `keras.constraints`). bias_constraint: Optional projection function to be applied to the bias after being updated by an `Optimizer` ( see `keras.constraints`). trainable: Boolean, if `True` the weights of this layer will be marked as trainable (and listed in `layer.trainable_weights`). Input shape: 3D tensor with shape: `(batch_size, channels, steps)` if data_format='channels_first' or 5D tensor with shape: `(batch_size, steps, channels)` if data_format='channels_last'. Output shape: 3D tensor with shape: `(batch_size, filters, new_steps)` if data_format='channels_first' or 3D tensor with shape: `(batch_size, new_steps, filters)` if data_format='channels_last'. `new_steps` value might have changed due to padding or strides. Returns: A tensor of rank 3 representing `activation(separableconv1d(inputs, kernel) + bias)`. Raises: ValueError: when both `strides` > 1 and `dilation_rate` > 1. rrNTrrc stt|jfd|||||||t|| t| t| t| t| t|t|t|t|t|t|d|dS)Nr)r*r/r r!r2r4r"rr5r6rrr8rrr:rrrr<)r'rKr(rr)rrr)rCr/r r!r2r4r"rr5r6rrr8rrr:rrrr<rD)rErFrGr(s,  zSeparableConv1D.__init__c Cs |jdkrt|||}|jdkr>d|jdd}d}nd|jd}d}t||}t|jd}t|jd}d|j }|jdkrd}n|j}t j ||||| |t j|jd d d }|jrt j||jt j|jd d d }t||g}|jdk r||S|S) Nr%rz)rr#r)rrrrr)r)r!r2rater4)r4)r2rrhrir4r!Z expand_dimsrrr"rseparable_conv2drZrrAr6rerRZsqueezer5) rCrmr!Zspatial_start_dimrrr"rrnrFrFrGrps>       zSeparableConv1D.call)rrNrrNTrrrNNNNNNN)r\rrrr(rprrFrF)rErGrKss&\rKzkeras.layers.SeparableConv2Dz#keras.layers.SeparableConvolution2Dcs*eZdZdZd fd d Zd d ZZS)SeparableConv2Da'Depthwise separable 2D convolution. Separable convolutions consist of first performing a depthwise spatial convolution (which acts on each input channel separately) followed by a pointwise convolution which mixes the resulting output channels. The `depth_multiplier` argument controls how many output channels are generated per input channel in the depthwise step. Intuitively, separable convolutions can be understood as a way to factorize a convolution kernel into two smaller kernels, or as an extreme version of an Inception block. Args: filters: Integer, the dimensionality of the output space (i.e. the number of output filters in the convolution). kernel_size: An integer or tuple/list of 2 integers, specifying the height and width of the 2D convolution 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 convolution along the height and width. Can be a single integer to specify the same value for all spatial dimensions. Current implementation only supports equal length strides in the row and column dimensions. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: one of `"valid"` or `"same"` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros 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_size, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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". dilation_rate: An integer or tuple/list of 2 integers, specifying the dilation rate to use for dilated convolution. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any `strides` value != 1. depth_multiplier: The number of depthwise convolution output channels for each input channel. The total number of depthwise convolution output channels will be equal to `filters_in * depth_multiplier`. activation: Activation function to use. If you don't specify anything, no activation is applied ( see `keras.activations`). use_bias: Boolean, whether the layer uses a bias vector. depthwise_initializer: An initializer for the depthwise convolution kernel ( see `keras.initializers`). If None, then the default initializer ( 'glorot_uniform') will be used. pointwise_initializer: An initializer for the pointwise convolution kernel ( see `keras.initializers`). If None, then the default initializer ('glorot_uniform') will be used. bias_initializer: An initializer for the bias vector. If None, the default initializer ('zeros') will be used (see `keras.initializers`). depthwise_regularizer: Regularizer function applied to the depthwise kernel matrix (see `keras.regularizers`). pointwise_regularizer: Regularizer function applied to the pointwise kernel matrix (see `keras.regularizers`). bias_regularizer: Regularizer function applied to the bias vector ( see `keras.regularizers`). activity_regularizer: Regularizer function applied to the output of the layer (its "activation") ( see `keras.regularizers`). depthwise_constraint: Constraint function applied to the depthwise kernel matrix ( see `keras.constraints`). pointwise_constraint: Constraint function applied to the pointwise kernel matrix ( see `keras.constraints`). bias_constraint: Constraint function applied to the bias vector ( see `keras.constraints`). Input shape: 4D tensor with shape: `(batch_size, channels, rows, cols)` if data_format='channels_first' or 4D tensor with shape: `(batch_size, rows, cols, channels)` if data_format='channels_last'. Output shape: 4D tensor with shape: `(batch_size, filters, new_rows, new_cols)` if data_format='channels_first' or 4D tensor with shape: `(batch_size, new_rows, new_cols, filters)` if data_format='channels_last'. `rows` and `cols` values might have changed due to padding. Returns: A tensor of rank 4 representing `activation(separableconv2d(inputs, kernel) + bias)`. Raises: ValueError: if `padding` is "causal". ValueError: when both `strides` > 1 and `dilation_rate` > 1. rrrNrTrrc stt|jfd|||||||t|| t| t| t| t| t|t|t|t|t|t|d|dS)Nr#)r*r/r r!r2r4r"rr5r6rrr8rrr:rrrr<)r'rr(rr)rrr)rCr/r r!r2r4r"rr5r6rrr8rrr:rrrr<rD)rErFrGr(s,  zSeparableConv2D.__init__c Cs|jdkrd|jd}n d|j}tj||j|j||j|jt j |jddd}|j rxtj ||j t j |jddd}|jdk r||S|S)Nrz)r)rrr)r)r!r2rr4)r4)r4r!rrrrr2rZr"rrAr6rerRr5)rCrmr!rnrFrFrGrps&    zSeparableConv2D.call)rrNrrNTrrrNNNNNNN)r\rrrr(rprrFrF)rErGr(s&frzkeras.layers.DepthwiseConv2DcsLeZdZdZdfd d Zd d Zd dZejddZ fddZ Z S)DepthwiseConv2DaDepthwise 2D convolution. Depthwise convolution is a type of convolution in which a single convolutional filter is apply to each input channel (i.e. in a depthwise way). You can understand depthwise convolution as being the first step in a depthwise separable convolution. It is implemented via the following steps: - Split the input into individual channels. - Convolve each input with the layer's kernel (called a depthwise kernel). - Stack the convolved outputs together (along the channels axis). Unlike a regular 2D convolution, depthwise convolution does not mix information across different input channels. The `depth_multiplier` argument controls how many output channels are generated per input channel in the depthwise step. Args: kernel_size: An integer or tuple/list of 2 integers, specifying the height and width of the 2D convolution 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 convolution along the height and width. Can be a single integer to specify the same value for all spatial dimensions. Specifying any stride value != 1 is incompatible with specifying any `dilation_rate` value != 1. padding: one of `'valid'` or `'same'` (case-insensitive). `"valid"` means no padding. `"same"` results in padding with zeros evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input. depth_multiplier: The number of depthwise convolution output channels for each input channel. The total number of depthwise convolution output channels will be equal to `filters_in * depth_multiplier`. 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_size, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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'. dilation_rate: An integer or tuple/list of 2 integers, specifying the dilation rate to use for dilated convolution. Currently, specifying any `dilation_rate` value != 1 is incompatible with specifying any `strides` value != 1. activation: Activation function to use. If you don't specify anything, no activation is applied ( see `keras.activations`). use_bias: Boolean, whether the layer uses a bias vector. depthwise_initializer: Initializer for the depthwise kernel matrix ( see `keras.initializers`). If None, the default initializer ( 'glorot_uniform') will be used. bias_initializer: Initializer for the bias vector ( see `keras.initializers`). If None, the default initializer ( 'zeros') will bs used. depthwise_regularizer: Regularizer function applied to the depthwise kernel matrix (see `keras.regularizers`). bias_regularizer: Regularizer function applied to the bias vector ( see `keras.regularizers`). activity_regularizer: Regularizer function applied to the output of the layer (its 'activation') ( see `keras.regularizers`). depthwise_constraint: Constraint function applied to the depthwise kernel matrix ( see `keras.constraints`). bias_constraint: Constraint function applied to the bias vector ( see `keras.constraints`). Input shape: 4D tensor with shape: `[batch_size, channels, rows, cols]` if data_format='channels_first' or 4D tensor with shape: `[batch_size, rows, cols, channels]` if data_format='channels_last'. Output shape: 4D tensor with shape: `[batch_size, channels * depth_multiplier, new_rows, new_cols]` if data_format='channels_first' or 4D tensor with shape: `[batch_size, new_rows, new_cols, channels * depth_multiplier]` if data_format='channels_last'. `rows` and `cols` values might have changed due to padding. Returns: A tensor of rank 4 representing `activation(depthwiseconv2d(inputs, kernel) + bias)`. Raises: ValueError: if `padding` is "causal". ValueError: when both `strides` > 1 and `dilation_rate` > 1. rrrrNTrrc shtt|jfd|||||||| | |d |||_t| |_t| |_t ||_ t| |_ dS)N) r/r r!r2r4r"r5r6r:rr<) r'rr(rrr)rrrrrr8)rCr r!r2rr4r"r5r6rr8rr:rrr<rD)rErFrGr(: s$    zDepthwiseConv2D.__init__cCst|dkrtdt|t|}|}|j|jdkrDtdt||}|j d|j d||j f}|j ||j d|j |jd|_|jr|j ||j f|jd|j|jd|_nd|_td||id |_d |_dS) NrzEInputs to `DepthwiseConv2D` should have rank 4. Received input shape:zYThe channel dimension of the inputs to `DepthwiseConv2D` should be defined. Found `None`.rrr)rMrNrrOrPrR)rrST)r}r.rYrrUrXrrr-r rrWrrrrr6r8r:r<rRr r=r`)rCrarcrrrFrFrGrd^ s6     zDepthwiseConv2D.buildcCsRtj||j|j|j|j|jd}|jr:tj||j |jd}|j dk rN| |S|S)N)r!r2r"r4)r4) rZdepthwise_conv2drr!r2r"r4r6rerRr5)rCrmrnrFrFrGrp s    zDepthwiseConv2D.callcCs|jdkr*|d}|d}|d|j}n(|jdkrR|d}|d}|d|j}t||jd|j|jd|jd}t||jd|j|jd|jd}|jdkr|d|||fS|jdkr|d|||fSdS)Nr&r#rrrzr)r4rrrsr r2r!r")rCrarowscolsZ out_filtersrFrFrGrk s(      z$DepthwiseConv2D.compute_output_shapecsttt|}|d|d|d|d|j|d<t|j|d<t|j |d<t |j |d<|S) Nr/r7r9r;rrrr) r'rrrrrrrrrrr)rCr)rErFrGr s        zDepthwiseConv2D.get_config)rrrNrNTrrNNNNN) r\rrrr(rdrprZshape_type_conversionrkrrrFrF)rErGrs&b#rzkeras.layers.UpSampling1Dcs>eZdZdZd fdd ZddZddZfd d ZZS) UpSampling1DaUpsampling layer for 1D inputs. Repeats each temporal step `size` times along the time axis. Examples: >>> input_shape = (2, 2, 3) >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) >>> print(x) [[[ 0 1 2] [ 3 4 5]] [[ 6 7 8] [ 9 10 11]]] >>> y = tf.keras.layers.UpSampling1D(size=2)(x) >>> print(y) tf.Tensor( [[[ 0 1 2] [ 0 1 2] [ 3 4 5] [ 3 4 5]] [[ 6 7 8] [ 6 7 8] [ 9 10 11] [ 9 10 11]]], shape=(2, 4, 3), dtype=int64) Args: size: Integer. Upsampling factor. Input shape: 3D tensor with shape: `(batch_size, steps, features)`. Output shape: 3D tensor with shape: `(batch_size, upsampled_steps, features)`. r#c s,tt|jf|t||_tdd|_dS)Nr)r)r'rr(r-sizer r=)rCrrD)rErFrGr( s zUpSampling1D.__init__cCsDt|}|ddk r(|j|dnd}t|d||dgS)Nrrr#)rrUr|r)rCrarrFrFrGrk sz!UpSampling1D.compute_output_shapecCstj||jdd}|S)Nr)Zaxis)rZrepeat_elementsr)rCrmoutputrFrFrGrp szUpSampling1D.callcs4d|ji}tt|}tt|t|S)Nr)rr'rrrr[r)rCrr)rErFrGr s zUpSampling1D.get_config)r#) r\rrrr(rkrprrrFrF)rErGr s #rzkeras.layers.UpSampling2Dcs>eZdZdZd fdd ZddZd d Zfd d ZZS) UpSampling2DaUpsampling layer for 2D inputs. Repeats the rows and columns of the data by `size[0]` and `size[1]` respectively. Examples: >>> input_shape = (2, 2, 1, 3) >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) >>> print(x) [[[[ 0 1 2]] [[ 3 4 5]]] [[[ 6 7 8]] [[ 9 10 11]]]] >>> y = tf.keras.layers.UpSampling2D(size=(1, 2))(x) >>> print(y) tf.Tensor( [[[[ 0 1 2] [ 0 1 2]] [[ 3 4 5] [ 3 4 5]]] [[[ 6 7 8] [ 6 7 8]] [[ 9 10 11] [ 9 10 11]]]], shape=(2, 2, 2, 3), dtype=int64) Args: size: Int, or tuple of 2 integers. The upsampling factors for rows and columns. 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_size, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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". interpolation: A string, one of `nearest` or `bilinear`. Input shape: 4D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, rows, cols, channels)` - If `data_format` is `"channels_first"`: `(batch_size, channels, rows, cols)` Output shape: 4D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, upsampled_rows, upsampled_cols, channels)` - If `data_format` is `"channels_first"`: `(batch_size, channels, upsampled_rows, upsampled_cols)` r#r#Nnearestc sTtt|jf|t||_t|dd|_|dkr>td||_ t dd|_ dS)Nr#r>bilinearrzF`interpolation` argument should be one of `"nearest"` or `"bilinear"`.r)r) r'rr(rr3r4r1rr. interpolationr r=)rCrr4rrD)rErFrGr(0 s zUpSampling2D.__init__cCst|}|jdkrv|ddk r6|jd|dnd}|ddk rX|jd|dnd}t|d|d||gS|ddk r|jd|dnd}|ddk r|jd|dnd}t|d|||dgSdS)Nr&r#rrr)rrUr|r4r)rCrarrrFrFrGrk> s """"z!UpSampling2D.compute_output_shapecCs$tj||jd|jd|j|jdS)Nrr)r)rZ resize_imagesrr4r)rCrmrFrFrGrpO szUpSampling2D.callcs<|j|j|jd}tt|}tt|t|S)N)rr4r) rr4rr'rrrr[r)rCrr)rErFrGrT s  zUpSampling2D.get_config)rNr) r\rrrr(rkrprrrFrF)rErGr s8 rzkeras.layers.UpSampling3Dcs>eZdZdZd fdd ZddZdd Zfd d ZZS) UpSampling3DaUpsampling layer for 3D inputs. Repeats the 1st, 2nd and 3rd dimensions of the data by `size[0]`, `size[1]` and `size[2]` respectively. Examples: >>> input_shape = (2, 1, 2, 1, 3) >>> x = tf.constant(1, shape=input_shape) >>> y = tf.keras.layers.UpSampling3D(size=2)(x) >>> print(y.shape) (2, 2, 4, 2, 3) Args: size: Int, or tuple of 3 integers. The upsampling factors for dim1, dim2 and dim3. 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_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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: 5D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, dim1, dim2, dim3, channels)` - If `data_format` is `"channels_first"`: `(batch_size, channels, dim1, dim2, dim3)` Output shape: 5D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, upsampled_dim1, upsampled_dim2, upsampled_dim3, channels)` - If `data_format` is `"channels_first"`: `(batch_size, channels, upsampled_dim1, upsampled_dim2, upsampled_dim3)` r#r#r#Nc s>t||_t|dd|_tdd|_tt|j f|dS)Nrrr)r) rr3r4r1rr r=r'rr()rCrr4rD)rErFrGr( s  zUpSampling3D.__init__cCs t|}|jdkr|ddk r6|jd|dnd}|ddk rX|jd|dnd}|ddk rz|jd|dnd}t|d|d|||gS|ddk r|jd|dnd}|ddk r|jd|dnd}|ddk r|jd|dnd}t|d||||dgSdS)Nr&r#rrrr)rrUr|r4r)rCradim1dim2dim3rFrFrGrk s """"""z!UpSampling3D.compute_output_shapecCs&t||jd|jd|jd|jS)Nrrr#)rZresize_volumesrr4)rCrmrFrFrGrp szUpSampling3D.callcs8|j|jd}tt|}tt|t|S)N)rr4)rr4r'rrrr[r)rCrr)rErFrGr szUpSampling3D.get_config)rN) r\rrrr(rkrprrrFrF)rErGr^ s *rzkeras.layers.ZeroPadding1Dcs>eZdZdZd fdd ZddZddZfd d ZZS) ZeroPadding1Da=Zero-padding layer for 1D input (e.g. temporal sequence). Examples: >>> input_shape = (2, 2, 3) >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) >>> print(x) [[[ 0 1 2] [ 3 4 5]] [[ 6 7 8] [ 9 10 11]]] >>> y = tf.keras.layers.ZeroPadding1D(padding=2)(x) >>> print(y) tf.Tensor( [[[ 0 0 0] [ 0 0 0] [ 0 1 2] [ 3 4 5] [ 0 0 0] [ 0 0 0]] [[ 0 0 0] [ 0 0 0] [ 6 7 8] [ 9 10 11] [ 0 0 0] [ 0 0 0]]], shape=(2, 6, 3), dtype=int64) Args: padding: Int, or tuple of int (length 2), or dictionary. - If int: How many zeros to add at the beginning and end of the padding dimension (axis 1). - If tuple of int (length 2): How many zeros to add at the beginning and the end of the padding dimension (`(left_pad, right_pad)`). Input shape: 3D tensor with shape `(batch_size, axis_to_pad, features)` Output shape: 3D tensor with shape `(batch_size, padded_axis, features)` rc s2tt|jf|t|dd|_tdd|_dS)Nr#r2r)r)r'rr(rr1r2r r=)rCr2rD)rErFrGr( szZeroPadding1D.__init__cCsF|ddk r*|d|jd|jd}nd}t|d||dgS)Nrrr#)r2rrU)rCrarvrFrFrGrk s z"ZeroPadding1D.compute_output_shapecCstj||jdS)N)r2)rZtemporal_paddingr2)rCrmrFrFrGrp szZeroPadding1D.callcs4d|ji}tt|}tt|t|S)Nr2)r2r'rrrr[r)rCrr)rErFrGr s zZeroPadding1D.get_config)r) r\rrrr(rkrprrrFrF)rErGr s +rzkeras.layers.ZeroPadding2Dcs>eZdZdZd fdd ZddZdd Zfd d ZZS) ZeroPadding2DaZero-padding layer for 2D input (e.g. picture). This layer can add rows and columns of zeros at the top, bottom, left and right side of an image tensor. Examples: >>> input_shape = (1, 1, 2, 2) >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) >>> print(x) [[[[0 1] [2 3]]]] >>> y = tf.keras.layers.ZeroPadding2D(padding=1)(x) >>> print(y) tf.Tensor( [[[[0 0] [0 0] [0 0] [0 0]] [[0 0] [0 1] [2 3] [0 0]] [[0 0] [0 0] [0 0] [0 0]]]], shape=(1, 3, 4, 2), dtype=int64) Args: padding: Int, or tuple of 2 ints, or tuple of 2 tuples of 2 ints. - If int: the same symmetric padding is applied to height and width. - If tuple of 2 ints: interpreted as two different symmetric padding values for height and width: `(symmetric_height_pad, symmetric_width_pad)`. - If tuple of 2 tuples of 2 ints: interpreted as `((top_pad, bottom_pad), (left_pad, right_pad))` 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_size, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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: 4D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, rows, cols, channels)` - If `data_format` is `"channels_first"`: `(batch_size, channels, rows, cols)` Output shape: 4D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, padded_rows, padded_cols, channels)` - If `data_format` is `"channels_first"`: `(batch_size, channels, padded_rows, padded_cols)` rrNc stt|jf|t||_t|tr<||f||ff|_nft |drt |dkrbt dt |t |ddd}t |ddd}||f|_nt dt |td d |_dS) N__len__r#z+`padding` should have two elements. Found: rz1st entry of paddingrz2nd entry of paddingz`padding` should be either an int, a tuple of 2 ints (symmetric_height_pad, symmetric_width_pad), or a tuple of 2 tuples of 2 ints ((top_pad, bottom_pad), (left_pad, right_pad)). Found: r)r)r'rr(rr3r4r+r-r2hasattrr}r.rYr1r r=)rCr2r4rDZheight_padding width_padding)rErFrGr(4 s          zZeroPadding2D.__init__cCs6t|}|jdkr|ddk rJ|d|jdd|jdd}nd}|ddk r|d|jdd|jdd}nd}t|d|d||gS|jdkr2|ddk r|d|jdd|jdd}nd}|ddk r|d|jdd|jdd}nd}t|d|||dgSdS)Nr&r#rrrrz)rrUr|r4r2)rCrarrrFrFrGrkK s&  & &  &&z"ZeroPadding2D.compute_output_shapecCstj||j|jdS)N)r2r4)rZspatial_2d_paddingr2r4)rCrmrFrFrGrpd szZeroPadding2D.callcs8|j|jd}tt|}tt|t|S)N)r2r4)r2r4r'rrrr[r)rCrr)rErFrGrh szZeroPadding2D.get_config)rN) r\rrrr(rkrprrrFrF)rErGr s Arzkeras.layers.ZeroPadding3Dcs>eZdZdZd fdd ZddZdd Zfd d ZZS) ZeroPadding3DaZero-padding layer for 3D data (spatial or spatio-temporal). Examples: >>> input_shape = (1, 1, 2, 2, 3) >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) >>> y = tf.keras.layers.ZeroPadding3D(padding=2)(x) >>> print(y.shape) (1, 5, 6, 6, 3) Args: padding: Int, or tuple of 3 ints, or tuple of 3 tuples of 2 ints. - If int: the same symmetric padding is applied to height and width. - If tuple of 3 ints: interpreted as two different symmetric padding values for height and width: `(symmetric_dim1_pad, symmetric_dim2_pad, symmetric_dim3_pad)`. - If tuple of 3 tuples of 2 ints: interpreted as `((left_dim1_pad, right_dim1_pad), (left_dim2_pad, right_dim2_pad), (left_dim3_pad, right_dim3_pad))` 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_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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: 5D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, first_axis_to_pad, second_axis_to_pad, third_axis_to_pad, depth)` - If `data_format` is `"channels_first"`: `(batch_size, depth, first_axis_to_pad, second_axis_to_pad, third_axis_to_pad)` Output shape: 5D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, first_padded_axis, second_padded_axis, third_axis_to_pad, depth)` - If `data_format` is `"channels_first"`: `(batch_size, depth, first_padded_axis, second_padded_axis, third_axis_to_pad)` rrrNc stt|jf|t||_t|trB||f||f||ff|_nzt |drt |dkrht dt |t |ddd}t |ddd}t |ddd }|||f|_nt d t |td d |_dS) Nrrz)`padding` should have 3 elements. Found: rr#z1st entry of paddingrz2nd entry of paddingz3rd entry of paddinga`padding` should be either an int, a tuple of 3 ints (symmetric_dim1_pad, symmetric_dim2_pad, symmetric_dim3_pad), or a tuple of 3 tuples of 2 ints ((left_dim1_pad, right_dim1_pad), (left_dim2_pad, right_dim2_pad), (left_dim3_pad, right_dim2_pad)). Found: r)r)r'rr(rr3r4r+r-r2rr}r.rYr1r r=)rCr2r4rDZ dim1_paddingZ dim2_paddingZ dim3_padding)rErFrGr( s(          zZeroPadding3D.__init__cCst|}|jdkr|ddk rJ|d|jdd|jdd}nd}|ddk r|d|jdd|jdd}nd}|ddk r|d|jdd|jdd}nd}t|d|d|||gS|jdkr|ddk r|d|jdd|jdd}nd}|ddk rN|d|jdd|jdd}nd}|ddk r|d|jdd|jdd}nd}t|d||||dgSdS)Nr&r#rrrrrz)rrUr|r4r2)rCrarrrrFrFrGrk s2  & & & &&&z"ZeroPadding3D.compute_output_shapecCstj||j|jdS)N)r2r4)rZspatial_3d_paddingr2r4)rCrmrFrFrGrp szZeroPadding3D.callcs8|j|jd}tt|}tt|t|S)N)r2r4)r2r4r'rrrr[r)rCrr)rErFrGr szZeroPadding3D.get_config)rN) r\rrrr(rkrprrrFrF)rErGrn s 4!rzkeras.layers.Cropping1Dcs>eZdZdZd fdd ZddZddZfd d ZZS) Cropping1DaDCropping layer for 1D input (e.g. temporal sequence). It crops along the time dimension (axis 1). Examples: >>> input_shape = (2, 3, 2) >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) >>> print(x) [[[ 0 1] [ 2 3] [ 4 5]] [[ 6 7] [ 8 9] [10 11]]] >>> y = tf.keras.layers.Cropping1D(cropping=1)(x) >>> print(y) tf.Tensor( [[[2 3]] [[8 9]]], shape=(2, 1, 2), dtype=int64) Args: cropping: Int or tuple of int (length 2) How many units should be trimmed off at the beginning and end of the cropping dimension (axis 1). If a single int is provided, the same value will be used for both. Input shape: 3D tensor with shape `(batch_size, axis_to_crop, features)` Output shape: 3D tensor with shape `(batch_size, cropped_axis, features)` rrc s2tt|jf|t|dd|_tdd|_dS)Nr#croppingr)r)r'rr(rr1rr r=)rCrrD)rErFrGr( szCropping1D.__init__cCsTt|}|ddk r8|d|jd|jd}nd}t|d||dgS)Nrrr#)rrUr|r)rCrarvrFrFrGrk s  zCropping1D.compute_output_shapecCsZ|jddkr.|dd|jddddfS|dd|jd|jd ddfSdS)Nrr)r)rCrmrFrFrGrp s zCropping1D.callcs4d|ji}tt|}tt|t|S)Nr)rr'rrrr[r)rCrr)rErFrGr# s zCropping1D.get_config)r) r\rrrr(rkrprrrFrF)rErGr s "rzkeras.layers.Cropping2Dcs>eZdZdZd fdd ZddZdd Zfd d ZZS) Cropping2DaCropping layer for 2D input (e.g. picture). It crops along spatial dimensions, i.e. height and width. Examples: >>> input_shape = (2, 28, 28, 3) >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) >>> y = tf.keras.layers.Cropping2D(cropping=((2, 2), (4, 4)))(x) >>> print(y.shape) (2, 24, 20, 3) Args: cropping: Int, or tuple of 2 ints, or tuple of 2 tuples of 2 ints. - If int: the same symmetric cropping is applied to height and width. - If tuple of 2 ints: interpreted as two different symmetric cropping values for height and width: `(symmetric_height_crop, symmetric_width_crop)`. - If tuple of 2 tuples of 2 ints: interpreted as `((top_crop, bottom_crop), (left_crop, right_crop))` 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_size, height, width, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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: 4D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, rows, cols, channels)` - If `data_format` is `"channels_first"`: `(batch_size, channels, rows, cols)` Output shape: 4D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, cropped_rows, cropped_cols, channels)` - If `data_format` is `"channels_first"`: `(batch_size, channels, cropped_rows, cropped_cols)` )rr)rrNc stt|jf|t||_t|tr<||f||ff|_nft |drt |dkrbt dt |t |ddd}t |ddd}||f|_nt dt |td d |_dS) Nrr#z,`cropping` should have two elements. Found: rz1st entry of croppingrz2nd entry of croppingz`cropping` should be either an int, a tuple of 2 ints (symmetric_height_crop, symmetric_width_crop), or a tuple of 2 tuples of 2 ints ((top_crop, bottom_crop), (left_crop, right_crop)). Found: r)r)r'rr(rr3r4r+r-rrr}r.rYr1r r=)rCrr4rDZheight_croppingZwidth_cropping)rErFrGr(\ s          zCropping2D.__init__cCst|}|jdkrt|d|d|drT|d|jdd|jddnd|dr|d|jdd|jddndgSt|d|dr|d|jdd|jddnd|dr|d|jdd|jddnd|dgSdS)Nr&rrr#r)rrUr|r4r)rCrarFrFrGrks s  .4.zCropping2D.compute_output_shapecCs|jdkr^|jdd|jddkr4dkrlnn4|dddd|jddd|jdddfS|jdddkr|dddd|jddd|jdd|jdd fS|jdddkr|dddd|jdd|jdd |jdddfS|dddd|jdd|jdd |jdd|jdd fS|jdd|jddkrdkrnn4|dd|jddd|jdddddfS|jdddkr|dd|jddd|jdd|jdd ddfS|jdddkrj|dd|jdd|jdd |jdddddfS|dd|jdd|jdd |jdd|jdd ddfSdS)Nr&rr)r4r)rCrmrFrFrGrp s* ,4***"04$$(zCropping2D.callcs8|j|jd}tt|}tt|t|S)N)rr4)rr4r'rrrr[r)rCrr)rErFrGr szCropping2D.get_config)rN) r\rrrr(rkrprrrFrF)rErGr) s 1rzkeras.layers.Cropping3Dcs>eZdZdZd fdd ZddZdd Zfd d ZZS) Cropping3DaCropping layer for 3D data (e.g. spatial or spatio-temporal). Examples: >>> input_shape = (2, 28, 28, 10, 3) >>> x = np.arange(np.prod(input_shape)).reshape(input_shape) >>> y = tf.keras.layers.Cropping3D(cropping=(2, 4, 2))(x) >>> print(y.shape) (2, 24, 20, 6, 3) Args: cropping: Int, or tuple of 3 ints, or tuple of 3 tuples of 2 ints. - If int: the same symmetric cropping is applied to depth, height, and width. - If tuple of 3 ints: interpreted as two different symmetric cropping values for depth, height, and width: `(symmetric_dim1_crop, symmetric_dim2_crop, symmetric_dim3_crop)`. - If tuple of 3 tuples of 2 ints: interpreted as `((left_dim1_crop, right_dim1_crop), (left_dim2_crop, right_dim2_crop), (left_dim3_crop, right_dim3_crop))` 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_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)` while `channels_first` corresponds to inputs with shape `(batch_size, 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: 5D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, first_axis_to_crop, second_axis_to_crop, third_axis_to_crop, depth)` - If `data_format` is `"channels_first"`: `(batch_size, depth, first_axis_to_crop, second_axis_to_crop, third_axis_to_crop)` Output shape: 5D tensor with shape: - If `data_format` is `"channels_last"`: `(batch_size, first_cropped_axis, second_cropped_axis, third_cropped_axis, depth)` - If `data_format` is `"channels_first"`: `(batch_size, depth, first_cropped_axis, second_cropped_axis, third_cropped_axis)` )rr)rr)rrNc stt|jf|t||_t|trB||f||f||ff|_nzt |drt |dkrht dt |t |ddd}t |ddd}t |ddd }|||f|_nt d t |td d |_dS) Nrrz*`cropping` should have 3 elements. Found: rr#z1st entry of croppingrz2nd entry of croppingz3rd entry of croppinga `cropping` should be either an int, a tuple of 3 ints (symmetric_dim1_crop, symmetric_dim2_crop, symmetric_dim3_crop), or a tuple of 3 tuples of 2 ints ((left_dim1_crop, right_dim1_crop), (left_dim2_crop, right_dim2_crop), (left_dim3_crop, right_dim2_crop)). Found: r)r)r'rr(rr3r4r+r-rrr}r.rYr1r r=)rCrr4rDZ dim1_croppingZ dim2_croppingZ dim3_cropping)rErFrGr( s(          zCropping3D.__init__cCst|}|jdkr|ddk rJ|d|jdd|jdd}nd}|ddk r|d|jdd|jdd}nd}|ddk r|d|jdd|jdd}nd}t|d|d|||gS|jdkr|ddk r|d|jdd|jdd}nd}|ddk rN|d|jdd|jdd}nd}|ddk r|d|jdd|jdd}nd}t|d||||dgSdS)Nr&r#rrrrrz)rrUr|r4r)rCrarrrrFrFrGrk s2  & & & &&&zCropping3D.compute_output_shapecCs|jdkr|jdd|jddkrH|jddkrHdkrnnD|dddd|jddd|jddd|jdddfS|jdd|jddkrdkrnnP|dddd|jddd|jddd|jdd|jdd fS|jdd|jddkr:dkrnnP|dddd|jdd|jdd |jddd|jdddfS|jdd|jddkrdkrnnP|dddd|jddd|jdd|jdd |jdddfS|jdddkr~|dddd|jddd|jdd|jdd |jdd|jdd fS|jdddkr|dddd|jdd|jdd |jddd|jdd|jdd fS|jdddkr^|dddd|jdd|jdd |jdd|jdd |jdddfS|dddd|jdd|jdd |jdd|jdd |jdd|jdd fS|jdd|jddkr|jddkrdkrPnnD|dd|jddd|jddd|jdddddfS|jdd|jddkr|dkrnnP|dd|jddd|jddd|jdd|jdd ddfS|jdd|jddkrdkrPnnP|dd|jdd|jdd |jddd|jdddddfS|jdd|jddkr|dkrnnP|dd|jddd|jdd|jdd |jdddddfS|jdddkr@|dd|jddd|jdd|jdd |jdd|jdd ddfS|jdddkr|dd|jdd|jdd |jddd|jdd|jdd ddfS|jdddkr |dd|jdd|jdd |jdd|jdd |jdddddfS|dd|jdd|jdd |jdd|jdd |jdd|jdd ddfSdS)Nr&rrr#)r4r)rCrmrFrFrGrp sh @..."0*&0*&&6....*$F(0((0$,0$,  0$ ($zCropping3D.callcs8|j|jd}tt|}tt|t|S)N)rr4)rr4r'rrrr[r)rCrr)rErFrGrX szCropping3D.get_config)rN) r\rrrr(rkrprrrFrF)rErGr s 2#9r)?rr]Ztensorflow.python.eagerrZtensorflow.python.frameworkrZtensorflow.python.kerasrrrrrZ)tensorflow.python.keras.engine.base_layerr Z)tensorflow.python.keras.engine.input_specr Z&tensorflow.python.keras.layers.poolingr r r rrrZtensorflow.python.keras.utilsrrZtensorflow.python.opsrrrZ tensorflow.python.util.tf_exportrrrJrrrrrrrKrrrrrrrrrrrZ Convolution1DZ Convolution2DZ Convolution3DZSeparableConvolution1DZSeparableConvolution2DZConvolution2DTransposeZConvolution3DTransposeZDeconvolution2DZDeconv2DZDeconvolution3DZDeconv3DrFrFrFrGs                     U  v/9T4-g8gPA|}<~8