path: root/tensorflow/g3doc/api_docs/python/constant_op.md

<!-- This file is machine generated: DO NOT EDIT! -->

# Constants, Sequences, and Random Values
<!-- TOC-BEGIN This section is generated by neural network: DO NOT EDIT! -->
## Contents
* [Constant Value Tensors](#AUTOGENERATED-constant-value-tensors)
  * [tf.zeros(shape, dtype=tf.float32, name=None)](#zeros)
  * [tf.zeros_like(tensor, dtype=None, name=None)](#zeros_like)
  * [tf.ones(shape, dtype=tf.float32, name=None)](#ones)
  * [tf.ones_like(tensor, dtype=None, name=None)](#ones_like)
  * [tf.fill(dims, value, name=None)](#fill)
  * [tf.constant(value, dtype=None, shape=None, name='Const')](#constant)
* [Sequences](#AUTOGENERATED-sequences)
  * [tf.linspace(start, stop, num, name=None)](#linspace)
  * [tf.range(start, limit, delta=1, name='range')](#range)
* [Random Tensors](#AUTOGENERATED-random-tensors)
  * [Examples:](#AUTOGENERATED-examples-)
  * [tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)](#random_normal)
  * [tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)](#truncated_normal)
  * [tf.random_uniform(shape, minval=0.0, maxval=1.0, dtype=tf.float32, seed=None, name=None)](#random_uniform)
  * [tf.random_shuffle(value, seed=None, name=None)](#random_shuffle)
  * [tf.set_random_seed(seed)](#set_random_seed)


<!-- TOC-END This section was generated by neural network, THANKS FOR READING! -->

## Constant Value Tensors <div class="md-anchor" id="AUTOGENERATED-constant-value-tensors">{#AUTOGENERATED-constant-value-tensors}</div>

TensorFlow provides several operations that you can use to generate constants.

- - -

### tf.zeros(shape, dtype=tf.float32, name=None) <div class="md-anchor" id="zeros">{#zeros}</div>

Creates a tensor with all elements set to zero.

This operation returns a tensor of type `dtype` with shape `shape` and
all elements set to zero.

For example:

```python
tf.zeros([3, 4], int32) ==> [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
```

##### Args:


*  <b>shape</b>: Either a list of integers, or a 1-D `Tensor` of type `int32`.
*  <b>dtype</b>: The type of an element in the resulting `Tensor`.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A `Tensor` with all elements set to zero.


- - -

### tf.zeros_like(tensor, dtype=None, name=None) <div class="md-anchor" id="zeros_like">{#zeros_like}</div>

Creates a tensor with all elements set to zero.

Given a single tensor (`tensor`), this operation returns a tensor of the
same type and shape as `tensor` with all elements set to zero. Optionally,
you can use `dtype` to specify a new type for the returned tensor.

For example:

```python
# 'tensor' is [[1, 2, 3], [4, 5, 6]]
tf.zeros_like(tensor) ==> [[0, 0, 0], [0, 0, 0]]
```

##### Args:


*  <b>tensor</b>: A `Tensor`.
*  <b>dtype</b>: A type for the returned `Tensor`. Must be `float32`, `float64`,
  `int8`, `int16`, `int32`, `int64`, `uint8`, or `complex64`.

*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A `Tensor` with all elements set to zero.



- - -

### tf.ones(shape, dtype=tf.float32, name=None) <div class="md-anchor" id="ones">{#ones}</div>

Creates a tensor with all elements set to 1.

This operation returns a tensor of type `dtype` with shape `shape` and all
elements set to 1.

For example:

```python
tf.ones([2, 3], int32) ==> [[1, 1, 1], [1, 1, 1]]
```

##### Args:


*  <b>shape</b>: Either a list of integers, or a 1-D `Tensor` of type `int32`.
*  <b>dtype</b>: The type of an element in the resulting `Tensor`.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A `Tensor` with all elements set to 1.


- - -

### tf.ones_like(tensor, dtype=None, name=None) <div class="md-anchor" id="ones_like">{#ones_like}</div>

Creates a tensor with all elements set to 1.

Given a single tensor (`tensor`), this operation returns a tensor of the same
type and shape as `tensor` with all elements set to 1. Optionally, you can
specify a new type (`dtype`) for the returned tensor.

For example:

```python
# 'tensor' is [[1, 2, 3], [4, 5, 6]]
tf.ones_like(tensor) ==> [[1, 1, 1], [1, 1, 1]]
```

##### Args:


*  <b>tensor</b>: A `Tensor`.
*  <b>dtype</b>: A type for the returned `Tensor`. Must be `float32`, `float64`,
  `int8`, `int16`, `int32`, `int64`, `uint8`, or `complex64`.

*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A `Tensor` with all elements set to 1.



- - -

### tf.fill(dims, value, name=None) <div class="md-anchor" id="fill">{#fill}</div>

Creates a tensor filled with a scalar value.

This operation creates a tensor of shape `dims` and fills it with `value`.

For example:

```prettyprint
# output tensor shape needs to be [2, 3]
# so 'dims' is [2, 3]
fill(dims, 9) ==> [[9, 9, 9]
                   [9, 9, 9]]
```

##### Args:


*  <b>dims</b>: A `Tensor` of type `int32`.
    1-D. Represents the shape of the output tensor.
*  <b>value</b>: A `Tensor`. 0-D (scalar). Value to fill the returned tensor.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A `Tensor`. Has the same type as `value`.



- - -

### tf.constant(value, dtype=None, shape=None, name='Const') <div class="md-anchor" id="constant">{#constant}</div>

Creates a constant tensor.

 The resulting tensor is populated with values of type `dtype`, as
 specified by arguments `value` and (optionally) `shape` (see examples
 below).

 The argument `value` can be a constant value, or a list of values of type
 `dtype`. If `value` is a list, then the length of the list must be less
 than or equal to the number of elements implied by the `shape` argument (if
 specified). In the case where the list length is less than the number of
 elements specified by `shape`, the last element in the list will be used
 to fill the remaining entries.

 The argument `shape` is optional. If present, it specifies the dimensions
 of the resulting tensor. If not present, then the tensor is a scalar (0-D)
 if `value` is a scalar, or 1-D otherwise.

 If the argument `dtype` is not specified, then the type is inferred from
 the type of `value`.

 For example:

 ```python
 # Constant 1-D Tensor populated with value list.
 tensor = tf.constant([1, 2, 3, 4, 5, 6, 7]) => [1 2 3 4 5 6 7]

 # Constant 2-D tensor populated with scalar value -1.
 tensor = tf.constant(-1.0, shape=[2, 3]) => [[-1. -1. -1.]
                                              [-1. -1. -1.]]
 ```

##### Args:


*  <b>value</b>: A constant value (or list) of output type `dtype`.


*  <b>dtype</b>: The type of the elements of the resulting tensor.


*  <b>shape</b>: Optional dimensions of resulting tensor.


*  <b>name</b>: Optional name for the tensor.

##### Returns:

  A Constant Tensor.



## Sequences <div class="md-anchor" id="AUTOGENERATED-sequences">{#AUTOGENERATED-sequences}</div>

- - -

### tf.linspace(start, stop, num, name=None) <div class="md-anchor" id="linspace">{#linspace}</div>

Generates values in an interval.

A sequence of `num` evenly-spaced values are generated beginning at `start`.
If `num > 1`, the values in the sequence increase by `stop - start / num - 1`,
so that the last one is exactly `stop`.

For example:

```
tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]
```

##### Args:


*  <b>start</b>: A `Tensor`. Must be one of the following types: `float32`, `float64`.
    First entry in the range.
*  <b>stop</b>: A `Tensor`. Must have the same type as `start`.
    Last entry in the range.
*  <b>num</b>: A `Tensor` of type `int32`. Number of values to generate.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A `Tensor`. Has the same type as `start`. 1-D. The generated values.



- - -

### tf.range(start, limit, delta=1, name='range') <div class="md-anchor" id="range">{#range}</div>

Creates a sequence of integers.

This operation creates a sequence of integers that begins at `start` and
extends by increments of `delta` up to but not including `limit`.

For example:

```
# 'start' is 3
# 'limit' is 18
# 'delta' is 3
tf.range(start, limit, delta) ==> [3, 6, 9, 12, 15]
```

##### Args:


*  <b>start</b>: A 0-D (scalar) of type `int32`. First entry in sequence.
*  <b>limit</b>: A 0-D (scalar) of type `int32`. Upper limit of sequence,
    exclusive.
*  <b>delta</b>: A 0-D `Tensor` (scalar) of type `int32`. Optional. Default is 1.
    Number that increments `start`.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  An 1-D `int32` `Tensor`.



## Random Tensors <div class="md-anchor" id="AUTOGENERATED-random-tensors">{#AUTOGENERATED-random-tensors}</div>

TensorFlow has several ops that create random tensors with different
distributions.  The random ops are stateful, and create new random values each
time they are evaluated.

The `seed` keyword argument in these functions acts in conjunction with
the graph-level random seed. Changing either the graph-level seed using
[`set_random_seed`](constant_op.md#set_random_seed) or the op-level seed
will change the underlying seed of these operations. Setting neither graph-level
nor op-level seed, results in a random seed for all operations.
See [`set_random_seed`](constant_op.md#set_random_seed) for details on the
interaction between operation-level and graph-level random seeds.

### Examples: <div class="md-anchor" id="AUTOGENERATED-examples-">{#AUTOGENERATED-examples-}</div>

```python
# Create a tensor of shape [2, 3] consisting of random normal values, with mean
# -1 and standard deviation 4.
norm = tf.random_normal([2, 3], mean=-1, stddev=4)

# Shuffle the first dimension of a tensor
c = tf.constant([[1, 2], [3, 4], [5, 6]])
shuff = tf.random_shuffle(c)

# Each time we run these ops, different results are generated
sess = tf.Session()
print sess.run(norm)
print sess.run(norm)

# Set an op-level seed to generate repeatable sequences across sessions.
c = tf.constant([[1, 2], [3, 4], [5, 6]])
sess = tf.Session()
norm = tf.random_normal(c, seed=1234)
print sess.run(norm)
print sess.run(norm)
```

Another common use of random values is the intialization of variables. Also see
the [Variables How To](../../how_tos/variables/index.md).

```python
# Use random uniform values in [0, 1) as the initializer for a variable of shape
# [2, 3]. The default type is float32.
var = tf.Variable(tf.random_uniform([2, 3]), name="var")
init = tf.initialize_all_variables()

sess = tf.Session()
sess.run(init)
print sess.run(var)
```

- - -

### tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None) <div class="md-anchor" id="random_normal">{#random_normal}</div>

Outputs random values from a normal distribution.

##### Args:


*  <b>shape</b>: A 1-D integer Tensor or Python array. The shape of the output tensor.
*  <b>mean</b>: A 0-D Tensor or Python value of type `dtype`. The mean of the normal
    distribution.
*  <b>stddev</b>: A 0-D Tensor or Python value of type `dtype`. The standard deviation
    of the normal distribution.
*  <b>dtype</b>: The type of the output.
*  <b>seed</b>: A Python integer. Used to create a random seed for the distribution.
    See [`set_random_seed`](constant_op.md#set_random_seed) for behavior.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A tensor of the specified shape filled with random normal values.


- - -

### tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None) <div class="md-anchor" id="truncated_normal">{#truncated_normal}</div>

Outputs random values from a truncated normal distribution.

The generated values follow a normal distribution with specified mean and
standard deviation, except that values whose magnitude is more than 2 standard
deviations from the mean are dropped and re-picked.

##### Args:


*  <b>shape</b>: A 1-D integer Tensor or Python array. The shape of the output tensor.
*  <b>mean</b>: A 0-D Tensor or Python value of type `dtype`. The mean of the
    truncated normal distribution.
*  <b>stddev</b>: A 0-D Tensor or Python value of type `dtype`. The standard deviation
    of the truncated normal distribution.
*  <b>dtype</b>: The type of the output.
*  <b>seed</b>: A Python integer. Used to create a random seed for the distribution.
    See [`set_random_seed`](constant_op.md#set_random_seed) for behavior.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A tensor of the specified shape filled with random truncated normal values.


- - -

### tf.random_uniform(shape, minval=0.0, maxval=1.0, dtype=tf.float32, seed=None, name=None) <div class="md-anchor" id="random_uniform">{#random_uniform}</div>

Outputs random values from a uniform distribution.

The generated values follow a uniform distribution in the range
`[minval, maxval)`. The lower bound `minval` is included in the range, while
the upper bound `maxval` is excluded.

##### Args:


*  <b>shape</b>: A 1-D integer Tensor or Python array. The shape of the output tensor.
*  <b>minval</b>: A 0-D Tensor or Python value of type `dtype`. The lower bound on the
    range of random values to generate.
*  <b>maxval</b>: A 0-D Tensor or Python value of type `dtype`. The upper bound on
    the range of random values to generate.
*  <b>dtype</b>: The type of the output.
*  <b>seed</b>: A Python integer. Used to create a random seed for the distribution.
    See [`set_random_seed`](constant_op.md#set_random_seed) for behavior.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A tensor of the specified shape filled with random uniform values.


- - -

### tf.random_shuffle(value, seed=None, name=None) <div class="md-anchor" id="random_shuffle">{#random_shuffle}</div>

Randomly shuffles a tensor along its first dimension.

The tensor is shuffled along dimension 0, such that each `value[j]` is mapped
to one and only one `output[i]`. For example, a mapping that might occur for a
3x2 tensor is:

```python
[[1, 2],       [[5, 6],
 [3, 4],  ==>   [1, 2],
 [5, 6]]        [3, 4]]
```

##### Args:


*  <b>value</b>: A Tensor to be shuffled.
*  <b>seed</b>: A Python integer. Used to create a random seed for the distribution.
    See [`set_random_seed`](constant_op.md#set_random_seed) for behavior.
*  <b>name</b>: A name for the operation (optional).

##### Returns:

  A tensor of same shape and type as `value`, shuffled along its first
  dimension.


- - -

### tf.set_random_seed(seed) <div class="md-anchor" id="set_random_seed">{#set_random_seed}</div>

Sets the graph-level random seed.

Operations that rely on a random seed actually derive it from two seeds:
the graph-level and operation-level seeds. This sets the graph-level seed.

Its interactions with operation-level seeds is as follows:

  1. If neither the graph-level nor the operation seed is set:
    A random seed is used for this op.
  2. If the graph-level seed is set, but the operation seed is not:
    The system deterministically picks an operation seed in conjunction
    with the graph-level seed so that it gets a unique random sequence.
  3. If the graph-level seed is not set, but the operation seed is set:
    A default graph-level seed and the specified operation seed are used to
    determine the random sequence.
  4. If both the graph-level and the operation seed are set:
    Both seeds are used in conjunction to determine the random sequence.

To illustrate the user-visible effects, consider these examples:

To generate different sequences across sessions, set neither
graph-level nor op-level seeds:

```python
a = tf.random_uniform([1])
b = tf.random_normal([1])

print "Session 1"
with tf.Session() as sess1:
  print sess1.run(a)  # generates 'A1'
  print sess1.run(a)  # generates 'A2'
  print sess1.run(b)  # generates 'B1'
  print sess1.run(b)  # generates 'B2'

print "Session 2"
with tf.Session() as sess2:
  print sess2.run(a)  # generates 'A3'
  print sess2.run(a)  # generates 'A4'
  print sess2.run(b)  # generates 'B3'
  print sess2.run(b)  # generates 'B4'
```

To generate the same repeatable sequence for an op across sessions, set the
seed for the op:

```python
a = tf.random_uniform([1], seed=1)
b = tf.random_normal([1])

# Repeatedly running this block with the same graph will generate the same
# sequence of values for 'a', but different sequences of values for 'b'.
print "Session 1"
with tf.Session() as sess1:
  print sess1.run(a)  # generates 'A1'
  print sess1.run(a)  # generates 'A2'
  print sess1.run(b)  # generates 'B1'
  print sess1.run(b)  # generates 'B2'

print "Session 2"
with tf.Session() as sess2:
  print sess2.run(a)  # generates 'A1'
  print sess2.run(a)  # generates 'A2'
  print sess2.run(b)  # generates 'B3'
  print sess2.run(b)  # generates 'B4'
```

To make the random sequences generated by all ops be repeatable across
sessions, set a graph-level seed:

```python
tf.set_random_seed(1234)
a = tf.random_uniform([1])
b = tf.random_normal([1])

# Repeatedly running this block with the same graph will generate different
# sequences of 'a' and 'b'.
print "Session 1"
with tf.Session() as sess1:
  print sess1.run(a)  # generates 'A1'
  print sess1.run(a)  # generates 'A2'
  print sess1.run(b)  # generates 'B1'
  print sess1.run(b)  # generates 'B2'

print "Session 2"
with tf.Session() as sess2:
  print sess2.run(a)  # generates 'A1'
  print sess2.run(a)  # generates 'A2'
  print sess2.run(b)  # generates 'B1'
  print sess2.run(b)  # generates 'B2'
```

##### Args:


*  <b>seed</b>: integer.