pytorch api文档：torch.rand()生成均匀分布随机张量[0, 1) 区间-马育民老师

# 介绍

`torch.rand()` 函数，是生成 **均匀分布 随机 张量** 的核心工具，常用来初始化模型权重、生成随机数据等

### 作用

创建一个指定形状的张量，其中的元素值**随机采样自 [0, 1) 区间的均匀分布**（即每个值的出现概率相等，且不包含 1）。

它是 PyTorch 中最基础的随机张量生成函数，同类还有：

- `torch.randn()`：生成标准正态分布（均值0，方差1）的随机张量；
- `torch.randint()`：生成整数随机张量。

# 语法

```
torch.rand(*size, dtype=None, device=None, requires_grad=False)
```

#### 参数详解

| 参数           | 作用                                                                 | 常用场景                                                                 |
|----------------|----------------------------------------------------------------------|--------------------------------------------------------------------------|
| `*size`        | 张量形状，可传单个整数、多个整数，或元组/列表（如 `torch.rand((2,3))`） | 核心参数，必传；形状顺序遵循“批量优先”（如 `(batch, dim)`）|
| `dtype`        | 指定数据类型（如 `torch.float32`/`torch.float64`）| 默认 `torch.float32`，需高精度时设 `dtype=torch.float64`                 |
| `device`       | 指定存储设备（`cpu`/`cuda`）| 深度学习中需和模型/数据同设备，如 `device="cuda:0"`                      |
| `requires_grad`| 是否开启梯度计算                                                     | 仅作为可训练参数初始化时设 `True`，普通随机数据设 `False`（默认）|

# 例子

`size` 是唯一必传参数，可指定单个/多个维度，直接看代码更直观：
```python
import torch

# 示例1：生成一维随机张量（3个元素）
rand_1d = torch.rand(3)
print("一维随机张量：", rand_1d)
# 输出示例：tensor([0.1234, 0.5678, 0.9012])（值在 [0,1) 之间）
print("形状：", rand_1d.shape)  # torch.Size([3])

# 示例2：生成二维随机张量（2行3列）
rand_2d = torch.rand(2, 3)
print("二维随机张量：\n", rand_2d)
# 输出示例：
# tensor([[0.3456, 0.7890, 0.2345],
#         [0.8765, 0.4567, 0.6789]])
print("形状：", rand_2d.shape)  # torch.Size([2, 3])

# 示例3：生成高维随机张量（批量场景）
rand_3d = torch.rand(4, 2, 3)  # 4个 2×3 的随机矩阵
print("三维随机张量形状：", rand_3d.shape)  # torch.Size([4, 2, 3])
print("数值范围：", (rand_3d.min().item(), rand_3d.max().item()))  # (≈0, ≈1)
```

### 参数示例
```python
# 示例1：指定数据类型（float64）
rand_float64 = torch.rand(2, 3, dtype=torch.float64)
print("数据类型：", rand_float64.dtype)  # torch.float64
print("数值：\n", rand_float64)

# 示例2：指定GPU设备（需CUDA环境）
if torch.cuda.is_available():
    rand_cuda = torch.rand(2, 3, device="cuda")
    print("设备：", rand_cuda.device)  # cuda:0
else:
    print("无CUDA环境，默认生成CPU张量")

# 示例3：可求梯度的随机张量（初始化模型参数）
rand_grad = torch.rand(2, 3, requires_grad=True)
print("是否可求梯度：", rand_grad.requires_grad)  # True
```

### 随机种子（复现结果）

`torch.rand()` 生成的随机数是伪随机的，设置全局随机种子可固定结果，方便复现实验：
```python
# 设置全局随机种子
torch.manual_seed(42)
# 多次运行，结果完全一致
print("固定种子后结果1：", torch.rand(2))  # tensor([0.8823, 0.9150])
torch.manual_seed(42)
print("固定种子后结果2：", torch.rand(2))  # tensor([0.8823, 0.9150])
```

### 扩展数值范围

如果需要生成 `[a, b)` 区间的均匀分布随机数，可通过简单变换实现：
```python
# 目标：生成 [2, 5) 区间的随机数
a, b = 2, 5
rand_custom = a + (b - a) * torch.rand(2, 3)
print("自定义区间随机数：\n", rand_custom)
print("数值范围：", (rand_custom.min().item(), rand_custom.max().item()))  # (≈2, ≈5)
```

# 实战场景
### （1）初始化模型参数
虽然 `torch.randn()` 更常用，但简单场景下可通过 `torch.rand()` 初始化权重（需缩放）：
```python
import torch.nn as nn

# 自定义线性层，用rand初始化权重
class MyLinear(nn.Module):
    def __init__(self, in_dim, out_dim):
        super().__init__()
        # 初始化权重：[0,1) 均匀分布 → 缩放为 [-0.1, 0.1)
        self.weight = nn.Parameter(torch.rand(out_dim, in_dim) * 0.2 - 0.1)
        self.bias = nn.Parameter(torch.zeros(out_dim))
    
    def forward(self, x):
        return x @ self.weight.T + self.bias

# 测试
linear = MyLinear(5, 3)
print("权重初始化结果：\n", linear.weight)
print("权重范围：", (linear.weight.min().item(), linear.weight.max().item()))  # (≈-0.1, ≈0.1)
```

### （2）生成随机掩码/掩码矩阵
在注意力机制、数据增强等场景中，常用 `torch.rand()` 生成随机掩码：
```python
# 场景：生成0/1掩码（概率0.5保留，0.5掩码）
batch_size, seq_len = 4, 10
mask = (torch.rand(batch_size, seq_len) > 0.5).float()
print("随机掩码：\n", mask)
# 输出示例：
# tensor([[1., 0., 1., 0., 1., 0., 1., 0., 1., 0.],
#         [0., 1., 0., 1., 0., 1., 0., 1., 0., 1.],
#         [1., 1., 0., 0., 1., 1., 0., 0., 1., 1.],
#         [0., 0., 1., 1., 0., 0., 1., 1., 0., 0.]])
```

### （3）生成随机输入数据
测试模型时，常用 `torch.rand()` 生成模拟输入：
```python
# 模拟：生成批量输入（4个样本，每个样本10维特征）
batch_x = torch.rand(4, 10)
print("模拟输入数据：\n", batch_x)
print("输入形状：", batch_x.shape)  # torch.Size([4, 10])
```

# 总结

1. `torch.rand(*size)` 生成**[0,1) 均匀分布**的随机张量，是PyTorch基础的随机数生成函数。
2. 核心参数：`size` 定义形状，`dtype` 指定数据类型，`device` 指定存储设备；设置随机种子（`torch.manual_seed()`）可复现结果。
3. 关键区别：`torch.rand()` 是均匀分布，`torch.randn()` 是正态分布；扩展区间可通过 `a + (b-a)*torch.rand()` 实现。
4. 实战场景：初始化简单权重、生成随机掩码、模拟测试数据等。

原文出处：http://malaoshi.top/show_1GW2c5aFcZOW.html