def array(val, dtype=None, copy=True, ndmin=0): """Creates an ndarray with the contents of val. Args: val: array_like. Could be an ndarray, a Tensor or any object that can be converted to a Tensor using `tf.convert_to_tensor`. dtype: Optional, defaults to dtype of the `val`. The type of the resulting ndarray. Could be a python type, a NumPy type or a TensorFlow `DType`. copy: Determines whether to create a copy of the backing buffer. Since Tensors are immutable, a copy is made only if val is placed on a different device than the current one. Even if `copy` is False, a new Tensor may need to be built to satisfy `dtype` and `ndim`. This is used only if `val` is an ndarray or a Tensor. ndmin: The minimum rank of the returned array. Returns: An ndarray. """ if dtype: dtype = utils.to_tf_type(dtype) if isinstance(val, arrays.ndarray): result_t = val.data else: result_t = val if isinstance(result_t, tf.Tensor): # Copy only if copy=True and a copy would not otherwise be made to satisfy # dtype or ndmin. if (copy and (dtype is None or dtype == utils.array_dtype(val)) and val.ndim >= ndmin): # Note: In eager mode, a copy of `result_t` is made only if it is not on # the context device. result_t = tf.identity(result_t) if not isinstance(result_t, tf.Tensor): # Note: We don't just call tf.convert_to_tensor because, unlike NumPy, # TensorFlow prefers int32 and float32 over int64 and float64. So we compute # the NumPy type of `result_t` and create a tensor of that type instead. if not dtype: dtype = utils.array_dtype(result_t) result_t = tf.convert_to_tensor(result_t) result_t = tf.cast(result_t, dtype=dtype) elif dtype: result_t = utils.maybe_cast(result_t, dtype) ndims = len(result_t.shape) if ndmin > ndims: old_shape = list(result_t.shape) new_shape = [1 for _ in range(ndmin - ndims)] + old_shape result_t = tf.reshape(result_t, new_shape) return utils.tensor_to_ndarray(result_t)
def arange(start, stop=None, step=1, dtype=None): """Returns `step`-separated values in the range [start, stop). Args: start: Start of the interval. Included in the range. stop: End of the interval. If not specified, `start` is treated as 0 and `start` value is used as `stop`. If specified, it is not included in the range if `step` is integer. When `step` is floating point, it may or may not be included. step: The difference between 2 consecutive values in the output range. It is recommended to use `linspace` instead of using non-integer values for `step`. dtype: Optional. Type of the resulting ndarray. Could be a python type, a NumPy type or a TensorFlow `DType`. If not provided, the largest type of `start`, `stop`, `step` is used. Raises: ValueError: If step is zero. """ if not step: raise ValueError('step must be non-zero.') if dtype: dtype = utils.to_tf_type(dtype) else: dtype = utils.result_type( utils.array_dtype(start).as_numpy_dtype, utils.array_dtype(step).as_numpy_dtype) if stop is not None: dtype = utils.result_type(dtype, utils.array_dtype(stop).as_numpy_dtype) dtype = utils.to_tf_type(dtype) if step > 0 and ((stop is not None and start > stop) or (stop is None and start < 0)): return array([], dtype=dtype) if step < 0 and ((stop is not None and start < stop) or (stop is None and start > 0)): return array([], dtype=dtype) # TODO(srbs): There are some bugs when start or stop is float type and dtype # is integer type. return utils.tensor_to_ndarray( tf.cast(tf.range(start, limit=stop, delta=step), dtype=dtype))
def zeros_like(a, dtype=None): """Returns an array of zeros with the shape and type of the input array. Args: a: array_like. Could be an ndarray, a Tensor or any object that can be converted to a Tensor using `tf.convert_to_tensor`. dtype: Optional, defaults to dtype of the input array. The type of the resulting ndarray. Could be a python type, a NumPy type or a TensorFlow `DType`. Returns: An ndarray. """ if isinstance(a, arrays.ndarray): a = a.data if dtype is None: dtype = utils.array_dtype(a) else: dtype = utils.to_tf_type(dtype) return utils.tensor_to_ndarray(tf.zeros_like(a, dtype))
def full_like(a, fill_value, dtype=None): """Returns an array with same shape and dtype as `a` filled with `fill_value`. Args: a: array_like. Could be an ndarray, a Tensor or any object that can be converted to a Tensor using `tf.convert_to_tensor`. fill_value: array_like. Could be an ndarray, a Tensor or any object that can be converted to a Tensor using `tf.convert_to_tensor`. dtype: Optional, defaults to dtype of the `a`. The type of the resulting ndarray. Could be a python type, a NumPy type or a TensorFlow `DType`. Returns: An ndarray. Raises: ValueError: if `fill_value` can not be broadcast to shape `shape`. """ if not isinstance(a, arrays.ndarray): a = array(a, copy=False) dtype = dtype or utils.array_dtype(a) return full(a.shape, fill_value, dtype)