B ӻd|? @sdZddlmZddlmZddlmZddlmZddlmZddl m Z ddl m Z dd l m Z dd l mZdd lmZdd lmZdd lmZddZedGddde jZedddddZdS)z,Input layer code (`Input` and `InputLayer`).)distribution_strategy_context)ops) tensor_shape) tensor_spec)backend)distributed_training_utils) base_layer) keras_tensor)node)layer_serialization)tf_utils) keras_exportcCs|dk rtd|dS)Nz\When `type_spec` is not None, all other args except `name` must be None, but %s is not None.) ValueError)arg_nameargr\/var/www/html/venv/lib/python3.7/site-packages/tensorflow/python/keras/engine/input_layer.py_assert_other_arg_none srzkeras.layers.InputLayercs6eZdZdZd fdd ZddZeddZZS) InputLayera Layer to be used as an entry point into a Network (a graph of layers). It can either wrap an existing tensor (pass an `input_tensor` argument) or create a placeholder tensor (pass arguments `input_shape`, and optionally, `dtype`). It is generally recommend to use the functional layer API via `Input`, (which creates an `InputLayer`) without directly using `InputLayer`. When using InputLayer with Keras Sequential model, it can be skipped by moving the input_shape parameter to the first layer after the InputLayer. This class can create placeholders for tf.Tensors, tf.SparseTensors, and tf.RaggedTensors by choosing 'sparse=True' or 'ragged=True'. Note that 'sparse' and 'ragged' can't be configured to True at same time. Usage: ```python # With explicit InputLayer. model = tf.keras.Sequential([ tf.keras.layers.InputLayer(input_shape=(4,)), tf.keras.layers.Dense(8)]) model.compile(tf.optimizers.RMSprop(0.001), loss='mse') model.fit(np.zeros((10, 4)), np.ones((10, 8))) # Without InputLayer and let the first layer to have the input_shape. # Keras will add a input for the model behind the scene. model = tf.keras.Sequential([ tf.keras.layers.Dense(8, input_shape=(4,))]) model.compile(tf.optimizers.RMSprop(0.001), loss='mse') model.fit(np.zeros((10, 4)), np.ones((10, 8))) ``` Args: input_shape: Shape tuple (not including the batch axis), or `TensorShape` instance (not including the batch axis). batch_size: Optional input batch size (integer or None). dtype: Optional datatype of the input. When not provided, the Keras default float type will be used. input_tensor: Optional tensor to use as layer input. If set, the layer will use the `tf.TypeSpec` of this tensor rather than creating a new placeholder tensor. sparse: Boolean, whether the placeholder created is meant to be sparse. Default to False. ragged: Boolean, whether the placeholder created is meant to be ragged. In this case, values of 'None' in the 'shape' argument represent ragged dimensions. For more information about RaggedTensors, see [this guide](https://www.tensorflow.org/guide/ragged_tensors). Default to False. type_spec: A `tf.TypeSpec` object to create Input from. This `tf.TypeSpec` represents the entire batch. When provided, all other args except name must be None. name: Optional name of the layer (string). Nc  s||_||_||_||_||_||_t} | rl|dk rlt | rl|| j dkrbt d || j || j }d| kr| d} |r| rt d| r| d}| dd}| rt d| |r|rt d|sd} | d tt| }|s |dkrt}n t|}n(|dk r2|j|kr2t d |j|ftt|j||d d |_|rVd nd |_|rfd nd |_||_d |_t|tjrt| }nt|t!r|f}|dk r~d|jfd|jfd|jfd|fd|jfd|jfg} x| D]\}}t"||qWt#$st dt%&|}t|t%j'r0d |_t|t%j(rDd |_d |_)yt|j* |_+Wnt k rzd|_+YnXn|dkr|dk r|ft|} nd} t,}|-tj.| ||j/||d}WdQRXd |_)| |_+npt#$r t|t%j0st%1|}nt23|st dd |_)yt|j* |_+Wnt k rTd|_+YnXd|_4t5j6||dt|t%j0st27|r|j8|_8nt9j:|j*|j|j/d|_8dS)NrzOThe `batch_size` argument ({}) must be divisible by the number of replicas ({})batch_input_shapezdOnly provide the input_shape OR batch_input_shape argument to InputLayer, not both at the same time.zUnrecognized keyword arguments:z;Cannot set both sparse and ragged to True in a Keras input.input_z4`input_tensor.dtype` differs from `dtype`: %s vs. %s)dtypenameTFz (input_)shape batch_sizer input_tensorsparseraggedzYCreating Keras inputs from a type_spec is only supported when eager execution is enabled.)shaperrrrzYou should not pass an EagerTensor to `Input`. For example, instead of creating an InputLayer, you should instantiate your model and directly call it on your input.)layeroutputs)rrr);Z_init_input_shapeZ_init_batch_sizeZ _init_dtypeZ _init_sparseZ _init_ragged_init_type_specrZ get_strategyrZglobal_batch_size_supportedZnum_replicas_in_syncrformatpopkeysstrrZget_uidZfloatxrsuperr__init__ZbuiltrrrZsupports_masking isinstancerZ TensorShapetupleas_listintrrZ#executing_eagerly_outside_functionsr Zkeras_tensor_from_type_specZSparseKerasTensorZRaggedKerasTensorZis_placeholderr_batch_input_shapeZ get_graphZ as_default placeholderrZ KerasTensorZkeras_tensor_from_tensorr Zis_symbolic_tensorZ _keras_mask node_moduleNodeZis_extension_typeZ _type_specrZ TensorSpec)self input_shaperrrrrr type_speckwargsZstrategyrprefixZargs_that_must_be_nonerrgraph) __class__rrr(bs                       zInputLayer.__init__cCs8|jdk r|j|jd}n|j|j|j|j|jd}|S)N)rr3)rrrrr)r"rr-rrr)r1configrrr get_configs   zInputLayer.get_configcCs t|S)N)r ZInputLayerSavedModelSaver)r1rrr_trackable_saved_model_saversz'InputLayer._trackable_saved_model_saver)NNNNNNNN) __name__ __module__ __qualname____doc__r(r9propertyr: __classcell__rr)r7rr's9rz keras.Inputzkeras.layers.InputNc Ks|r|rtd||||||d} |d|dd} |dk rN| dk rNtd| dkrv|dkrv|dkrv|dkrvtd|rtd|| r| d d}| d| in| ||d tf| } | jd j} t| trt | d kr| d S| SdS) a`Input()` is used to instantiate a Keras tensor. A Keras tensor is a symbolic tensor-like object, which we augment with certain attributes that allow us to build a Keras model just by knowing the inputs and outputs of the model. For instance, if `a`, `b` and `c` are Keras tensors, it becomes possible to do: `model = Model(input=[a, b], output=c)` Args: shape: A shape tuple (integers), not including the batch size. For instance, `shape=(32,)` indicates that the expected input will be batches of 32-dimensional vectors. Elements of this tuple can be None; 'None' elements represent dimensions where the shape is not known. batch_size: optional static batch size (integer). name: An optional name string for the layer. Should be unique in a model (do not reuse the same name twice). It will be autogenerated if it isn't provided. dtype: The data type expected by the input, as a string (`float32`, `float64`, `int32`...) sparse: A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True. Note that, if `sparse` is False, sparse tensors can still be passed into the input - they will be densified with a default value of 0. tensor: Optional existing tensor to wrap into the `Input` layer. If set, the layer will use the `tf.TypeSpec` of this tensor rather than creating a new placeholder tensor. ragged: A boolean specifying whether the placeholder to be created is ragged. Only one of 'ragged' and 'sparse' can be True. In this case, values of 'None' in the 'shape' argument represent ragged dimensions. For more information about RaggedTensors, see [this guide](https://www.tensorflow.org/guide/ragged_tensors). type_spec: A `tf.TypeSpec` object to create the input placeholder from. When provided, all other args except name must be None. **kwargs: deprecated arguments support. Supports `batch_shape` and `batch_input_shape`. Returns: A `tensor`. Example: ```python # this is a logistic regression in Keras x = Input(shape=(32,)) y = Dense(16, activation='softmax')(x) model = Model(x, y) ``` Note that even if eager execution is enabled, `Input` produces a symbolic tensor-like object (i.e. a placeholder). This symbolic tensor-like object can be used with lower-level TensorFlow ops that take tensors as inputs, as such: ```python x = Input(shape=(32,)) y = tf.square(x) # This op will be treated like a layer model = Model(x, y) ``` (This behavior does not work for higher-order TensorFlow APIs such as control flow and being directly watched by a `tf.GradientTape`). However, the resulting model will not track any variables that were used as inputs to TensorFlow ops. All variable usages must happen within Keras layers to make sure they will be tracked by the model's weights. The Keras Input can also create a placeholder from an arbitrary `tf.TypeSpec`, e.g: ```python x = Input(type_spec=tf.RaggedTensorSpec(shape=[None, None], dtype=tf.float32, ragged_rank=1)) y = x.values model = Model(x, y) ``` When passing an arbitrary `tf.TypeSpec`, it must represent the signature of an entire batch instead of just one example. Raises: ValueError: If both `sparse` and `ragged` are provided. ValueError: If both `shape` and (`batch_input_shape` or `batch_shape`) are provided. ValueError: If `shape`, `tensor` and `type_spec` are None. ValueError: If arguments besides `type_spec` are non-None while `type_spec` is passed. ValueError: if any unrecognized parameters are provided. z;Cannot set both sparse and ragged to True in a Keras input.)rrrrrr3rZ batch_shapeNz]Only provide the `shape` OR `batch_input_shape` argument to Input, not both at the same time.zPlease provide to Input a `shape` or a `tensor` or a `type_spec` argument. Note that `shape` does not include the batch dimension.zUnrecognized keyword arguments:r)rr2r) rr$r%updaterZ_inbound_nodesr!r)listlen) rrrrrZtensorrr3r4Zinput_layer_configrZ input_layerr!rrrInputs2e    rD)NNNNNNNN)r>Ztensorflow.python.distributerZtensorflow.python.frameworkrrrZtensorflow.python.kerasrZ"tensorflow.python.keras.distributerZtensorflow.python.keras.enginerr r r/Z*tensorflow.python.keras.saving.saved_modelr Ztensorflow.python.keras.utilsr Z tensorflow.python.util.tf_exportr rZLayerrrDrrrrs2             Z