Xc@sddlZddlmZddlmZddlmZddlmZddlmZ ddl m Z ddl Z ddlZddlZdd lmZdd lmZdd lmZdd lmZmZeZeZdaiaiaead dZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*dZ+ej,Z,dddZ-dZ.ddddZ/dddeddZ0dZ1dZ2d Z3d!Z4d"Z5ddd#Z6ddd$Z7ddd%Z8ddd&Z9ddd'Z:dddd(Z;dddd)Z<d*Z=d+Z>d,Z?d-Z@d.ZAd/ZBd0ZCdd1ZDd2ZEd3ZFd4ZGded5ZHded6ZIded7Zded8ZJded9ZKded:ZLded;ZMded<ZNded=Zdd>ZOdd?ZPd@ZQdAZRdBZSdCZTdDZUdEZVdFZWdGZXdHZYdIZZdJZ[dKZ\dLZ]dMZ^dNZ_dOZ`dPZadQZbdRZcdSdTZddSdUZeddVZfdWZgdXZhdYZidZZjd[Zkd\Zlddd]d^Zmd_Znd`ZodaZpddbZqdcZrdddZsddfddeZtdddfddfZudgdhZvdiZwdjZxdkZydlZzdmZ{dnZ|doZ}d dpZ~dqefdrYZddsZdtZduZeddeddvZdwZddxZddyZdzdd{Zd|d}Zd~ZdZdZedZedZedZdZdZdZdddZdZdZdZdZdZdZdZdZdZdZdddddZdddddZddddZdddddZdddddZdddddZdddddZddZdzd|dddZdzd|dddZdzdddZdzd|dddZdZdZedddZddZdddZdddZdS(iN(tmoving_averages(ttensor_array_ops(tcontrol_flow_ops(tfunctional_ops(tctc_ops(t defaultdicti(tfloatx(t_EPSILON(timage_data_format(tset_image_dim_orderingtimage_dim_orderingtcCsKtj}|tkr+ttt|>> from keras import backend as K >>> a = K.placeholder((2, 2), sparse=False) >>> print(K.is_sparse(a)) False >>> b = K.placeholder((2, 2), sparse=True) >>> print(K.is_sparse(b)) True ``` (t isinstanceR t SparseTensor(ttensor((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt is_sparsescCs!t|rtj|S|SdS(sConverts a sparse tensor into a dense tensor and returns it. # Arguments tensor: A tensor instance (potentially sparse). # Returns A dense tensor. # Examples ```python >>> from keras import backend as K >>> b = K.placeholder((2, 2), sparse=True) >>> print(K.is_sparse(b)) True >>> c = K.to_dense(b) >>> print(K.is_sparse(c)) False ``` N(RFR tsparse_tensor_to_dense(RE((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytto_denses  cCs%|d krt}nt|dr|j}tjtj|jdtj|jdfd}t j d|d|j d|j }|j |_ t|_|St j|dt|d|}t|tjr|j |_ n0t|drttt|j|_ nt|_|S( sInstantiates a variable and returns it. # Arguments value: Numpy array, initial value of the tensor. dtype: Tensor type. name: Optional name string for the tensor. # Returns A variable instance (with Keras metadata included). # Examples ```python >>> from keras import backend as K >>> val = np.array([[1, 2], [3, 4]]) >>> kvar = K.variable(value=val, dtype='float64', name='example_var') >>> K.dtype(kvar) 'float64' >>> print(kvar) example_var >>> kvar.eval() array([[ 1., 2.], [ 3., 4.]]) ``` ttocooitindicestvaluest dense_shapeRRt get_shapeN(RRthasattrRItnpt concatenatet expand_dimstrowtcolR RDtdatatshapet _keras_shapetFalset_uses_learning_phasetVariableR>RCtndarrayttupletmapRRM(R RRt sparse_cooRJtv((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytvariables&       !! cCstj}g}xA|D]9}t|d s9|j r|j|t|_qqW|r~t}|jtj|ndS(s>Utility to initialize uninitialized variables on the fly. t_keras_initializedN( R tglobal_variablesRNR`tappendR.R3truntvariables_initializer(t variablestuninitialized_variablesR^tsess((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR0's    cCs7|dkrt}ntj|d|d|d|S(NRRUR(RRR tconstant(R RRUR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRh5s  cCs|dkrt}n|sO|rOtgt|D] }d^q4}qOn|rstj|d|d|}ntj|d|d|}||_t|_ |S(sIInstantiates a placeholder tensor and returns it. # Arguments shape: Shape of the placeholder (integer tuple, may include `None` entries). ndim: Number of axes of the tensor. At least one of {`shape`, `ndim`} must be specified. If both are specified, `shape` is used. dtype: Placeholder type. sparse: Boolean, whether the placeholder should have a sparse type. name: Optional name string for the placeholder. # Returns Tensor instance (with Keras metadata included). # Examples ```python >>> from keras import backend as K >>> input_ph = K.placeholder(shape=(2, 4, 5)) >>> input_ph._keras_shape (2, 4, 5) >>> input_ph ``` RURN( RRR[trangeR tsparse_placeholderRRVRWRX(RUtndimRtsparseRt_RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR;s  +  cCs tj|S(slReturns the symbolic shape of a tensor or variable. # Arguments x: A tensor or variable. # Returns A symbolic shape (which is itself a tensor). # Examples ``` # TensorFlow example >>> from keras import backend as K >>> tf_session = K.get_session() >>> val = np.array([[1, 2], [3, 4]]) >>> kvar = K.variable(value=val) >>> input = keras.backend.placeholder(shape=(2, 4, 5)) >>> K.shape(kvar) >>> K.shape(input) # To get integer shape (Instead, you can use K.int_shape(x)) >>> K.shape(kvar).eval(session=tf_session) array([2, 2], dtype=int32) >>> K.shape(input).eval(session=tf_session) array([2, 4, 5], dtype=int32) ``` (R RU(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRUcscCsbt|dr|jS|j}y'tg|D]}|j^q/SWntk r]dSXdS(sReturns the shape tensor or variable as a tuple of int or None entries. # Arguments x: Tensor or variable. # Returns A tuple of integers (or None entries). # Examples ```python >>> from keras import backend as K >>> input = K.placeholder(shape=(2, 4, 5)) >>> K.int_shape(input) (2, 4, 5) >>> val = np.array([[1, 2], [3, 4]]) >>> kvar = K.variable(value=val) >>> K.int_shape(kvar) (2, 2) ``` RVN(RNRVRMR[t__int__R#R(RARUti((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt int_shapes ' cCs)|jj}|dk r%t|SdS(sReturns the number of axes in a tensor, as an integer. # Arguments x: Tensor or variable. # Returns Integer (scalar), number of axes. # Examples ```python >>> from keras import backend as K >>> input = K.placeholder(shape=(2, 4, 5)) >>> val = np.array([[1, 2], [3, 4]]) >>> kvar = K.variable(value=val) >>> K.ndim(input) 3 >>> K.ndim(kvar) 2 ``` N(RMt_dimsRtlen(RAtdims((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRks  cCs |jjS(sReturns the dtype of a Keras tensor or variable, as a string. # Arguments x: Tensor or variable. # Returns String, dtype of `x`. # Examples ```python >>> from keras import backend as K >>> K.dtype(K.placeholder(shape=(2,4,5))) 'float32' >>> K.dtype(K.placeholder(shape=(2,4,5), dtype='float32')) 'float32' >>> K.dtype(K.placeholder(shape=(2,4,5), dtype='float64')) 'float64' # Keras variable >>> kvar = K.variable(np.array([[1, 2], [3, 4]])) >>> K.dtype(kvar) 'float32_ref' >>> kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32') >>> K.dtype(kvar) 'float32_ref' ``` (RR(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRscCst|jdtS(spEvaluates the value of a variable. # Arguments x: A variable. # Returns A Numpy array. # Examples ```python >>> from keras import backend as K >>> kvar = K.variable(np.array([[1, 2], [3, 4]]), dtype='float32') >>> K.eval(kvar) array([[ 1., 2.], [ 3., 4.]], dtype=float32) ``` R1(RHtevalR3(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRtscCs^|dkrt}nttt|}t|}ttjdd||||S(sXInstantiates an all-zeros variable and returns it. # Arguments shape: Tuple of integers, shape of returned Keras variable dtype: String, data type of returned Keras variable name: String, name of returned Keras variable # Returns A variable (including Keras metadata), filled with `0.0`. # Example ```python >>> from keras import backend as K >>> kvar = K.zeros((3,4)) >>> K.eval(kvar) array([[ 0., 0., 0., 0.], [ 0., 0., 0., 0.], [ 0., 0., 0., 0.]], dtype=float32) ``` gRN( RRR[R\RR>R_R tconstant_initializer(RURRttf_dtype((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytzeross    cCs^|dkrt}nttt|}t|}ttjdd||||S(sKInstantiates an all-ones tensor variable and returns it. # Arguments shape: Tuple of integers, shape of returned Keras variable. dtype: String, data type of returned Keras variable. name: String, name of returned Keras variable. # Returns A Keras variable, filled with `1.0`. # Example ```python >>> from keras import backend as K >>> kvar = K.ones((3,4)) >>> K.eval(kvar) array([[ 1., 1., 1., 1.], [ 1., 1., 1., 1.], [ 1., 1., 1., 1.]], dtype=float32) ``` g?RN( RRR[R\RR>R_R Ru(RURRRv((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytones s    cCsttj|||S(sInstantiate an identity matrix and returns it. # Arguments size: Integer, number of rows/columns. dtype: String, data type of returned Keras variable. name: String, name of returned Keras variable. # Returns A Keras variable, an identity matrix. # Example ```python >>> from keras import backend as K >>> kvar = K.eye(3) >>> K.eval(kvar) array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]], dtype=float32) ``` (R_ROteye(tsizeRR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRy(scCstj|d|d|S(sInstantiates an all-zeros variable of the same shape as another tensor. # Arguments x: Keras variable or Keras tensor. dtype: String, dtype of returned Keras variable. None uses the dtype of x. name: String, name for the variable to create. # Returns A Keras variable with the shape of x filled with zeros. # Example ```python >>> from keras import backend as K >>> kvar = K.variable(np.random.random((2,3))) >>> kvar_zeros = K.zeros_like(kvar) >>> K.eval(kvar_zeros) array([[ 0., 0., 0.], [ 0., 0., 0.]], dtype=float32) ``` RR(R t zeros_like(RARR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR{AscCstj|d|d|S(sInstantiates an all-ones variable of the same shape as another tensor. # Arguments x: Keras variable or tensor. dtype: String, dtype of returned Keras variable. None uses the dtype of x. name: String, name for the variable to create. # Returns A Keras variable with the shape of x filled with ones. # Example ```python >>> from keras import backend as K >>> kvar = K.variable(np.random.random((2,3))) >>> kvar_ones = K.ones_like(kvar) >>> K.eval(kvar_ones) array([[ 1., 1., 1.], [ 1., 1., 1.]], dtype=float32) ``` RR(R t ones_like(RARR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR|ZscCs|dkrt}nttt|}t|}|dkrZtjjd}nt j ||d|d||}t |d|d|S(s^Instantiates a variable with values drawn from a uniform distribution. # Arguments shape: Tuple of integers, shape of returned Keras variable. low: Float, lower boundary of the output interval. high: Float, upper boundary of the output interval. dtype: String, dtype of returned Keras variable. name: String, name of returned Keras variable. seed: Integer, random seed. # Returns A Keras variable, filled with drawn samples. # Example ```python # TensorFlow example >>> kvar = K.random_uniform_variable((2,3), 0, 1) >>> kvar >>> K.eval(kvar) array([[ 0.10940075, 0.10047495, 0.476143 ], [ 0.66137183, 0.00869417, 0.89220798]], dtype=float32) ``` geARtseedRN( RRR[R\RR>ROtrandomtrandintR trandom_uniform_initializerR_(RUtlowthighRRR}RvR ((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytrandom_uniform_variabless    cCs|dkrt}nttt|}t|}|dkrZtjjd}nt j ||d|d||}t |d|d|S(s`Instantiates a variable with values drawn from a normal distribution. # Arguments shape: Tuple of integers, shape of returned Keras variable. mean: Float, mean of the normal distribution. scale: Float, standard deviation of the normal distribution. dtype: String, dtype of returned Keras variable. name: String, name of returned Keras variable. seed: Integer, random seed. # Returns A Keras variable, filled with drawn samples. # Example ```python # TensorFlow example >>> kvar = K.random_normal_variable((2,3), 0, 1) >>> kvar >>> K.eval(kvar) array([[ 1.19591331, 0.68685907, -0.63814116], [ 0.92629528, 0.28055015, 1.70484698]], dtype=float32) ``` geARR}RN( RRR[R\RR>ROR~RR trandom_normal_initializerR_(RUtmeantscaleRRR}RvR ((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytrandom_normal_variables    cCs?|j}tjgtt|D]}||j^q%S(s|Returns the number of scalars in a Keras variable. # Arguments x: Keras variable. # Returns Integer, the number of scalars in `x`. # Example ```python >>> kvar = K.zeros((2,3)) >>> K.count_params(kvar) 6 >>> K.eval(kvar) array([[ 0., 0., 0.], [ 0., 0., 0.]], dtype=float32) ``` (RMROtprodRiRrt_value(RARURo((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt count_paramss cCstj||S(sCasts a tensor to a different dtype and returns it. You can cast a Keras variable but it still returns a Keras tensor. # Arguments x: Keras tensor (or variable). dtype: String, either (`'float16'`, `'float32'`, or `'float64'`). # Returns Keras tensor with dtype `dtype`. # Example ```python >>> from keras import backend as K >>> input = K.placeholder((2, 3), dtype='float32') >>> input # It doesn't work in-place as below. >>> K.cast(input, dtype='float16') >>> input # you need to assign it. >>> input = K.cast(input, dtype='float16') >>> input ``` (R R@(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR@scCstj||S(N(R tassign(RAtnew_x((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytupdatescCstj||S(N(R t assign_add(RAt increment((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt update_addscCstj||S(N(R t assign_sub(RAt decrement((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt update_subscCstj|||dtS(Nt zero_debias(Rtassign_moving_averageRW(RAR tmomentum((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytmoving_average_updatesc Cst|dk rt|dks6t|dkrg}x^tt|tjtj|D]5\}}|dk r|j|qd|j|qdWt|}g}x^tt|tjtj|D]5\}}|dk r|j|q|j|qWt|}t t t|}|j dg|}tj |d|dg}tj tj |d||ddg}tj tj|||d |d |dSt|rtj||} ntj||} | S(shMultiplies 2 tensors (and/or variables) and returns a *tensor*. When attempting to multiply a nD tensor with a nD tensor, it reproduces the Theano behavior. (e.g. `(2, 3) * (4, 3, 5) -> (2, 4, 5)`) # Arguments x: Tensor or variable. y: Tensor or variable. # Returns A tensor, dot product of `x` and `y`. # Examples ```python # dot product between tensors >>> x = K.placeholder(shape=(2, 3)) >>> y = K.placeholder(shape=(3, 4)) >>> xy = K.dot(x, y) >>> xy ``` ```python # dot product between tensors >>> x = K.placeholder(shape=(32, 28, 3)) >>> y = K.placeholder(shape=(3, 4)) >>> xy = K.dot(x, y) >>> xy ``` ```python # Theano-like behavior example >>> x = K.random_uniform_variable(shape=(2, 3), low=0, high=1) >>> y = K.ones((4, 3, 5)) >>> xy = K.dot(x, y) >>> K.int_shape(xy) (2, 4, 5) ``` iiitpermN(RkRtzipRpR tunstackRURbR[tlistRitpoptreshapet transposetmatmulRFtsparse_tensor_dense_matmul( RAtytx_shapeRotsty_shapet y_permute_dimtxttyttout((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytdot s.*64  4  + cCs_t|tr||f}nt|dkrt|dkr|d|dkr{tjtj|||d}q7tjtjtj|ddg||d}n|dk r |dt|dkrdnt}|dt|dkrtnd}n d}d}tj ||d|d|}t|dkr[t |d}n|S(sBatchwise dot product. `batch_dot` is used to compute dot product of `x` and `y` when `x` and `y` are data in batch, i.e. in a shape of `(batch_size, :)`. `batch_dot` results in a tensor or variable with less dimensions than the input. If the number of dimensions is reduced to 1, we use `expand_dims` to make sure that ndim is at least 2. # Arguments x: Keras tensor or variable with `ndim >= 2`. y: Keras tensor or variable with `ndim >= 2`. axes: list of (or single) int with target dimensions. The lengths of `axes[0]` and `axes[1]` should be the same. # Returns A tensor with shape equal to the concatenation of `x`'s shape (less the dimension that was summed over) and `y`'s shape (less the batch dimension and the dimension that was summed over). If the final rank is 1, we reshape it to `(batch_size, 1)`. # Examples Assume `x = [[1, 2], [3, 4]]` and `y = [[5, 6], [7, 8]]` `batch_dot(x, y, axes=1) = [[17, 53]]` which is the main diagonal of `x.dot(y.T)`, although we never have to calculate the off-diagonal elements. Shape inference: Let `x`'s shape be `(100, 20)` and `y`'s shape be `(100, 30, 20)`. If `axes` is (1, 2), to find the output shape of resultant tensor, loop through each dimension in `x`'s shape and `y`'s shape: * `x.shape[0]` : 100 : append to output shape * `x.shape[1]` : 20 : do not append to output shape, dimension 1 of `x` has been summed over. (`dot_axes[0]` = 1) * `y.shape[0]` : 100 : do not append to output shape, always ignore first dimension of `y` * `y.shape[1]` : 30 : append to output shape * `y.shape[2]` : 20 : do not append to output shape, dimension 2 of `y` has been summed over. (`dot_axes[1]` = 2) `output_shape` = `(100, 30)` ```python >>> x_batch = K.ones(shape=(32, 20, 1)) >>> y_batch = K.ones(shape=(32, 30, 20)) >>> xy_batch_dot = K.batch_dot(x_batch, y_batch, axes=[1, 2]) >>> K.int_shape(xy_batch_dot) (32, 1, 30) ``` iiit adjoint_at adjoint_bN( RCRRkR t reduce_sumtmultiplyRRR.RRQ(RARtaxesRtadj_xtadj_y((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt batch_dotRs3$%7 &)cCs tj|S(sTransposes a tensor and returns it. # Arguments x: Tensor or variable. # Returns A tensor. # Examples ```python >>> var = K.variable([[1, 2, 3], [4, 5, 6]]) >>> K.eval(var) array([[ 1., 2., 3.], [ 4., 5., 6.]], dtype=float32) >>> var_transposed = K.transpose(var) >>> K.eval(var_transposed) array([[ 1., 4.], [ 2., 5.], [ 3., 6.]], dtype=float32) ``` ```python >>> input = K.placeholder((2, 3)) >>> input >>> input_transposed = K.transpose(input) >>> input_transposed ``` (R R(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRs cCstj||S(sRetrieves the elements of indices `indices` in the tensor `reference`. # Arguments reference: A tensor. indices: An integer tensor of indices. # Returns A tensor of same type as `reference`. (R tgather(t referenceRJ((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRs cCst|trt|}nt|trvxkt|D]5\}}|dk r:|dkr:|||| y). # Arguments x: Tensor or variable. y: Tensor or variable. # Returns A bool tensor. (R tgreater(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR6s cCstj||S(sElement-wise truth value of (x >= y). # Arguments x: Tensor or variable. y: Tensor or variable. # Returns A bool tensor. (R t greater_equal(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRCs cCstj||S(sElement-wise truth value of (x < y). # Arguments x: Tensor or variable. y: Tensor or variable. # Returns A bool tensor. (R tless(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRPs cCstj||S(sElement-wise truth value of (x <= y). # Arguments x: Tensor or variable. y: Tensor or variable. # Returns A bool tensor. (R t less_equal(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR]s cCstj||S(sElement-wise maximum of two tensors. # Arguments x: Tensor or variable. y: Tensor or variable. # Returns A tensor. (R tmaximum(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRjs cCstj||S(sElement-wise minimum of two tensors. # Arguments x: Tensor or variable. y: Tensor or variable. # Returns A tensor. (R tminimum(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRws cCs tj|S(suComputes sin of x element-wise. # Arguments x: Tensor or variable. # Returns A tensor. (R tsin(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRs cCs tj|S(suComputes cos of x element-wise. # Arguments x: Tensor or variable. # Returns A tensor. (R tcos(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRs gMbP?c Cs{tjj||dddddt\}}t|tt|d krstjj||||||}ng}xPtt|D]<} | |kr|j dq|j tj || qWtj |}tj ||} tj ||} |dkrd} ntj ||} |dkr;d} ntj ||} tjj|| | | | |}|||fS(sComputes mean and std for batch then apply batch_normalization on batch. # Arguments x: Input tensor or variable. gamma: Tensor by which to scale the input. beta: Tensor with which to center the input. reduction_axes: iterable of integers, axes over which to normalize. epsilon: Fuzz factor. # Returns A tuple length of 3, `(normalized_tensor, mean, variance)`. tshiftRRiiN( R tnntmomentsRRWtsortedRiRktbatch_normalizationRbRUtstackR(RAtgammatbetatreduction_axestepsilonRRtnormedt target_shapeRtbroadcast_meant broadcast_vartbroadcast_gammatbroadcast_beta((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytnormalize_batch_in_trainings0"       cCstjj||||||S(sApplies batch normalization on x given mean, var, beta and gamma. I.e. returns: `output = (x - mean) / (sqrt(var) + epsilon) * gamma + beta` # Arguments x: Input tensor or variable. mean: Mean of batch. var: Variance of batch. beta: Tensor with which to center the input. gamma: Tensor by which to scale the input. epsilon: Fuzz factor. # Returns A tensor. (R RR(RARRRRR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRscCs|dkr8t|d}|r/||;}q8d}ntg|D]}t|^qBrmtj||Stjg|D]}t|^qz|SdS(sConcatenates a list of tensors alongside the specified axis. # Arguments tensors: list of tensors to concatenate. axis: concatenation axis. # Returns A tensor. iN(Rktpy_allRFR t sparse_concattconcatRH(ttensorsRtrankRA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRPs   %cCstj||S(sReshapes a tensor to the specified shape. # Arguments x: Tensor or variable. shape: Target shape tuple. # Returns A tensor. (R R(RARU((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRs cCstj|d|S(sPermutes axes in a tensor. # Arguments x: Tensor or variable. pattern: A tuple of dimension indices, e.g. `(0, 2, 1)`. # Returns A tensor. R(R R(RAtpattern((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytpermute_dimensionss cCs|dkrt|}tj|d}|tjtj||gjd9}t|ddddg}tjj ||}t|ddddg}|j d d |dd k r|d|nd |dd k r|d|nd f|S|dkrt|}tj|dd!}|tjtj||gjd9}tjj ||}|j d |dd k r|d|nd |dd k r|d|nd d f|St d|d S( sResizes the images contained in a 4D tensor. # Arguments x: Tensor or variable to resize. height_factor: Positive integer. width_factor: Positive integer. data_format: One of `"channels_first"`, `"channels_last"`. # Returns A tensor. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. tchannels_firstiR9iiit channels_lastsInvalid data_format:N( RpR RURhROtarraytastypeRtimagetresize_nearest_neighbort set_shapeRR#(RAt height_factort width_factort data_formattoriginal_shapet new_shape((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt resize_imagess&  +-(  +*+cCs|dkrOt||dd}t||dd}t||dd}|S|dkrt||dd}t||dd}t||dd}|Std|d S( sResizes the volume contained in a 5D tensor. # Arguments x: Tensor or variable to resize. depth_factor: Positive integer. height_factor: Positive integer. width_factor: Positive integer. data_format: One of `"channels_first"`, `"channels_last"`. # Returns A tensor. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. RRiiiRisInvalid data_format:N(trepeat_elementsR#(RAt depth_factorRRRtoutput((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytresize_volumes9s  cCs|jj}||dkrStdt|dtt|dntjd|d||d|}g|D]}t|D] }|^qq|}t ||S(sRepeats the elements of a tensor along an axis, like `np.repeat`. If `x` has shape `(s1, s2, s3)` and `axis` is `1`, the output will have shape `(s1, s2 * rep, s3)`. # Arguments x: Tensor or variable. rep: Python integer, number of times to repeat. axis: Axis along which to repeat. # Raises ValueError: In case `x.shape[axis]` is undefined. # Returns A tensor. sAxis sR of input tensor should have a defined dimension, but is None. Full tensor shape: sX. Typically you need to pass a fully-defined `input_shape` argument to your first layer.R tnum_or_size_splitsRN( RMtas_listRR#tstrR[R tsplitRiRP(RAtrepRRtsplitsRRmtx_rep((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR Xs.",cCsRt|dksttj|d}tjd|dg}tj||S(s Repeats a 2D tensor. if `x` has shape (samples, dim) and `n` is `2`, the output will have shape `(samples, 2, dim)`. # Arguments x: Tensor or variable. n: Python integer, number of times to repeat. # Returns A tensor. ii(RktAssertionErrorR RQRttile(RAtnR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytrepeatws R9c Csd|dkr!|dkr!d}ntj|d|d|dd}|dkr`t||}n|S(sCreates a 1D tensor containing a sequence of integers. The function arguments use the same convention as Theano's arange: if only one argument is provided, it is in fact the "stop" argument. The default type of the returned tensor is `'int32'` to match TensorFlow's default. # Arguments start: Start value. stop: Stop value. step: Difference between two successive values. dtype: Integer dtype to use. # Returns An integer tensor. itlimittdeltaRtarangeR9N(RR RiR@(tstarttstoptstepRtresult((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRs  ! cCs+t|tr|g}ntj||S(sCreates a tensor by tiling `x` by `n`. # Arguments x: A tensor or variable n: A list of integer. The length must be the same as the number of dimensions in `x`. # Returns A tiled tensor. (RCRR R(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRs  cCstj|dgS(s{Flatten a tensor. # Arguments x: A tensor or variable. # Returns A tensor, reshaped into 1-D i(R R(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytflattens cCs5tj|tjdtt|dg}|S(sTurn a nD tensor into a 2D tensor with same 0th dimension. In other words, it flattens each data samples of a batch. # Arguments x: A tensor or variable. # Returns A tensor. ii(R RRRRU(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt batch_flattens 1cCstj||S(sAdds a 1-sized dimension at index "dim". # Arguments x: A tensor or variable. axis: Position where to add a new axis. # Returns A tensor with expended dimensions. (R RQ(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRQs cCstj||gS(sRemoves a 1-dimension from the tensor at index "axis". # Arguments x: A tensor or variable. axis: Axis to drop. # Returns A tensor with the same data as `x` but reduced dimensions. (R tsqueeze(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR"s cCsQt|dkstddg|d|dgddgg}tj||S(sPads the middle dimension of a 3D tensor. # Arguments x: Tensor or variable. padding: Tuple of 2 integers, how many zeros to add at the start and end of dim 1. # Returns A padded 3D tensor. iii(RrRR tpad(RAtpaddingR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyttemporal_paddings )cCst|dkstt|ddks4tt|ddksPt|dkrht}n|ddhkrtdt|n|dkrddgddgt|dt|dg}n2ddgt|dt|dddgg}tj||S(stPads the 2nd and 3rd dimensions of a 4D tensor. # Arguments x: Tensor or variable. padding: Tuple of 2 tuples, padding pattern. data_format: One of `channels_last` or `channels_first`. # Returns A padded 4D tensor. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. iiiRRsUnknown data_format N( RrRRRR#RRR R#(RAR$RR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytspatial_2d_paddings        cCst|dkstt|ddks4tt|ddksPtt|ddkslt|dkrt}n|ddhkrtdt|n|dkr!ddgddg|dd|ddg|dd|ddg|dd|ddgg}ncddg|dd|ddg|dd|ddg|dd|ddgddgg}tj||S( sPads 5D tensor with zeros along the depth, height, width dimensions. Pads these dimensions with respectively "padding[0]", "padding[1]" and "padding[2]" zeros left and right. For 'channels_last' data_format, the 2nd, 3rd and 4th dimension will be padded. For 'channels_first' data_format, the 3rd, 4th and 5th dimension will be padded. # Arguments x: Tensor or variable. padding: Tuple of 3 tuples, padding pattern. data_format: One of `channels_last` or `channels_first`. # Returns A padded 5D tensor. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. iiiiRRsUnknown data_format N(RrRRRR#RR R#(RAR$RR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytspatial_3d_paddings(     " icCstj|d|S(sStacks a list of rank `R` tensors into a rank `R+1` tensor. # Arguments x: List of tensors. axis: Axis along which to perform stacking. # Returns A tensor. R(R R(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRSs cCstj|d|ddS(sComputes the one-hot representation of an integer tensor. # Arguments indices: nD integer tensor of shape `(batch_size, dim1, dim2, ... dim(n-1))` num_classes: Integer, number of classes to consider. # Returns (n + 1)D one hot representation of the input with shape `(batch_size, dim1, dim2, ... dim(n-1), num_classes)` # Returns The one-hot tensor. tdepthRi(R tone_hot(RJt num_classes((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR)`scCs+t|tr|g}ntj||S(sReverse a tensor along the specified axes. # Arguments x: Tensor to reverse. axes: Integer or iterable of integers. Axes to reverse. # Returns A tensor. (RCRR treverse(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR+rs  cCs|jdtS(swReturns the value of a variable. # Arguments x: input variable. # Returns A Numpy array. R1(RtR3(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt get_values cCs|rtj|SgSdS(sReturns the value of more than one tensor variable. # Arguments ops: list of ops to run. # Returns A list of Numpy arrays. N(R3Rc(tops((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytbatch_get_values cCstj|}t|jjjdd}t|drR|j}|j}n9t j |d|j }|j |}||_||_t j|di||6dS(sSets the value of a variable, from a Numpy array. # Arguments x: Tensor to set to a new value. value: Value to set the tensor to, as a Numpy array (of the same shape). Rmit_assign_placeholderRUt feed_dictN(ROtasarrayR>RRRRNR/t _assign_opR RRURR3Rc(RAR Rvtassign_placeholdert assign_op((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt set_values    cCs|rg}i}x|D]\}}tj|}t|jjjdd}t|drw|j}|j}n9t j |d|j }|j |}||_||_|j ||||RRRRNR/R2R RRURRbR3Rc(ttuplest assign_opsR0RAR RvR3R4((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytbatch_set_values"       cCs t|S(syReturns the shape of a variable. # Arguments x: A variable. # Returns A tuple of integers. (Rp(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytget_variable_shapes cCstj||g|S(sPrints `message` and the tensor value when evaluated. # Arguments x: Tensor to print. message: Message to print jointly with the tensor. # Returns The same tensor `x`, unchanged. (R tPrint(RAtmessage((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt print_tensors tFunctioncBs#eZdZddZdZRS(sRuns a computation graph. # Arguments inputs: Feed placeholders to the computation graph. outputs: Output tensors to fetch. updates: Additional update ops to be run at function call. c Cs |p g}t|ttfs0tdnt|ttfsTtdnt|ttfsxtdnt||_t||_tj|jrg}xR|D]J}t|tr|\}}|jtj ||q|j|qWtj ||_ WdQXdS(NsD`inputs` to a TensorFlow backend function should be a list or tuple.sE`outputs` of a TensorFlow backend function should be a list or tuple.sE`updates` in a TensorFlow backend function should be a list or tuple.( RCRR[t TypeErrortinputstoutputsR tcontrol_dependenciesRbRtgroupt updates_op(tselfR?R@tupdatest updates_opsRtptnew_p((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt__init__s"   c Cst|ttfs$tdni}xt|j|D]|\}}t|r|j}tj tj |j dtj |j dfd}||j |jf}n|||RR?RFRIRORPRQRRRSRTRUR3RcR@RCRr( RDR?R0RER R]RJR1tupdated((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt__call__ s    N(t__name__t __module__t__doc__RRIRK(((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR=s cKsH|r5dt|dg}tjdj|nt||d|S(sInstantiates a Keras function. # Arguments inputs: List of placeholder tensors. outputs: List of output tensors. updates: List of update ops. **kwargs: Not used with TensorFlow. # Returns Output values as Numpy arrays. s!Expected no kwargs, you passed %ss=kwargs passed to function are ignored with Tensorflow backends RE(RrtwarningstwarntjoinR=(R?R@REtkwargstmsg((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytfunctions   cCstj||dtS(sReturns the gradients of `variables` w.r.t. `loss`. # Arguments loss: Scalar tensor to minimize. variables: List of variables. # Returns A gradients tensor. tcolocate_gradients_with_ops(R t gradientsR.(tlossRe((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRV2s cCs tj|S(sReturns `variables` but with zero gradient w.r.t. every other variable. # Arguments variables: List of variables. # Returns The same list of variables. (R t stop_gradient(Re((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRX?s c sHt|j}|dkr-tdnddgttd|} tj|| }|dk r|jtj krtj |tj }nt|j|dkrt |}ntj|| }ndkrgn|r+|jdstdn|} g} g} tj |} |rB| j n|dk rtj |}|rp|j nxt| |D]:\}}|| \}}tj|tjdtj|dg}| st|}n | d}tj|||}g}xgt| |D]V\}}tj|tjdtj|dg}|jtj|||qW|} | j|| j| | d}| d}tj| }qWqxA| D]9}|| \}} | j|| j| qW| d}| d}tj| }n|rCt |d}nt|} tj|d|d|\}}tjd|jd d d }tjd|jd d d j |tjddd dd}|dk ro| s tdn|r$t |d}ntjdtj d d dj |fd}nfd}tjdfdd|d||f| dddt}|d}|d}|d}|j}|j|d}ddgttdt|j} tj|| }|||fS(sIterates over the time dimension of a tensor. # Arguments step_function: RNN step function. Parameters: input: tensor with shape `(samples, ...)` (no time dimension), representing input for the batch of samples at a certain time step. states: list of tensors. Returns: output: tensor with shape `(samples, output_dim)` (no time dimension). new_states: list of tensors, same length and shapes as 'states'. The first state in the list must be the output tensor at the previous timestep. inputs: tensor of temporal data of shape `(samples, time, ...)` (at least 3D). initial_states: tensor with shape (samples, output_dim) (no time dimension), containing the initial values for the states used in the step function. go_backwards: boolean. If True, do the iteration over the time dimension in reverse order. mask: binary tensor with shape `(samples, time, 1)`, with a zero for every element that is masked. constants: a list of constant values passed at each step. unroll: whether to unroll the RNN or to use a symbolic loop (`while_loop` or `scan` depending on backend). input_length: not relevant in the TensorFlow implementation. Must be specified if using unrolling with Theano. # Returns A tuple, `(last_output, outputs, new_states)`. last_output: the latest output of the rnn, of shape `(samples, ...)` outputs: tensor with shape `(samples, time, ...)` where each entry `outputs[s, t]` is the output of the step function at time `t` for sample `s`. new_states: list of tensors, latest states returned by the step function, of shape `(samples, ...)`. # Raises ValueError: if input dimension is less than 3. ValueError: if `unroll` is `True` but input timestep is not a fixed number. ValueError: if `mask` is provided (not `None`) but states is not provided (`len(states)` == 0). isInput should be at least 3D.iiis/Unrolling requires a fixed number of timesteps.iRRzttensor_array_namet output_tatinput_taR9RttimesNo initial states provided! When using masking in an RNN, you should provide initial states (and your step function should return as its first state at time `t` the output at time `t-1`).tmask_tac s#j|}j|}|t|t\}}x0t||D]\}}|j|jqSWtj|tjdtj|dg} tj | ||d}gt t |D]#} tj | || || ^q}|j ||}|d|ft|S(s0RNN step function. # Arguments time: Current timestep value. output_ta_t: TensorArray. *states: List of states. # Returns Tuple: `(time + 1,output_ta_t) + tuple(new_states)` ii( treadR[RRRMR RRRUtwhereRiRrtwrite( R\t output_ta_ttstatest current_inputtmask_tR t new_stateststatet new_statet tiled_mask_tRo(t constantsR[R]t step_function(s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_steps   %<csj|}|t|t\}}x0t||D]\}}|j|jqDW|j||}|d|ft|S(s0RNN step function. # Arguments time: Current timestep value. output_ta_t: TensorArray. *states: List of states. # Returns Tuple: `(time + 1,output_ta_t) + tuple(new_states)` i(R^R[RRRMR`(R\RaRbRcR ReRfRg(RiR[Rj(s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRk s  tcondcs |kS(N((R\Rm(t time_steps(s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt stbodyt loop_varstparallel_iterationsi t swap_memoryN(RrRMR#RRiR RRRRR@RQRR+RRRRUR{R_RbR[Rt TensorArrayRhRt while_loopR.R^( RjR?tinitial_statest go_backwardstmaskRitunrollt input_lengthRkRRbtsuccessive_statestsuccessive_outputst input_listt mask_listtinpRdR ReRht prev_outputt return_statesRfRgt last_outputR@RmRZR\Rkt final_outputst last_time((RiR[R]RjRms?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytrnnMs1        %  %                         +cs|jtjkr'tj|d}ntsEfd}n}tsifd}n}tj|||}|S(sSwitches between two operations depending on a scalar value. Note that both `then_expression` and `else_expression` should be symbolic tensors of the *same shape*. # Arguments condition: scalar tensor (`int` or `bool`). then_expression: either a tensor, or a callable that returns a tensor. else_expression: either a tensor, or a callable that returns a tensor. # Returns The selected tensor. RcsS(N(((tthen_expression(s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytthen_expression_fnA scsS(N(((telse_expression(s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytelse_expression_fnF s(RR RR@tcallableRl(t conditionRRRRRA((RRs?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytswitch0 s    cCs|dkrt}t}nt}|dks<|tkrVt|rO|S|Sn2|dksn|tkrt|r|S|Snt|||}|rt|_n|S(sLSelects `x` in train phase, and `alt` otherwise. Note that `alt` should have the *same shape* as `x`. # Arguments x: What to return in train phase (tensor or callable that returns a tensor). alt: What to return otherwise (tensor or callable that returns a tensor). training: Optional scalar tensor (or Python boolean, or Python integer) specifing the learning phase. # Returns Either `x` or `alt` based on the `training` flag. the `training` flag defaults to `K.learning_phase()`. iiN(RR"R.RWRRRX(RAtaltttrainingtuses_learning_phase((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytin_train_phaseP s       cCst||d|S(s Selects `x` in test phase, and `alt` otherwise. Note that `alt` should have the *same shape* as `x`. # Arguments x: What to return in test phase (tensor or callable that returns a tensor). alt: What to return otherwise (tensor or callable that returns a tensor). training: Optional scalar tensor (or Python boolean, or Python integer) specifing the learning phase. # Returns Either `x` or `alt` based on `K.learning_phase`. R(R(RARR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt in_test_phase{ sgcCs|dkr"tjj| }ntjj|}|dk rt||jj}td|jj}tj|||}n|dkrt||jj}|||8}n|S(sRectified linear unit. With default values, it returns element-wise `max(x, 0)`. # Arguments x: A tensor or variable. alpha: A scalar, slope of negative section (default=`0.`). max_value: Saturation threshold. # Returns A tensor. gN(R RtreluRRBRRR(RAtalphaRt negative_partR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s   g?cCsCtjj|}|dkr"|Stj|dk|||SdS(sExponential linear unit. # Arguments x: A tenor or variable to compute the activation function for. alpha: A scalar, slope of positive section. # Returns A tensor. iiN(R RteluR_(RARtres((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s  cCstjj|S(slSoftmax of a tensor. # Arguments x: A tensor or variable. # Returns A tensor. (R Rtsoftmax(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s cCstjj|S(smSoftplus of a tensor. # Arguments x: A tensor or variable. # Returns A tensor. (R Rtsoftplus(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s cCstjj|S(smSoftsign of a tensor. # Arguments x: A tensor or variable. # Returns A tensor. (R Rtsoftsign(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s cCs|s|tj|dt|jddt:}tt|jj}tj ||d|}tj|tj |dt|jd Stj j d|d|SdS(sCategorical crossentropy between an output tensor and a target tensor. # Arguments output: A tensor resulting from a softmax (unless `from_logits` is True, in which case `output` is expected to be the logits). target: A tensor of the same shape as `output`. from_logits: Boolean, whether `output` is the result of a softmax, or is a tensor of logits. # Returns Output tensor. RiRg?tlabelstlogitsN( R RRrRMR.RBRRRRRRt!softmax_cross_entropy_with_logits(R ttargett from_logitsR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytcategorical_crossentropy s cCs|sFtt|jj}tj||d|}tj|}n|j}tt |d}tj |dt |dg}tj j d|d|}t|dkrtj |tj|d S|SdS(sCategorical crossentropy with integer targets. # Arguments output: A tensor resulting from a softmax (unless `from_logits` is True, in which case `output` is expected to be the logits). target: An integer tensor. from_logits: Boolean, whether `output` is the result of a softmax, or is a tensor of logits. # Returns Output tensor. iR:iRRiN(RBRRRR RRRMR@R RRRt(sparse_softmax_cross_entropy_with_logitsRrRU(R RRRt output_shapettargetsRR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytsparse_categorical_crossentropy s "  cCsg|sNtt|jj}tj||d|}tj|d|}ntjjd|d|S(swBinary crossentropy between an output tensor and a target tensor. # Arguments output: A tensor. target: A tensor with the same shape as `output`. from_logits: Whether `output` is expected to be a logits tensor. By default, we consider that `output` encodes a probability distribution. # Returns A tensor. iRR( RBRRRR RRRt!sigmoid_cross_entropy_with_logits(R RRR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytbinary_crossentropy! s cCstjj|S(smElement-wise sigmoid. # Arguments x: A tensor or variable. # Returns A tensor. (R Rtsigmoid(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR: s cCsQd|d}td|jj}td|jj}tj|||}|S(sSegment-wise linear approximation of sigmoid. Faster than sigmoid. Returns `0.` if `x < -2.5`, `1.` if `x > 2.5`. In `-2.5 <= x <= 2.5`, returns `0.2 * x + 0.5`. # Arguments x: A tensor or variable. # Returns A tensor. g?g?gg?(RBRRR R(RARtone((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt hard_sigmoidF s cCstjj|S(sjElement-wise tanh. # Arguments x: A tensor or variable. # Returns A tensor. (R Rttanh(RA((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRZ s cCsKd|}|dkr+tjjd}ntjj|d||d|S(sSets entries in `x` to zero at random, while scaling the entire tensor. # Arguments x: tensor level: fraction of the entries in the tensor that will be set to 0. noise_shape: shape for randomly generated keep/drop flags, must be broadcastable to the shape of `x` seed: random seed to ensure determinism. # Returns A tensor. g?gcAR}N(RROR~RR Rtdropout(RAtlevelt noise_shapeR}t retain_prob((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRf s  cCs;|dkr%|t|j;}ntjj|d|S(sNormalizes a tensor wrt the L2 norm alongside the specified axis. # Arguments x: Tensor or variable. axis: axis along which to perform normalization. # Returns A tensor. itdim(RrRMR Rt l2_normalize(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR| s cCstjj|||S(sReturns whether the `targets` are in the top `k` `predictions`. # Arguments predictions: A tensor of shape `batch_size` x classes and type `float32`. targets: A tensor of shape batch_size and type `int32` or `int64`. k: An `int`, number of top elements to consider. # Returns A tensor of shape `batch_size` and type `bool`. `output_i` is `True` if `targets_i` is within top-k values of `predictions_i` (R Rtin_top_k(t predictionsRtk((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s cCs|dkr1|d|d|d|df}n|ddkr}tj|dft|d}tjt|}n|S(NRiiii(RR RUR[RR(RARUR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_preprocess_deconv_output_shape s  %$cCsLt|dkr'tj|d}n|dkrHtj|d}n|S( NR7R6Riiii(iiii(RR R@R(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_preprocess_conv2d_input s  cCsLt|dkr'tj|d}n|dkrHtj|d }n|S( NR7R6Riiiii(iiiii(RR R@R(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_preprocess_conv3d_input s  cCsLt|dkr'tj|d}n|dkrHtj|d}n|S( NR7R6Riiii(iiii(RR R@R(tkernelR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_preprocess_conv2d_kernel s  cCsLt|dkr'tj|d}n|dkrHtj|d }n|S( NR7R6Riiiii(iiiii(RR R@R(RR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_preprocess_conv3d_kernel s  cCs=|dkrd}n$|dkr*d}ntd||S(NtsametSAMEtvalidtVALIDsInvalid border mode:(R#(R$((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_preprocess_padding s     cCsI|dkr!tj|d}ntdkrEtj|d}n|S(NRiiiiR7(iiii(R RRR@(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_postprocess_conv2d_output s  cCsI|dkr!tj|d}ntdkrEtj|d}n|S( NRiiiiiR7(iiiii(R RRR@(RAR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt_postprocess_conv3d_output s  Rc Cs|jj}|dkrN||dd}t||df}d}nt|}|dkrod}nd}tjjd|d |d |fd |fd |d |}|S(sn1D convolution. # Arguments x: Tensor or variable. kernel: kernel tensor. strides: stride integer. padding: string, `"same"`, `"causal"` or `"valid"`. data_format: string, one of "channels_last", "channels_first". dilation_rate: integer dilate rate. # Returns A tensor, result of 1D convolution. tcausaliiRRtNWCtNCWtinputtfiltert dilation_ratetstridesR$R(RMRR%RR Rt convolution( RARRR$RRt kernel_shapetleft_padttf_data_format((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytconv1d s"         c Cs|d krt}n|ddhkrCtdt|nt||}t|}tjjd|d|d|d|d|d d }t ||S( s2D convolution. # Arguments x: Tensor or variable. kernel: kernel tensor. strides: strides tuple. padding: string, `"same"` or `"valid"`. data_format: `"channels_last"` or `"channels_first"`. Whether to use Theano or TensorFlow data format for inputs/kernels/ouputs. dilation_rate: tuple of 2 integers. # Returns A tensor, result of 2D convolution. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. RRsUnknown data_format RRRRR$RtNHWCN( RRR#RRRR RRR(RARRR$RR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytconv2d s     cCs|dkrt}n|ddhkrCtdt|nt|ttfrjtj|}nt ||}t |||}t |}d|d}tj j ||||d|}t||}|S( sW2D deconvolution (i.e. transposed convolution). # Arguments x: Tensor or variable. kernel: kernel tensor. output_shape: 1D int tensor for the output shape. strides: strides tuple. padding: string, `"same"` or `"valid"`. data_format: `"channels_last"` or `"channels_first"`. Whether to use Theano or TensorFlow data format for inputs/kernels/ouputs. # Returns A tensor, result of transposed 2D convolution. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. RRsUnknown data_format iR$N(i(i(RRR#RRCR[RR RRRRRtconv2d_transposeR(RARRRR$R((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR2 s    c Cs|dkrt}n|ddhkrCtdt|nt||}t|}d |d }tjj|||d|d|d|}t ||S( sk2D convolution with separable filters. # Arguments x: input tensor depthwise_kernel: convolution kernel for the depthwise convolution. pointwise_kernel: kernel for the 1x1 convolution. strides: strides tuple (length 2). padding: padding mode, "valid" or "same". data_format: data format, "channels_first" or "channels_last". dilation_rate: tuple of integers, dilation rates for the separable convolution. # Returns Output tensor. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. RRsUnknown data_format iRR$trateN(i(i( RRR#RRRR Rtseparable_conv2dR(RAtdepthwise_kerneltpointwise_kernelRR$RR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRX s    c Cs|d krt}n|ddhkrCtdt|nt||}t|}tjjd|d|d|d|d|d d }t ||S( s3D convolution. # Arguments x: Tensor or variable. kernel: kernel tensor. strides: strides tuple. padding: string, `"same"` or `"valid"`. data_format: `"channels_last"` or `"channels_first"`. Whether to use Theano or TensorFlow data format for inputs/kernels/ouputs. dilation_rate: tuple of 3 integers. # Returns A tensor, result of 3D convolution. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. RRsUnknown data_format RRRRR$RtNDHWCN( RRR#RRRR RRR(RARRR$RR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytconv3d| s     RcCs|d krt}n|ddhkrCtdt|nt|}d |d }d |d }t||}|dkrtjj|||d|}n<|dkrtjj |||d|}ntd|t ||S(s2D Pooling. # Arguments x: Tensor or variable. pool_size: tuple of 2 integers. strides: tuple of 2 integers. padding: one of `"valid"`, `"same"`. data_format: one of `"channels_first"`, `"channels_last"`. pool_mode: one of `"max"`, `"avg"`. # Returns A tensor, result of 2D pooling. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. ValueError: if `pool_mode` is neither `max` or `avg`. RRsUnknown data_format iRR$tavgsInvalid pooling mode:N(i(i(i(i( RRR#RRRR Rtmax_pooltavg_poolR(RAt pool_sizeRR$Rt pool_mode((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytpool2d s    ! !cCs|d krt}n|ddhkrCtdt|nt|}d |d }d |d }t||}|dkrtjj|||d|}n<|dkrtjj |||d|}ntd|t ||S(s3D Pooling. # Arguments x: Tensor or variable. pool_size: tuple of 3 integers. strides: tuple of 3 integers. padding: one of `"valid"`, `"same"`. data_format: one of `"channels_first"`, `"channels_last"`. pool_mode: one of `"max"`, `"avg"`. # Returns A tensor, result of 3D pooling. # Raises ValueError: if `data_format` is neither `channels_last` or `channels_first`. ValueError: if `pool_mode` is neither `max` or `avg`. RRsUnknown data_format iRR$RsInvalid pooling mode:N(i(i(i(i( RRR#RRRR Rt max_pool3dt avg_pool3dR(RARRR$RR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytpool3d s    ! !c Cs|d krt}n|ddhkrCtdt|nt|dkr|dkr|t|dt|ddddf7}q|dkr|t|ddddt|df7}qn t|dkrE|dkr|t|dt|dddf7}q|dkrtjj ||dd }qnt|d kr|dkr|t|dt|ddf7}q|dkr|t|ddt|df7}qntjj ||}|S( sZAdds a bias vector to a tensor. # Arguments x: Tensor or variable. bias: Bias tensor to add. data_format: Data format for 3D, 4D or 5D tensors: one of "channels_first", "channels_last". # Returns Output tensor. # Raises ValueError: In case of invalid `data_format` argument. RRsUnknown data_format iiiiRRiN( RRR#RRkRRpR Rtbias_add(RAtbiasR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s,   / 2 ,  ) ,c Cs^|dkrt}n|dkr9tjjd}ntj|d|d|d|d|S(sReturns a tensor with normal distribution of values. # Arguments shape: A tuple of integers, the shape of tensor to create. mean: A float, mean of the normal distribution to draw samples. stddev: A float, standard deviation of the normal distribution to draw samples. dtype: String, dtype of returned tensor. seed: Integer, random seed. # Returns A tensor. gcARtstddevRR}N(RRROR~RR t random_normal(RURRRR}((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s    c Cs^|dkrt}n|dkr9tjjd}ntj|d|d|d|d|S(sReturns a tensor with uniform distribution of values. # Arguments shape: A tuple of integers, the shape of tensor to create. minval: A float, lower boundary of the uniform distribution to draw samples. maxval: A float, upper boundary of the uniform distribution to draw samples. dtype: String, dtype of returned tensor. seed: Integer, random seed. # Returns A tensor. gcAtminvaltmaxvalRR}N(RRROR~RR trandom_uniform(RURRRR}((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR6 s    cCs|dkrt}n|dkr9tjjd}ntjtj|d|d||ktj|d|tj |d|S(sVReturns a tensor with random binomial distribution of values. # Arguments shape: A tuple of integers, the shape of tensor to create. p: A float, `0. <= p <= 1`, probability of binomial distribution. dtype: String, dtype of returned tensor. seed: Integer, random seed. # Returns A tensor. gcARR}N( RRROR~RR R_RRxRw(RURGRR}((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytrandom_binomialM s   $cCsX|dkrt}n|dkr9tjjd}ntj|||d|d|S(sHReturns a tensor with truncated random normal distribution of values. The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than two standard deviations from the mean are dropped and re-picked. # Arguments shape: A tuple of integers, the shape of tensor to create. mean: Mean of the values. stddev: Standard deviation of the values. dtype: String, dtype of returned tensor. seed: Integer, random seed. # Returns A tensor. gcARR}N(RRROR~RR ttruncated_normal(RURRRR}((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyRb s    c stj|tjdg}tjdgfd}tjtjddgdtj}tj||d|dd}|dddddf}tjtj tj dd|}tj ||}tj tjtj tj ddt d}tj ||} tj tjt| |gdddd g} tj|| } tjtj| | tjS( sConverts CTC labels from dense to sparse. # Arguments labels: dense CTC labels. label_lengths: length of the labels. # Returns A sparse tensor representation of the lablels. iics/tjtjddtj|kS(Nii(R RQRitfill(RmRc(t label_shapetmax_num_labels_tns(s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytrange_less_than s"t initializerRqNRii(R RURR@RRRtscanRRRit boolean_maskRR+RPt gather_ndRDtto_int64( Rt label_lengthstnum_batches_tnsRtinitt dense_maskt label_arrayt label_indt batch_arrayt batch_indRJt vals_sparse((RRs?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytctc_label_dense_to_sparse s" +% %3cCstjtj|}tjtj|}tjt||}tjtj|ddddgd}tjtjd|d|d|dS( s}Runs CTC loss algorithm on each batch element. # Arguments y_true: tensor `(samples, max_string_length)` containing the truth labels. y_pred: tensor `(samples, time_steps, num_categories)` containing the prediction, or output of the softmax. input_length: tensor `(samples, 1)` containing the sequence length for each batch item in `y_pred`. label_length: tensor `(samples, 1)` containing the sequence length for each batch item in `y_true`. # Returns Tensor with shape (samples,1) containing the CTC loss of each element. Riiig:0yE>R?Rtsequence_length( R tto_int32R"RRRRQtctctctc_loss(ty_truety_predRyt label_lengtht sparse_labels((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pytctc_batch_cost s+idc Cstjtj|ddddgd}tj|}|ratjd|d|\}}n*tjd|d|d|d |\}}g|D]*}tj|j|j |j d d ^q}||fS( sDecodes the output of a softmax. Can use either greedy search (also known as best path) or a constrained dictionary search. # Arguments y_pred: tensor `(samples, time_steps, num_categories)` containing the prediction, or output of the softmax. input_length: tensor `(samples, )` containing the sequence length for each batch item in `y_pred`. greedy: perform much faster best-path search if `true`. This does not use a dictionary. beam_width: if `greedy` is `false`: a beam search decoder will be used with a beam of this width. top_paths: if `greedy` is `false`, how many of the most probable paths will be returned. # Returns Tuple: List: if `greedy` is `true`, returns a list of one element that contains the decoded sequence. If `false`, returns the `top_paths` most probable decoded sequences. Important: blank labels are returned as `-1`. Tensor `(top_paths, )` that contains the log probability of each decoded sequence. Riiig:0yE>R?Rt beam_widtht top_pathst default_valuei( R RRRRtctc_greedy_decodertctc_beam_search_decodertsparse_to_denseRJRLRK( RRytgreedyRRtdecodedtlog_probtstt decoded_dense((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyt ctc_decode s+   4cCstj||d|S(sVMap the function fn over the elements elems and return the outputs. # Arguments fn: Callable that will be called upon each element in elems elems: tensor name: A string name for the map node in the graph # Returns Tensor with first dimension equal to the elems and second depending on fn R(R tmap_fn(tfntelemsR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s cCstj||d|d|S(sReduce elems using fn to combine them from left to right. # Arguments fn: Callable that will be called upon each element in elems and an accumulator, for instance `lambda acc, x: acc + x` elems: tensor initializer: The first value used (`elems[0]` in case of None) name: A string name for the foldl node in the graph # Returns Same type and shape as initializer RR(R tfoldl(RRRR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s cCstj||d|d|S(sReduce elems using fn to combine them from right to left. # Arguments fn: Callable that will be called upon each element in elems and an accumulator, for instance `lambda acc, x: acc + x` elems: tensor initializer: The first value used (`elems[-1]` in case of None) name: A string name for the foldr node in the graph # Returns Same type and shape as initializer RR(R tfoldr(RRRR((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyR s (ii(ii(ii(ii(ii(ii(ii(ii(ii(ii(ii(iii(iii(ii(iii(t tensorflowR ttensorflow.python.trainingRttensorflow.python.opsRRRRRt collectionsRtnumpyROR*ROtcommonRRRR R RRRtpy_sumRRRRRWRRRRR!R"R$R3R4R>RBRFRHt name_scopeR_R0RhRRURpRkRRtRwRxRyR{R|RRRR@RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRPRRR R R RRRR R!RQR"R%R&R'RR)R+R,R.R5R8R9R<tobjectR=RTRVRXRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR.R RRR(((s?/tmp/pip-build-isqEY4/keras/keras/backend/tensorflow_backend.pyts`          "     . (     %%  #     F G #        .    &      #4      2    +    "         #'%#' '( * %  0