1. 从“手动复制”到“智能创建”：为什么我们需要*_like函数
如果你用过 PyTorch 或者 NumPy，大概率写过这样的代码：想创建一个和已有张量tensor_a形状、数据类型、设备都一模一样的新张量，但里面的元素全是 1 或者 0。新手的第一反应可能是：torch.ones(tensor_a.shape, dtype=tensor_a.dtype, device=tensor_a.device)。这行代码当然能工作，但每次都要手动传递shape、dtype、device这三个参数，不仅啰嗦，还容易出错——比如你修改了tensor_a的数据类型，却忘了同步更新这行创建代码，一个隐蔽的 bug 就埋下了。
torch.ones_like和torch.zeros_like这两个函数，就是为了解决这个“复制元信息”的痛点而生的。它们的核心价值就体现在函数名后缀的_like上：“像谁一样”。你只需要告诉它“像”哪个张量，它就能自动继承该张量的所有关键属性，然后填充上你指定的数值（1或0）。这不仅仅是语法糖，更是一种保证张量间兼容性的最佳实践。在深度学习模型搭建、数据预处理、损失函数计算等场景中，我们经常需要创建与某个中间张量维度完全匹配的掩码（Mask）、权重初始值或临时缓冲区，*_like函数能让这些操作变得既简洁又可靠。
从网络热词可以看到，无论是sprintf、open这类基础 C 函数，还是lambda、softmax、损失函数这些高级概念，函数的核心职责都是封装特定操作，提升代码的复用性和可读性。torch.ones_like正是这一思想的体现：它将“创建一个与参考张量属性一致的新张量”这一高频操作，封装成了一个简单直观的接口。理解了它，你就能更顺畅地驾驭 PyTorch 的张量操作，避免许多因属性不匹配导致的运行时错误。
2.torch.ones_like与torch.zeros_like的深度解析：不只是填充数字
很多教程会把这两个函数简单描述为“生成一个和输入张量形状一样，但元素全是1或0的张量”。这个说法没错，但只揭示了冰山一角。要真正用好它们，必须理解其继承的“属性包”具体包含哪些内容，以及如何通过参数进行微调。
2.1 核心行为：自动继承的“属性包”
当你调用torch.ones_like(input)时，函数内部会默默从input张量中提取以下关键属性，并用它们来构造新张量：
- 形状（Shape）：这是最直观的。新张量的维度大小与
input完全一致。 - 数据类型（Dtype）：例如
torch.float32、torch.int64、torch.bool。新张量的元素类型与input相同。这意味着如果你对一个bool型张量使用ones_like，得到的是一个元素为True（在布尔语境下等价于1）的张量。 - 设备（Device）：即张量存储在 CPU 内存还是 GPU 显存上（如
‘cuda:0’）。这是分布式计算和利用GPU加速的关键。*_like函数能确保新张量自动创建在正确的设备上，避免昂贵的设备间数据传输。 - 内存布局（Layout）：主要是
torch.strided（默认的稠密张量布局）。对于绝大多数情况，我们无需关心，但它也是被继承的属性之一。
一个简单的例子胜过千言万语：
import torch # 假设我们有一个复杂的输入张量 input_tensor = torch.randn(2, 3, dtype=torch.float64, device=‘cuda’) print(f“原始张量: shape={input_tensor.shape}, dtype={input_tensor.dtype}, device={input_tensor.device}”) # 使用 ones_like 创建 ones_tensor = torch.ones_like(input_tensor) print(f“ones_like 结果: shape={ones_tensor.shape}, dtype={ones_tensor.dtype}, device={ones_tensor.device}”) print(ones_tensor) # 使用 zeros_like 创建 zeros_tensor = torch.zeros_like(input_tensor) print(f“\nzeros_like 结果: shape={zeros_tensor.shape}, dtype={zeros_tensor.dtype}, device={zeros_tensor.device}”) print(zeros_tensor)输出会显示，ones_tensor和zeros_tensor都完美继承了input_tensor的(2, 3)形状、torch.float64类型和cuda设备属性。
2.2 关键参数：如何覆盖默认继承行为
*_like函数并非铁板一块，它们提供了关键的参数让你在需要时覆盖自动继承的行为。这是其灵活性的体现。
dtype：指定新张量的数据类型。当你希望创建一个与输入形状、设备相同，但类型不同的张量时使用。input_tensor = torch.randn(3, 4) # 默认是 torch.float32 int_ones = torch.ones_like(input_tensor, dtype=torch.int32) print(int_ones.dtype) # 输出: torch.int32device：指定新张量的存储设备。用于跨设备创建（但需谨慎，因为可能引发隐式数据拷贝）。cpu_tensor = torch.randn(5) # 显式指定在CUDA设备上创建全1张量 cuda_ones = torch.ones_like(cpu_tensor, device=‘cuda:0’)requires_grad：这是PyTorch自动求导（Autograd）的核心标志。它不从输入张量继承，而是默认为False。如果你想创建的新张量需要参与梯度计算（例如作为可学习的参数），必须显式设置为True。x = torch.randn(2, 2, requires_grad=True) y = torch.ones_like(x) # y.requires_grad 为 False z = torch.ones_like(x, requires_grad=True) # z.requires_grad 为 Truelayout、memory_format：高级参数，用于控制内存存储格式（如通道优先channels_last），在优化特定硬件（如GPU）上的计算性能时会用到。
注意：
dtype和device参数虽然可以覆盖，但在实际编程中，除非有明确理由（如类型转换、设备迁移），否则建议依赖自动继承，以最大程度保证与上下游计算图的兼容性。
2.3 与基础创建函数的对比：何时用谁？
PyTorch 提供了torch.ones()和torch.zeros()这两个基础函数。它们与*_like系列的核心区别在于：基础函数需要你显式地、完整地指定新张量的所有属性。
| 特性 | torch.ones(sizes) | torch.ones_like(input) |
|---|---|---|
| 形状定义 | 必须显式传入sizes（如(3,4)） | 自动从input继承 |
| 数据类型 | 默认为torch.float32，或通过dtype指定 | 自动从input继承，可通过dtype覆盖 |
| 设备 | 默认为 CPU，或通过device指定 | 自动从input继承，可通过device覆盖 |
| 使用场景 | 从头创建全新张量，或参考形状已知 | 已有参考张量，需创建与其兼容的新张量 |
选择策略：
- 当你手头已经有一个“模板”张量（
input）时，毫不犹豫地使用*_like。这是最安全、最简洁的方式。 - 当你只是凭空想创建一个特定形状的张量，没有现成的参考对象时，使用
torch.ones()/torch.zeros()。
3. 实战应用场景：在模型构建与数据处理中大显身手
理解了原理，我们来看看这两个函数在真实项目中如何解决具体问题。它们绝不仅仅是创建全1/全0数组那么简单。
3.1 场景一：初始化模型权重与掩码（Mask）
在构建神经网络层时，我们经常需要初始化一些与输入特征图形状相关的权重或掩码。
import torch.nn as nn class CustomAttentionLayer(nn.Module): def __init__(self, feature_dim): super().__init__() self.feature_dim = feature_dim # 假设注意力权重初始化为全1（一种简单的初始化方式） # 但此时我们还没有输入，不知道batch_size和序列长度，所以无法用 ones_like def forward(self, x): # x 的形状为 [batch_size, seq_len, feature_dim] batch_size, seq_len, _ = x.shape # 创建一个与输入x形状相同的全1张量，作为可学习的注意力偏置 # 注意：这里需要 requires_grad=True 以便训练 attention_bias = torch.ones_like(x, requires_grad=True) * 0.1 # 初始化为小值 # 创建一个与输入x形状相同的全0掩码，用于屏蔽无效位置（如padding） # 假设我们有一个布尔列表标识哪些位置是有效的 valid_positions = [True, True, False, True] # 示例 mask = torch.zeros_like(x[:, :, 0]) # 取一个特征维度，创建 [batch_size, seq_len] 的掩码 for i, valid in enumerate(valid_positions): if valid: mask[:, i] = 1 # 有效位置置1 # 更高效的做法可能是直接基于条件创建，但这里演示 zeros_like 作为基础模板 # ... 后续使用 attention_bias 和 mask 进行计算 return x + attention_bias * mask.unsqueeze(-1)在这个例子中，ones_like确保了attention_bias与输入x在设备（GPU/CPU）和数据类型上完全匹配，这是正确进行张量运算的前提。zeros_like则快速创建了一个结构正确的“画布”，方便我们在此基础上绘制具体的掩码图案。
3.2 场景二：损失函数计算与梯度处理
在实现自定义损失函数或进行梯度操作时，经常需要创建与预测值、标签同形状的辅助张量。
def custom_huber_loss(pred, target, delta=1.0): """ 实现 Huber 损失函数。 当误差绝对值小于 delta 时，使用平方损失；否则使用线性损失。 """ error = pred - target abs_error = error.abs() # 创建一个与 error 形状相同的张量，用于条件判断 quadratic_region = abs_error < delta # 关键步骤：创建与 pred/target 同形状的损失张量 loss = torch.zeros_like(pred) # 自动继承设备和类型 # 在平方损失区域计算 loss[quadratic_region] = 0.5 * (error[quadratic_region] ** 2) # 在线性损失区域计算 loss[~quadratic_region] = delta * (abs_error[~quadratic_region] - 0.5 * delta) return loss.mean() # 模拟数据 pred = torch.randn(10, 5, requires_grad=True) target = torch.randn(10, 5) loss = custom_huber_loss(pred, target) loss.backward()这里，torch.zeros_like(pred)一举三得：1) 确定了损失张量的形状；2) 确保了它在正确的设备上（如果pred在GPU上）；3) 确定了数据类型（通常是float32）。如果手动用torch.zeros(pred.shape, ...)，很容易漏掉device参数，导致损失张量被创建在CPU上，与GPU上的pred运算时引发错误。
3.3 场景三：数据预处理与张量扩展
在数据增强或准备模型输入时，我们可能需要为一批数据添加一个固定的偏置或创建维度对齐的占位符。
def add_channel_dimension(images): """假设输入 images 是灰度图 [N, H, W]，需要扩展为 [N, 1, H, W] 以适配卷积层""" if images.dim() == 3: # 在第二维（通道维）增加一个大小为1的维度 images = images.unsqueeze(1) return images def normalize_with_mean_std(tensor, mean, std): """使用与 tensor 同形状的 mean/std 进行归一化（支持逐通道归一化）""" # mean 和 std 可能是标量，也可能是与 tensor 通道维形状相同的向量 [C] # 我们需要将其扩展为与 tensor 相同的形状以进行广播计算 # 假设 tensor 形状为 [N, C, H, W] if mean.dim() == 1: # mean 形状为 [C] # 创建与 tensor 同形状的全1张量作为扩展模板 shape_for_broadcast = torch.ones_like(tensor) # 通过广播机制，将 mean 扩展为 [N, C, H, W] 其中每个 H,W 切片都是相同的均值 mean_expanded = mean.view(1, -1, 1, 1) * shape_for_broadcast[:, :1, :, :] # 简化示例逻辑 # 实际中更常用：mean[:, None, None] 进行广播，这里用 ones_like 说明形状匹配的思想 return (tensor - mean) / std # 更常见的例子：创建与某张量 batch_size 相同的索引或标签 batch_features = torch.randn(16, 256) # [batch_size, feature_dim] # 为每个样本分配一个初始权重（例如全1） sample_weights = torch.ones_like(batch_features[:, 0]) # 形状变为 [16]在这些场景中，ones_like扮演了“形状生成器”或“广播辅助”的角色，帮助我们快速构建出维度匹配的中间张量，使后续的广播运算能够正确执行。
4. 高级技巧与常见“坑点”排查
即使是一个简单的函数，在深度使用中也会遇到一些需要特别注意的地方。下面分享一些实战中积累的经验和容易踩坑的地方。
4.1 性能考量：in-place操作与计算图
*_like函数总是返回一个新的张量。这意味着它会有内存分配开销。在极度追求性能的循环或内核函数中，如果形状不变，可以考虑复用已分配的张量。
# 低效做法：在循环内反复创建 buffer = None for data in data_stream: if buffer is None or buffer.shape != data.shape: buffer = torch.zeros_like(data) # 每次形状变化都重新分配 # ... 使用 buffer 进行计算 # 稍好的做法：预分配（如果知道最大形状） max_shape = (100, 256, 256) big_buffer = torch.zeros(max_shape, dtype=torch.float32, device=‘cuda’) for data in data_stream: current_buffer = big_buffer[:data.shape[0], :data.shape[1], :data.shape[2]] # ... 使用 current_buffer 切片视图进行操作另外，请注意requires_grad参数。如果你创建了一个requires_grad=True的张量，它将被纳入计算图，PyTorch 会跟踪其上的所有操作以计算梯度。这会带来额外的内存和计算开销。仅在需要梯度的地方使用requires_grad=True。
4.2 设备一致性错误与调试
这是使用*_like时最常见的运行时错误之一，但往往也是最容易避免的。
# 错误示例 device = ‘cuda:0’ tensor_cpu = torch.tensor([1, 2, 3]) tensor_gpu = torch.ones_like(tensor_cpu, device=device) # 这行没问题，但... result = tensor_cpu + tensor_gpu # RuntimeError: 张量不在同一设备上！ # 正确做法：确保运算前张量在同一设备 tensor_cpu = tensor_cpu.to(device) # 将CPU张量移动到GPU # 或者，从一开始就确保模板张量在目标设备上 template_on_gpu = torch.tensor([1, 2, 3], device=device) tensor_gpu = torch.ones_like(template_on_gpu) # 自动继承 device='cuda:0'调试技巧：当遇到RuntimeError: Expected all tensors to be on the same device时，立即检查参与运算的所有张量的.device属性。*_like创建的张量会继承模板的设备，这是一个有力的保证，但前提是你的“模板”本身在正确的设备上。
4.3 与torch.full_like的协同使用
PyTorch 还提供了更通用的torch.full_like(input, fill_value)函数。它可以创建与input形状、类型、设备相同的张量，并用任意指定的fill_value填充。
input = torch.randn(2, 3) # 以下三行代码等价 a = torch.ones_like(input) b = torch.full_like(input, fill_value=1.0) c = torch.zeros_like(input) + 1.0 # 不推荐，效率低且可能产生临时张量 # full_like 的威力：填充任意值 negative_ones = torch.full_like(input, -1.0) pi_tensor = torch.full_like(input, 3.14159)所以，ones_like和zeros_like可以看作是full_like在fill_value=1和fill_value=0时的特化版本，语法更简洁。当你需要填充的值不是0或1时，记住torch.full_like这个工具。
4.4 稀疏张量与特殊数据类型
对于稀疏张量（torch.sparse）或一些特殊数据类型（如复数torch.complex64），*_like函数的行为依然一致。
# 稀疏张量 sparse_input = torch.sparse_coo_tensor(indices=[[0, 1], [2, 3]], values=[1., 2.], size=(4, 5)) sparse_ones = torch.ones_like(sparse_input) print(sparse_ones) # 这会创建一个具有相同稀疏布局但值全为1的稀疏张量吗？ # 注意：对于稀疏张量，`ones_like` 会创建一个**稠密**的、形状相同的全1张量，而不是稀疏的。 # 要创建稀疏的全1张量，需要直接操作稀疏索引和值。 # 复数张量 complex_input = torch.complex(torch.randn(3), torch.randn(3)) complex_ones = torch.ones_like(complex_input) print(complex_ones) # 输出：tensor([1.+0.j, 1.+0.j, 1.+0.j])这里有一个重要的细节：对于稀疏张量，ones_like返回的是稠密张量。这是因为“全1”的稀疏表示效率极低（几乎每个位置都是1）。如果你需要稀疏格式的全1张量，可能需要重新考虑数据结构是否合适。
5. 从函数设计看编程哲学：一致性、简洁性与安全性
回顾torch.ones_like和torch.zeros_like，它们体现了优秀的API设计原则：
一致性（Consistency）：
_like后缀在 PyTorch 中形成了一个清晰的语义家族。除了这两个，还有torch.rand_like（均匀分布随机数）、torch.randn_like（标准正态分布随机数）、torch.empty_like（未初始化内存）等。这种命名约定让用户能够举一反三，大大降低了学习成本。简洁性（Simplicity）：将高频操作（复制张量元信息）封装成一个函数调用，避免了重复、易错的参数传递。这符合“Don‘t Repeat Yourself” (DRY) 原则。
安全性（Safety）：通过自动继承设备、数据类型等关键属性，从根本上避免了因属性不匹配导致的隐蔽错误。尤其是在混合精度训练（
float16/float32）或多设备（CPU/多GPU）编程中，这种安全性至关重要。
在实际编码中，养成使用*_like函数的习惯，能让你写出更健壮、更易维护的代码。下次当你需要创建一个与现有张量“类似”的新张量时，先问问自己：是不是用ones_like或zeros_like更合适？这个简单的选择，往往是区分新手和有经验开发者的一个小标志。
最后，再分享一个我个人的小习惯：在编写需要返回与输入同形状张量的函数时，我通常会先用torch.zeros_like(input)创建一个“外壳”，然后再填充内容。这就像先打好画框再作画，能让我在编码初期就明确输出形状，并利用编辑器的自动补全功能，避免后续的形状不匹配错误。这种“先定框架，后填逻辑”的思路，在很多编程场景下都很有用。
