Creation

Creation (basic)

empty staticmethod

empty(
    *shape,
    device: str | tuple[str, ...] | None = None,
    dtype: DTypeLike | None = None,
    **kwargs
) -> Tensor

Creates an empty tensor with the given shape.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

t = Tensor.empty(2, 3)
print(t.shape)

(2, 3)

Source code in tinygrad/tensor.py

@staticmethod
def empty(*shape, device:str|tuple[str, ...]|None=None, dtype:DTypeLike|None=None, **kwargs) -> Tensor:
  """
  Creates an empty tensor with the given shape.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor.empty(2, 3)
  print(t.shape)
  ```
  """
  return Tensor(UOp.empty(argfix(*shape), dtype, device), **kwargs)

zeros classmethod

zeros(*shape, **kwargs) -> Self

Creates a tensor with the given shape, filled with zeros.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

print(Tensor.zeros(2, 3).numpy())

[[0. 0. 0.]
 [0. 0. 0.]]

print(Tensor.zeros(2, 3, dtype=dtypes.int32).numpy())

[[0 0 0]
 [0 0 0]]

Source code in tinygrad/mixin/__init__.py

@classmethod
def zeros(cls, *shape, **kwargs) -> Self:
  """
  Creates a tensor with the given shape, filled with zeros.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.zeros(2, 3).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.zeros(2, 3, dtype=dtypes.int32).numpy())
  ```
  """
  return cls.full(argfix(*shape), 0.0, **kwargs)

ones classmethod

ones(*shape, **kwargs) -> Self

Creates a tensor with the given shape, filled with ones.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

print(Tensor.ones(2, 3).numpy())

[[1. 1. 1.]
 [1. 1. 1.]]

print(Tensor.ones(2, 3, dtype=dtypes.int32).numpy())

[[1 1 1]
 [1 1 1]]

Source code in tinygrad/mixin/__init__.py

@classmethod
def ones(cls, *shape, **kwargs) -> Self:
  """
  Creates a tensor with the given shape, filled with ones.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.ones(2, 3).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.ones(2, 3, dtype=dtypes.int32).numpy())
  ```
  """
  return cls.full(argfix(*shape), 1.0, **kwargs)

full classmethod

full(
    shape: tuple[sint, ...], fill_value: ConstType, **kwargs
) -> Self

Creates a tensor with the given shape, filled with the given value.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

print(Tensor.full((2, 3), 42).numpy())

[[42 42 42]
 [42 42 42]]

print(Tensor.full((2, 3), False).numpy())

[[False False False]
 [False False False]]

Source code in tinygrad/mixin/__init__.py

@classmethod
def full(cls, shape:tuple[sint, ...], fill_value:ConstType, **kwargs) -> Self:
  """
  Creates a tensor with the given shape, filled with the given value.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.full((2, 3), 42).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.full((2, 3), False).numpy())
  ```
  """
  return cls.unique_const(fill_value, **kwargs).reshape((1,)*len(new_shape := argfix(shape))).expand(new_shape)

arange classmethod

arange(start, stop=None, step=1, **kwargs) -> Self

Returns a 1-D tensor of size ceil((stop - start) / step) with values from [start, stop), with spacing between values given by step.

If stop is not specified, values are generated from [0, start) with the given step.

If stop is specified, values are generated from [start, stop) with the given step.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

print(Tensor.arange(5).numpy())

[0 1 2 3 4]

print(Tensor.arange(5, 10).numpy())

[5 6 7 8 9]

print(Tensor.arange(5, 10, 2).numpy())

[5 7 9]

print(Tensor.arange(5.5, 10, 2).numpy())

[5.5 7.5 9.5]

Source code in tinygrad/mixin/__init__.py

@classmethod
def arange(cls, start, stop=None, step=1, **kwargs) -> Self:
  """
  Returns a 1-D tensor of size `ceil((stop - start) / step)` with values from `[start, stop)`, with spacing between values given by `step`.

  If `stop` is not specified, values are generated from `[0, start)` with the given `step`.

  If `stop` is specified, values are generated from `[start, stop)` with the given `step`.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.arange(5).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.arange(5, 10).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.arange(5, 10, 2).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.arange(5.5, 10, 2).numpy())
  ```
  """
  if stop is None: stop, start = start, 0
  dtype = kwargs.pop("dtype", dtypes.default_float if any(isinstance(x, float) for x in (start, stop, step)) else dtypes.default_int)
  lo, hi = (start, stop-step) if step > 0 else (stop-step, start)
  if lo < (dt:=to_dtype(dtype)).min or dt.max < hi: raise OverflowError(f"arange [{start}, {stop}) is not representable in dtype {dtype}")
  # NOTE: this matches numpy, torch raises RuntimeError if stop-start and step have different signs
  if (output_len:=ceildiv(stop-start, step)) <= 0: return cls.full((0,), 0, dtype=dtype, **kwargs)
  return (cls.full((output_len,), step, dtype=dtype, **kwargs)._cumalu(0, Ops.ADD) + (start - step)).cast(dtype)

linspace classmethod

linspace(
    start: int | float,
    stop: int | float,
    steps: int,
    **kwargs
) -> Self

Returns a 1-D tensor of steps evenly spaced values from start to stop, inclusive.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

print(Tensor.linspace(0, 10, 5).numpy())

[ 0.   2.5  5.   7.5 10. ]

print(Tensor.linspace(-1, 1, 5).numpy())

[-1.  -0.5  0.   0.5  1. ]

Source code in tinygrad/mixin/__init__.py

@classmethod
def linspace(cls, start:int|float, stop:int|float, steps:int, **kwargs) -> Self:
  """
  Returns a 1-D tensor of `steps` evenly spaced values from `start` to `stop`, inclusive.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.linspace(0, 10, 5).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.linspace(-1, 1, 5).numpy())
  ```
  """
  if steps < 0: raise ValueError("number of steps must be non-negative")
  if (dtype := to_dtype(kwargs.pop("dtype", dtypes.default_float))) == dtypes.bool: raise ValueError("linspace with bool dtype is not supported")
  if steps == 1: return cls.full((1,), start, dtype=dtype, **kwargs)
  return (start + cls.arange(steps, dtype=dtypes.default_float, **kwargs) * ((stop - start) / (steps - 1))).cast(dtype)

eye classmethod

eye(
    n: int,
    m: int | None = None,
    dtype=None,
    device=None,
    requires_grad: bool | None = None,
) -> Tensor

Returns a 2-D tensor with n rows and m columns, with ones on the diagonal and zeros elsewhere.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

print(Tensor.eye(3).numpy())

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

print(Tensor.eye(2, 4).numpy())

[[1. 0. 0. 0.]
 [0. 1. 0. 0.]]

Source code in tinygrad/tensor.py

@classmethod
def eye(cls, n:int, m:int|None=None, dtype=None, device=None, requires_grad:bool|None=None) -> Tensor:
  """
  Returns a 2-D tensor with `n` rows and `m` columns, with ones on the diagonal and zeros elsewhere.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.eye(3).numpy())
  ```

  ```python exec="true" source="above" session="tensor" result="python"
  print(Tensor.eye(2, 4).numpy())
  ```
  """
  return super().eye(n, m, dtype, device).requires_grad_(requires_grad)

full_like

full_like(
    fill_value: ConstType,
    dtype=None,
    device=None,
    requires_grad=None,
) -> Tensor

Creates a tensor with the same shape as self, filled with the given value. If dtype is not specified, the dtype of self is used.

You can pass in the device keyword argument to control device of the tensor.

t = Tensor.ones(2, 3)
print(Tensor.full_like(t, 42).numpy())

[[42. 42. 42.]
 [42. 42. 42.]]

Source code in tinygrad/tensor.py

def full_like(self, fill_value:ConstType, dtype=None, device=None, requires_grad=None) -> Tensor:
  """
  Creates a tensor with the same shape as `self`, filled with the given value.
  If `dtype` is not specified, the dtype of `self` is used.

  You can pass in the `device` keyword argument to control device of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor.ones(2, 3)
  print(Tensor.full_like(t, 42).numpy())
  ```
  """
  if device is not None:
    if isinstance(self.device, tuple): raise RuntimeError("cannot specify `device` on `full_like` of a multi device tensor")
    return Tensor.full(self.shape, fill_value, dtype=dtype or self.dtype, device=device).requires_grad_(requires_grad)
  if requires_grad:
    return Tensor.full(self.shape, fill_value, dtype=dtype or self.dtype, device=self.device).requires_grad_(requires_grad)
  return super().full_like(fill_value, dtype)

zeros_like

zeros_like(**kwargs) -> Self

Creates a tensor with the same shape as self, filled with zeros.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor.

t = Tensor.ones(2, 3)
print(Tensor.zeros_like(t).numpy())

[[0. 0. 0.]
 [0. 0. 0.]]

Source code in tinygrad/mixin/creation.py

def zeros_like(self, **kwargs) -> Self:
  """
  Creates a tensor with the same shape as `self`, filled with zeros.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor.ones(2, 3)
  print(Tensor.zeros_like(t).numpy())
  ```
  """
  return self.full_like(0, **kwargs)

ones_like

ones_like(**kwargs) -> Self

Creates a tensor with the same shape as self, filled with ones.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor.

t = Tensor.zeros(2, 3)
print(Tensor.ones_like(t).numpy())

[[1. 1. 1.]
 [1. 1. 1.]]

Source code in tinygrad/mixin/creation.py

def ones_like(self, **kwargs) -> Self:
  """
  Creates a tensor with the same shape as `self`, filled with ones.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor.zeros(2, 3)
  print(Tensor.ones_like(t).numpy())
  ```
  """
  return self.full_like(1, **kwargs)

Creation (external)

from_blob staticmethod

from_blob(
    ptr: int, shape: tuple[int, ...], **kwargs
) -> Tensor

Exposes the pointer as a Tensor without taking ownership of the original data. The pointer must remain valid for the entire lifetime of the created Tensor.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Source code in tinygrad/tensor.py

@staticmethod
def from_blob(ptr:int, shape:tuple[int, ...], **kwargs) -> Tensor:
  """
  Exposes the pointer as a Tensor without taking ownership of the original data.
  The pointer must remain valid for the entire lifetime of the created Tensor.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.
  """
  r = Tensor.empty(*shape, **kwargs)
  assert isinstance(r.device, str)
  cast(Buffer, r.uop.buffer).allocate(external_ptr=ptr)
  return r

from_url staticmethod

from_url(
    url: str, gunzip: bool = False, **kwargs
) -> Tensor

Creates a Tensor from a URL.

This is the preferred way to access Internet resources. It currently returns a DISK Tensor, but in the future it may return an HTTP Tensor. This also will soon become lazy (when possible) and not print progress without DEBUG.

The gunzip flag will gzip extract the resource and return an extracted Tensor.

Source code in tinygrad/tensor.py

@staticmethod
def from_url(url:str, gunzip:bool=False, **kwargs) -> Tensor:
  """
  Creates a Tensor from a URL.

  This is the preferred way to access Internet resources.
  It currently returns a DISK Tensor, but in the future it may return an HTTP Tensor.
  This also will soon become lazy (when possible) and not print progress without DEBUG.

  The `gunzip` flag will gzip extract the resource and return an extracted Tensor.
  """
  return Tensor(fetch(url, gunzip=gunzip), **kwargs)

Creation (random)

manual_seed staticmethod

manual_seed(seed=0) -> None

Sets the seed for random operations.

Tensor.manual_seed(42)
print(Tensor.rand(5).numpy())
print(Tensor.rand(5).numpy())

[0.381  0.0098 0.1128 0.1177 0.5054]
[0.8984 0.9686 0.5969 0.9117 0.9869]

Tensor.manual_seed(42)  # reset to the same seed
print(Tensor.rand(5).numpy())
print(Tensor.rand(5).numpy())

[0.381  0.0098 0.1128 0.1177 0.5054]
[0.8984 0.9686 0.5969 0.9117 0.9869]

Source code in tinygrad/tensor.py

@staticmethod
def manual_seed(seed=0) -> None:
  """
  Sets the seed for random operations.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.rand(5).numpy())
  print(Tensor.rand(5).numpy())
  ```
  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)  # reset to the same seed
  print(Tensor.rand(5).numpy())
  print(Tensor.rand(5).numpy())
  ```
  """
  Tensor._seed, Tensor._device_seeds, Tensor._device_rng_counters = seed, {}, {}

rand staticmethod

rand(
    *shape,
    device: str | None = None,
    dtype: DTypeLike | None = None,
    contiguous: bool = True,
    **kwargs
) -> Tensor

Creates a tensor with the given shape, filled with random values from a uniform distribution over the interval [0, 1).

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
t = Tensor.rand(2, 3)
print(t.numpy())

[[0.381  0.0098 0.1128]
 [0.1177 0.5054 0.3721]]

Source code in tinygrad/tensor.py

@staticmethod
def rand(*shape, device:str|None=None, dtype:DTypeLike|None=None, contiguous:bool=True, **kwargs) -> Tensor:
  """
  Creates a tensor with the given shape, filled with random values from a uniform distribution over the interval `[0, 1)`.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  t = Tensor.rand(2, 3)
  print(t.numpy())
  ```
  """
  dt = to_dtype(dtype or dtypes.default_float)
  if not dtypes.is_float(dt): raise ValueError(f"rand only supports float dtypes, got {dt}")
  if not all_int(shape:=argfix(*shape)) or not all(s >= 0 for s in shape): raise ValueError(f"invalid input {shape=}")
  if device is not None and not isinstance(device, str): raise ValueError(f"rand only supports single device, got {device=}")
  device = cast(str, canonicalize_device(device))

  # if shape has 0, return zero tensor
  if (numel := prod(shape)) == 0: return Tensor.zeros(shape, device=device, dtype=dt, **kwargs)
  num = ceildiv(numel * dt.itemsize, 4)

  # generate per device seeds and rng counter if we haven't seen this device yet
  if device not in Tensor._device_seeds:
    Tensor._device_seeds[device] = Tensor(
      [int.from_bytes(hashlib.sha256(len(Tensor._device_seeds).to_bytes(4, "big")).digest(), "big"), Tensor._seed],
      device=device, dtype=dtypes.uint32, requires_grad=False)
    Tensor._device_rng_counters[device] = Tensor([0, 0], device=device, dtype=dtypes.uint32, requires_grad=False).contiguous()

  # increment rng counter for devices
  new_low = Tensor._device_rng_counters[device][0:1] + (num & 0xffffffff)
  new_high = Tensor._device_rng_counters[device][1:2] + (num >> 32) + (new_low < Tensor._device_rng_counters[device][0]).cast(dtypes.uint32)
  Tensor._device_rng_counters[device].assign(new_low.cat(new_high))

  low = Tensor._device_rng_counters[device][0:1] - (num & 0xffffffff)
  high = Tensor._device_rng_counters[device][1:2] - (num >> 32) - (Tensor._device_rng_counters[device][0] < (num & 0xffffffff)).cast(dtypes.uint32)
  bits = Tensor.random_bits(Tensor._device_seeds[device], low.cat(high), num)

  # bitcast to uint with same number of bits
  _, nmant = dtypes.finfo(dt)
  uint_dtype = {1: dtypes.uint8, 2: dtypes.uint16, 4: dtypes.uint32, 8: dtypes.uint64}[dt.itemsize]
  bits = bits.bitcast(uint_dtype)
  # only randomize the mantissa bits and set the exponent to 1
  one = Tensor.ones_like(bits, device=bits.device, dtype=dt).bitcast(uint_dtype)
  bits = bits.rshift(dt.bitsize - nmant).bitwise_or(one)
  # bitcast back to the original dtype and reshape
  out = bits.bitcast(dt)[:numel].sub(1).reshape(shape).requires_grad_(kwargs.get("requires_grad"))
  return out.contiguous() if contiguous else out

rand_like

rand_like(**kwargs) -> Tensor

Creates a tensor with the same shape and sharding as self, filled with random values from a uniform distribution over the interval [0, 1).

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

t = Tensor.ones(2, 3)
print(Tensor.rand_like(t).numpy())

[[0.2103 0.611  0.1345]
 [0.0131 0.368  0.9245]]

Source code in tinygrad/tensor.py

def rand_like(self, **kwargs) -> Tensor:
  """
  Creates a tensor with the same shape and sharding as `self`, filled with random values from a uniform distribution over the interval `[0, 1)`.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor.ones(2, 3)
  print(Tensor.rand_like(t).numpy())
  ```
  """
  if isinstance(self.device, tuple): return self._multi_like(Tensor.rand, **kwargs)
  return Tensor.rand(*self.shape, device=kwargs.pop("device", self.device), dtype=kwargs.pop("dtype", self.dtype), **kwargs)

randn staticmethod

randn(
    *shape,
    dtype: DTypeLike | None = None,
    requires_grad: bool | None = None,
    **kwargs
) -> Tensor

Creates a tensor with the given shape, filled with random values from a normal distribution with mean 0 and standard deviation 1. If dtype is not specified, the default type is used.

You can pass in the device keyword argument to control device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
print(Tensor.randn(2, 3).numpy())

[[ 1.9576 -0.1859  1.6404]
 [-0.7647 -0.8695 -0.4379]]

Source code in tinygrad/tensor.py

@staticmethod
def randn(*shape, dtype:DTypeLike|None=None, requires_grad:bool|None=None, **kwargs) -> Tensor:
  """
  Creates a tensor with the given shape, filled with random values from a normal distribution with mean `0` and standard deviation `1`.
  If `dtype` is not specified, the default type is used.

  You can pass in the `device` keyword argument to control device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.randn(2, 3).numpy())
  ```
  """
  return Tensor.empty(*shape, **kwargs).randn_like(dtype=dtype, requires_grad=requires_grad)

randn_like

randn_like(
    dtype: DTypeLike | None = None,
    requires_grad: bool | None = None,
    **kwargs
) -> Tensor

Creates a tensor with the same shape and sharding as self, filled with random values from a normal distribution with mean 0 and variance 1.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

t = Tensor.ones(2, 3)
print(Tensor.randn_like(t).numpy())

[[-0.7382  1.5164 -0.3065]
 [-0.7862  0.5411 -0.4394]]

Source code in tinygrad/tensor.py

def randn_like(self, dtype:DTypeLike|None=None, requires_grad:bool|None=None, **kwargs) -> Tensor:
  """
  Creates a tensor with the same shape and sharding as `self`, filled with random values from a normal distribution with mean 0 and variance 1.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  t = Tensor.ones(2, 3)
  print(Tensor.randn_like(t).numpy())
  ```
  """
  src = self.stack(self).rand_like(**{**kwargs, "dtype": dtypes.float32})
  # https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform
  return (src[0].mul(2*math.pi).cos().mul((1 - src[1]).log().mul(-2).sqrt()).cast(dtype or self.dtype)).requires_grad_(requires_grad)

randint staticmethod

randint(
    *shape, low=0, high=10, dtype=int32, **kwargs
) -> Tensor

Creates a tensor with the given shape, filled with random integer values generated uniformly from the interval [low, high). If dtype is not specified, the default type is used.

You can pass in the device keyword argument to control device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
print(Tensor.randint(2, 3, low=5, high=10).numpy())

[[6 5 5]
 [5 7 6]]

Source code in tinygrad/tensor.py

@staticmethod
def randint(*shape, low=0, high=10, dtype=dtypes.int32, **kwargs) -> Tensor:
  """
  Creates a tensor with the given shape, filled with random integer values generated uniformly from the interval `[low, high)`.
  If `dtype` is not specified, the default type is used.

  You can pass in the `device` keyword argument to control device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.randint(2, 3, low=5, high=10).numpy())
  ```
  """
  if not all_int([low, high]): raise TypeError(f"{low=} and {high=} must be integers")
  if not dtypes.is_int(dtype := to_dtype(dtype)): raise TypeError(f"{dtype=} must be int")
  return Tensor.uniform(*shape, low=low, high=high, dtype=dtype, **kwargs)

randperm staticmethod

randperm(
    n: int, device=None, dtype=int32, **kwargs
) -> Tensor

Returns a tensor with a random permutation of integers from 0 to n-1.

Tensor.manual_seed(42)
print(Tensor.randperm(6).numpy())

[1 2 3 5 0 4]

Source code in tinygrad/tensor.py

@staticmethod
def randperm(n:int, device=None, dtype=dtypes.int32, **kwargs) -> Tensor:
  """
  Returns a tensor with a random permutation of integers from `0` to `n-1`.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.randperm(6).numpy())
  ```
  """
  return Tensor.rand(n, device=device, **kwargs).argsort().cast(dtype)

normal staticmethod

normal(
    *shape,
    mean=0.0,
    std=1.0,
    requires_grad: bool | None = None,
    **kwargs
) -> Tensor

Creates a tensor with the given shape, filled with random values from a normal distribution with the given mean and standard deviation std.

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
print(Tensor.normal(2, 3, mean=10, std=2).numpy())

[[13.9153  9.6281 13.2808]
 [ 8.4707  8.261   9.1242]]

Source code in tinygrad/tensor.py

@staticmethod
def normal(*shape, mean=0.0, std=1.0, requires_grad:bool|None=None, **kwargs) -> Tensor:
  """
  Creates a tensor with the given shape, filled with random values from a normal distribution with the given `mean` and standard deviation `std`.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.normal(2, 3, mean=10, std=2).numpy())
  ```
  """
  return (std * Tensor.randn(*shape, **kwargs) + mean).requires_grad_(requires_grad)

uniform staticmethod

uniform(
    *shape,
    low=0.0,
    high=1.0,
    dtype: DTypeLike | None = None,
    requires_grad: bool | None = None,
    **kwargs
) -> Tensor

Creates a tensor with the given shape, filled with random values from a uniform distribution over the interval [low, high).

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
print(Tensor.uniform(2, 3, low=2, high=10).numpy())

[[5.0483 2.0782 2.9024]
 [2.9416 6.0429 4.9769]]

Source code in tinygrad/tensor.py

@staticmethod
def uniform(*shape, low=0.0, high=1.0, dtype:DTypeLike|None=None, requires_grad:bool|None=None, **kwargs) -> Tensor:
  """
  Creates a tensor with the given shape, filled with random values from a uniform distribution over the interval `[low, high)`.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.uniform(2, 3, low=2, high=10).numpy())
  ```
  """
  return (((high-low) * Tensor.rand(*shape, **kwargs)).cast(dtype or dtypes.default_float) + low).requires_grad_(requires_grad)

scaled_uniform staticmethod

scaled_uniform(*shape, **kwargs) -> Tensor

Creates a tensor with the given shape, filled with random values from a uniform distribution over the interval [-prod(shape)**-0.5, prod(shape)**-0.5).

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
print(Tensor.scaled_uniform(2, 3).numpy())

[[-0.0971 -0.4003 -0.3161]
 [-0.3121  0.0044 -0.1044]]

Source code in tinygrad/tensor.py

@staticmethod
def scaled_uniform(*shape, **kwargs) -> Tensor:
  """
  Creates a tensor with the given shape, filled with random values from a uniform distribution
  over the interval `[-prod(shape)**-0.5, prod(shape)**-0.5)`.

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.scaled_uniform(2, 3).numpy())
  ```
  """
  return Tensor.uniform(*shape, low=-1.0, high=1.0, **kwargs).mul(prod(argfix(*shape))**-0.5)

glorot_uniform staticmethod

glorot_uniform(*shape, **kwargs) -> Tensor

https://www.tensorflow.org/api_docs/python/tf/keras/initializers/GlorotUniform

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
print(Tensor.glorot_uniform(2, 3).numpy())

[[-0.2606 -1.074  -0.8483]
 [-0.8376  0.0117 -0.2802]]

Source code in tinygrad/tensor.py

@staticmethod
def glorot_uniform(*shape, **kwargs) -> Tensor:
  """
  <https://www.tensorflow.org/api_docs/python/tf/keras/initializers/GlorotUniform>

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.glorot_uniform(2, 3).numpy())
  ```
  """
  bound = (6 / (argfix(*shape)[0]+prod(argfix(*shape)[1:]))) ** 0.5
  return Tensor.uniform(*shape, low=-bound, high=bound, **kwargs)

kaiming_uniform staticmethod

kaiming_uniform(
    *shape, a: float = 0.01, **kwargs
) -> Tensor

https://pytorch.org/docs/stable/_modules/torch/nn/init.html#kaiming_uniform_

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
print(Tensor.kaiming_uniform(2, 3).numpy())

[[-0.3364 -1.3865 -1.0951]
 [-1.0813  0.0152 -0.3617]]

Source code in tinygrad/tensor.py

@staticmethod
def kaiming_uniform(*shape, a:float = 0.01, **kwargs) -> Tensor:
  """
  <https://pytorch.org/docs/stable/_modules/torch/nn/init.html#kaiming_uniform_>

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.kaiming_uniform(2, 3).numpy())
  ```
  """
  bound = (6 / (1 + a ** 2) / prod(argfix(*shape)[1:])) ** 0.5
  return Tensor.uniform(*shape, low=-bound, high=bound, **kwargs)

kaiming_normal staticmethod

kaiming_normal(*shape, a: float = 0.01, **kwargs) -> Tensor

https://pytorch.org/docs/stable/_modules/torch/nn/init.html#kaiming_normal_

You can pass in dtype and device keyword arguments to control the data type and device of the tensor. Additionally, all other keyword arguments are passed to the constructor of the tensor.

Tensor.manual_seed(42)
print(Tensor.kaiming_normal(2, 3).numpy())

[[ 1.5983 -0.1518  1.3393]
 [-0.6243 -0.7099 -0.3575]]

Source code in tinygrad/tensor.py

@staticmethod
def kaiming_normal(*shape, a:float = 0.01, **kwargs) -> Tensor:
  """
  <https://pytorch.org/docs/stable/_modules/torch/nn/init.html#kaiming_normal_>

  You can pass in `dtype` and `device` keyword arguments to control the data type and device of the tensor.
  Additionally, all other keyword arguments are passed to the constructor of the tensor.

  ```python exec="true" source="above" session="tensor" result="python"
  Tensor.manual_seed(42)
  print(Tensor.kaiming_normal(2, 3).numpy())
  ```
  """
  std = (2 / (1 + a ** 2) / prod(argfix(*shape)[1:])) ** 0.5
  return Tensor.normal(*shape, mean=0.0, std=std, **kwargs)