ó ¾÷Xc@`s.ddlmZddlmZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddl mZddl mZdd l mZdd lmZdd lmZdd lmZdd lmZddlmZddlmZdefd„ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZdefd„ƒYZ defd„ƒYZ!d efd!„ƒYZ"d"efd#„ƒYZ#d$efd%„ƒYZ$d&efd'„ƒYZ%d(efd)„ƒYZ&dS(*i(tabsolute_import(tdivisionNi(tbackend(t activations(t initializers(t regularizers(t constraints(t InputSpec(tLayer(t func_dump(t func_load(tdeserialize_keras_object(t interfacestMaskingcB`s8eZdZdd„Zdd„Zd„Zd„ZRS(sÁMasks a sequence by using a mask value to skip timesteps. For each timestep in the input tensor (dimension #1 in the tensor), if all values in the input tensor at that timestep are equal to `mask_value`, then the timestep will be masked (skipped) in all downstream layers (as long as they support masking). If any downstream layer does not support masking yet receives such an input mask, an exception will be raised. # Example Consider a Numpy data array `x` of shape `(samples, timesteps, features)`, to be fed to a LSTM layer. You want to mask timestep #3 and #5 because you lack data for these timesteps. You can: - set `x[:, 3, :] = 0.` and `x[:, 5, :] = 0.` - insert a `Masking` layer with `mask_value=0.` before the LSTM layer: ```python model = Sequential() model.add(Masking(mask_value=0., input_shape=(timesteps, features))) model.add(LSTM(32)) ``` gcK`s,tt|ƒj|t|_||_dS(N(tsuperR t__init__tTruetsupports_maskingt mask_value(tselfRtkwargs((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR5s cC`s"tjtj||jƒddƒS(Ntaxisiÿÿÿÿ(tKtanyt not_equalR(Rtinputstmask((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyt compute_mask:scC`sDtjtj||jƒdddtƒ}|tj|tjƒƒS(NRiÿÿÿÿtkeepdims(RRRRRtcasttfloatx(RRt boolean_mask((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pytcall=scC`sKi|jd6}tt|ƒjƒ}tt|jƒƒt|jƒƒƒS(NR(RRR t get_configtdicttlisttitems(Rtconfigt base_config((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR!BsN(t__name__t __module__t__doc__RtNoneRR R!(((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR s    tDropoutcB`sDeZdZejddd„ƒZd„Zdd„Zd„Z RS(sjApplies Dropout to the input. Dropout consists in randomly setting a fraction `p` of input units to 0 at each update during training time, which helps prevent overfitting. # Arguments rate: float between 0 and 1. Fraction of the input units to drop. noise_shape: 1D integer tensor representing the shape of the binary dropout mask that will be multiplied with the input. For instance, if your inputs have shape `(batch_size, timesteps, features)` and you want the dropout mask to be the same for all timesteps, you can use `noise_shape=(batch_size, 1, features)`. seed: A Python integer to use as random seed. # References - [Dropout: A Simple Way to Prevent Neural Networks from Overfitting](http://www.cs.toronto.edu/~rsalakhu/papers/srivastava14a.pdf) cK`sPtt|ƒj|tdtd|ƒƒ|_||_||_t|_ dS(Ngð?g( RR+Rtmintmaxtratet noise_shapetseedRR(RR.R/R0R((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR\s   cC`s|jS(N(R/(Rt_((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyt_get_noise_shapedsc`s]dˆjkodknrYˆjˆƒ‰‡‡‡fd†}tj|ˆd|ƒSˆS(Nggð?c`stjˆˆjˆdˆjƒS(NR0(RtdropoutR.R0((RR/R(s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pytdropped_inputsksttraining(R.R2Rtin_train_phase(RRR5R4((RR/Rs0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR gs cC`sKi|jd6}tt|ƒjƒ}tt|jƒƒt|jƒƒƒS(NR.(R.RR+R!R"R#R$(RR%R&((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR!rsN( R'R(R)R tlegacy_dropout_supportR*RR2R R!(((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR+Hs   tSpatialDropout1DcB`s)eZdZejd„ƒZd„ZRS(svSpatial 1D version of Dropout. This version performs the same function as Dropout, however it drops entire 1D feature maps instead of individual elements. If adjacent frames within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease. In this case, SpatialDropout1D will help promote independence between feature maps and should be used instead. # Arguments p: float between 0 and 1. Fraction of the input units to drop. # Input shape 3D tensor with shape: `(samples, timesteps, channels)` # Output shape Same as input # References - [Efficient Object Localization Using Convolutional Networks](https://arxiv.org/abs/1411.4280) cK`s/tt|ƒj||tddƒ|_dS(Ntndimi(RR8RRt input_spec(RR.R((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR‘scC`s*tj|ƒ}|dd|df}|S(Niii(Rtshape(RRt input_shapeR/((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR2–s(R'R(R)R tlegacy_spatialdropout1d_supportRR2(((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR8xstSpatialDropout2DcB`s,eZdZejdd„ƒZd„ZRS(sšSpatial 2D version of Dropout. This version performs the same function as Dropout, however it drops entire 2D feature maps instead of individual elements. If adjacent pixels within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease. In this case, SpatialDropout2D will help promote independence between feature maps and should be used instead. # Arguments rate: float between 0 and 1. Fraction of the input units to drop. data_format: 'channels_first' or 'channels_last'. In 'channels_first' mode, the channels dimension (the depth) is at index 1, in 'channels_last' mode is it at index 3. 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: `(samples, channels, rows, cols)` if data_format='channels_first' or 4D tensor with shape: `(samples, rows, cols, channels)` if data_format='channels_last'. # Output shape Same as input # References - [Efficient Object Localization Using Convolutional Networks](https://arxiv.org/abs/1411.4280) cK`sttt|ƒj|||dkr4tjƒ}n|ddhkrUtdƒ‚n||_tddƒ|_ dS(Nt channels_lasttchannels_firsts:data_format must be in {"channels_last", "channels_first"}R9i( RR>RR*Rtimage_data_formatt ValueErrort data_formatRR:(RR.RCR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR¾s  cC`s}tj|ƒ}|jdkr;|d|dddf}n>|jdkrg|ddd|df}ntd|jƒ‚|S(NR@iiR?isInvalid data_format:(RR;RCRB(RRR<R/((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR2ÉsN(R'R(R)R tlegacy_spatialdropoutNd_supportR*RR2(((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR>œs  tSpatialDropout3DcB`s,eZdZejdd„ƒZd„ZRS(sšSpatial 3D version of Dropout. This version performs the same function as Dropout, however it drops entire 3D feature maps instead of individual elements. If adjacent voxels within feature maps are strongly correlated (as is normally the case in early convolution layers) then regular dropout will not regularize the activations and will otherwise just result in an effective learning rate decrease. In this case, SpatialDropout3D will help promote independence between feature maps and should be used instead. # Arguments rate: float between 0 and 1. Fraction of the input units to drop. data_format: 'channels_first' or 'channels_last'. In 'channels_first' mode, the channels dimension (the depth) is at index 1, in 'channels_last' mode is it at index 4. 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: `(samples, channels, dim1, dim2, dim3)` if data_format='channels_first' or 5D tensor with shape: `(samples, dim1, dim2, dim3, channels)` if data_format='channels_last'. # Output shape Same as input # References - [Efficient Object Localization Using Convolutional Networks](https://arxiv.org/abs/1411.4280) cK`sttt|ƒj|||dkr4tjƒ}n|ddhkrUtdƒ‚n||_tddƒ|_ dS(NR?R@s:data_format must be in {"channels_last", "channels_first"}R9i( RRERR*RRARBRCRR:(RR.RCR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRõs  cC`sƒtj|ƒ}|jdkr>|d|ddddf}nA|jdkrm|dddd|df}ntd|jƒ‚|S(NR@iiR?isInvalid data_format:(RR;RCRB(RRR<R/((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR2s  N(R'R(R)R RDR*RR2(((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyREÔs t ActivationcB`s)eZdZd„Zd„Zd„ZRS(sèApplies an activation function to an output. # Arguments activation: name of activation function to use (see: [activations](../activations.md)), or alternatively, a Theano or TensorFlow operation. # Input shape Arbitrary. Use the keyword argument `input_shape` (tuple of integers, does not include the samples axis) when using this layer as the first layer in a model. # Output shape Same shape as input. cK`s5tt|ƒj|t|_tj|ƒ|_dS(N(RRFRRRRtgett activation(RRHR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRs cC`s |j|ƒS(N(RH(RR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR !scC`sTitj|jƒd6}tt|ƒjƒ}tt|jƒƒt|jƒƒƒS(NRH( Rt serializeRHRRFR!R"R#R$(RR%R&((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR!$s(R'R(R)RR R!(((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRF s  tReshapecB`s;eZdZd„Zd„Zd„Zd„Zd„ZRS(s,Reshapes an output to a certain shape. # Arguments target_shape: target shape. Tuple of integers, does not include the samples dimension (batch size). # Input shape Arbitrary, although all dimensions in the input shaped must be fixed. Use the keyword argument `input_shape` (tuple of integers, does not include the samples axis) when using this layer as the first layer in a model. # Output shape `(batch_size,) + target_shape` # Example ```python # as first layer in a Sequential model model = Sequential() model.add(Reshape((3, 4), input_shape=(12,))) # now: model.output_shape == (None, 3, 4) # note: `None` is the batch dimension # as intermediate layer in a Sequential model model.add(Reshape((6, 2))) # now: model.output_shape == (None, 6, 2) # also supports shape inference using `-1` as dimension model.add(Reshape((-1, 2, 2))) # now: model.output_shape == (None, 3, 2, 2) ``` cK`s)tt|ƒj|t|ƒ|_dS(N(RRJRttuplet target_shape(RRLR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRMsc C`s÷t|ƒ}d}d\}}xTt|ƒD]F\}}|dkrg|dkrX|}qqtdƒ‚q+||9}q+Wtj|dtƒ}|dk rÒ|dks²||dkrÁt|ƒ‚n||||The shape of the input to "Flatten" is not fully defined (got sn. Make sure to pass a complete "input_shape" or "batch_input_shape" argument to the first layer in your model.i(tallRBtstrRORP(RR<((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRZäscC`s tj|ƒS(N(Rt batch_flatten(RR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR îs(R'R(R)RRZR (((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyReÏs  t RepeatVectorcB`s2eZdZd„Zd„Zd„Zd„ZRS(sRepeats the input n times. # Example ```python model = Sequential() model.add(Dense(32, input_dim=32)) # now: model.output_shape == (None, 32) # note: `None` is the batch dimension model.add(RepeatVector(3)) # now: model.output_shape == (None, 3, 32) ``` # Arguments n: integer, repetition factor. # Input shape 2D tensor of shape `(num_samples, features)`. # Output shape 3D tensor of shape `(num_samples, n, features)`. cK`s5tt|ƒj|||_tddƒ|_dS(NR9i(RRjRtnRR:(RRkR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR s cC`s|d|j|dfS(Nii(Rk(RR<((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRZscC`stj||jƒS(N(RtrepeatRk(RR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR scC`sKi|jd6}tt|ƒjƒ}tt|jƒƒt|jƒƒƒS(NRk(RkRRjR!R"R#R$(RR%R&((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyR!s(R'R(R)RRZR R!(((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRjòs    tLambdacB`seeZdZejdddd„ƒZd„Zdd„Zdd„Z d„Z e dd„ƒZ RS(sWraps arbitrary expression as a `Layer` object. # Examples ```python # add a x -> x^2 layer model.add(Lambda(lambda x: x ** 2)) ``` ```python # add a layer that returns the concatenation # of the positive part of the input and # the opposite of the negative part def antirectifier(x): x -= K.mean(x, axis=1, keepdims=True) x = K.l2_normalize(x, axis=1) pos = K.relu(x) neg = K.relu(-x) return K.concatenate([pos, neg], axis=1) def antirectifier_output_shape(input_shape): shape = list(input_shape) assert len(shape) == 2 # only valid for 2D tensors shape[-1] *= 2 return tuple(shape) model.add(Lambda(antirectifier, output_shape=antirectifier_output_shape)) ``` # Arguments function: The function to be evaluated. Takes input tensor as first argument. output_shape: Expected output shape from function. Only relevant when using Theano. Can be a tuple or function. If a tuple, it only specifies the first dimension onward; sample dimension is assumed either the same as the input: `output_shape = (input_shape[0], ) + output_shape` or, the input is `None` and the sample dimension is also `None`: `output_shape = (None, ) + output_shape` If a function, it specifies the entire shape as a function of the input shape: `output_shape = f(input_shape)` arguments: optional dictionary of keyword arguments to be passed to the function. # Input shape Arbitrary. Use the keyword argument input_shape (tuple of integers, does not include the samples axis) when using this layer as the first layer in a model. # Output shape Specified by `output_shape` argument (or auto-inferred when using TensorFlow). cK`s¼tt|ƒj|||_|r+|ni|_|dk rLt|_n||_|dkrmd|_ nKt |t t fƒr”t |ƒ|_ n$t |ƒs¯tdƒ‚n||_ dS(NsAIn Lambda, `output_shape` must be a list, a tuple, or a function.(RRmRtfunctiont argumentsR*RRRt _output_shapet isinstanceRKR#tcallableR\(RRnRRRRoR((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRVs       cC`sŠ|jdkrçtjƒdkrÇt|tƒrgg|D]}tjd|ƒ^q7}|j|ƒ}n!tjd|ƒ}|j|ƒ}t|tƒr·g|D]}tj|ƒ^qžStj|ƒSnt j dj |j |ƒƒ|St|jt tfƒrIt|tƒr|dd}n|r/|dnd}|ft |jƒS|j|ƒ}t|tt fƒs|tdƒ‚nt |ƒSdS(Nt tensorflowR;sþ`output_shape` argument not specified for layer {} and cannot be automatically inferred with the Theano backend. Defaulting to output shape `{}` (same as input shape). If the expected output shape is different, specify it via the `output_shape` argument.is)output_shape function must return a tuple(RpR*RRRqR#t placeholderR R[twarningstwarntformattnameRKRB(RR<R;txstxtx_elemt num_samples((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyRZjs,%  cC`sG|j}tj|jƒ}d|jkr7||dRERFRJR^ReRjRmRR«(((s0/tmp/pip-build-isqEY4/keras/keras/layers/core.pyts<     /0$87q4#*¼