LostTech.TensorFlow : API Documentation

Type tf.keras

Namespace tensorflow

Methods

Properties

Public static methods

object Input(int shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(int shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(int shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(int shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(int shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(int shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(int shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(TensorShape shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
TensorShape 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, DType dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, object tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(IEnumerable<int> shape, Nullable<int> batch_size, string name, dtype dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
IEnumerable<int> 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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 dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(int shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, IEnumerable<IGraphNodeBase> tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IEnumerable<IGraphNodeBase> tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input(int shape, Nullable<int> batch_size, string name, PythonClassContainer dtype, Nullable<bool> sparse, IGraphNodeBase tensor, Nullable<bool> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
int 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.
Nullable<int> batch_size
optional static batch size (integer).
string 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.
PythonClassContainer dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
Nullable<bool> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
IGraphNodeBase tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
Nullable<bool> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

object Input_dyn(object shape, object batch_size, object name, object dtype, ImplicitContainer<T> sparse, object tensor, ImplicitContainer<T> ragged, IDictionary<string, object> kwargs)

`Input()` is used to instantiate a Keras tensor.

A Keras tensor is a tensor object from the underlying backend (Theano or TensorFlow), 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)`

The added Keras attribute is: `_keras_history`: Last layer applied to the tensor. the entire layer graph is retrievable from that layer, recursively.
Parameters
object 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.
object batch_size
optional static batch size (integer).
object 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.
object dtype
The data type expected by the input, as a string (`float32`, `float64`, `int32`...)
ImplicitContainer<T> sparse
A boolean specifying whether the placeholder to be created is sparse. Only one of 'ragged' and 'sparse' can be True.
object tensor
Optional existing tensor to wrap into the `Input` layer. If set, the layer will not create a placeholder tensor.
ImplicitContainer<T> 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 https://www.tensorflow.org/guide/ragged_tensors.
IDictionary<string, object> kwargs
deprecated arguments support. Supports `batch_shape` and `batch_input_shape`.
Returns
object
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 (i.e. a placeholder). This symbolic tensor can be used with other TensorFlow ops, as such:

```python x = Input(shape=(32,)) y = tf.square(x) ```

Public properties

PythonFunctionContainer Input_fn get;