![SCR-20260220-ufky.png](https://developer.qcloudimg.com/http-save/yehe-11467648/994aeb2df7b4093f926253414ca1e60b.png)
```
# 张量介绍


**张量（Tensor）**是 PyTorch 中将要使用的主要数据结构。如果你使用过 NumPy，你会发现 PyTorch 张量非常熟悉。从本质上讲，张量是多维数组，与 NumPy 的 `ndarray` 非常相似。

可以把张量看作是常见数学对象的推广：

- 一个**标量**（单个数字，例如 7）是 0 维张量（或 0 阶张量）。
- 一个**向量**（一维数字列表或数组，例如 `[1, 2, 3]`）是 1 维张量（或 1 阶张量）。
- 一个**矩阵**（二维数字网格，例如 `[[1, 2], [3, 4]]`）是 2 维张量（或 2 阶张量）。
- 依此类推，可以有 3 维张量（例如数字立方体，常用于 RGB 图像：高 x 宽 x 通道）、4 维张量（常用于图像批次：批大小 x 高 x 宽 x 通道）等。

标量 (7)0维张量向量 [1, 2, 3]1维张量增加维度矩阵 [[1, 2],   [3, 4]]2维张量增加维度3维张量(例如：图像 高x宽x通道)增加维度高维张量(例如：批次 批大小x高x宽x通道)...


> 一种将张量看作标量、向量和矩阵的推广的方式，维度逐渐增加。


在深度学习中，张量用来表示几乎所有数据：

- **输入数据：** 图像批次、文本序列或特征表格。
- **模型参数：** 神经网络层的权重和偏置。
- **中间激活：** 网络内部各层的输出。
- **梯度：** 反向传播过程中计算的值，用于更新模型参数。

与标准 Python 列表甚至 NumPy 数组相比，是什么让 PyTorch 张量特别适合深度学习呢？

1. **GPU 加速：** 张量可以轻松地移动到图形处理器 (GPU) 或其他硬件加速器上进行处理。这为深度学习中常见的计算密集型操作提供了大幅加速。
2. **自动微分：** PyTorch 张量通过 `Autograd` 系统内置了对自动微分的支持（我们将在第 3 章中介绍）。这种机制自动计算梯度，这对通过反向传播训练神经网络来说非常重要。

尽管其原理与 NumPy 数组相似，但这两个特性使得 PyTorch 张量成为高效构建和训练模型的主要工具。在接下来的部分中，我们将介绍如何创建和操作这些重要的数据结构。


# 创建张量


张量是 PyTorch 中的基本数据结构，代表深度学习模型中使用的多维数组。代码中提供了创建张量的实用方法。PyTorch 提供了一系列灵活的函数来创建张量，无论使用现有数据，还是需要特定形状和初始值。

### 从现有数据创建张量

创建张量最直接的方法通常是使用现有的 Python 数据结构，比如列表或 NumPy 数组。主要用于此目的的函数是 `torch.tensor()`。这个函数会根据输入数据自动判断数据类型 (`dtype`)，但您也可以明确指定。重要的是，`torch.tensor()` 总是复制输入数据。

我们来看看实际操作。首先，请确保已导入 PyTorch：

```scala 3
import torch.*
import numpy as np

```

```java
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.bytedeco.javacpp.*;
import org.bytedeco.pytorch.*;
import org.bytedeco.pytorch.global.torch;
import org.bytedeco.pytorch.global.torch_cuda;
import static org.bytedeco.pytorch.global.torch.*;


TensorOptions tensorOptions = new TensorOptions()
                .device(new DeviceOptional(device))
                .requires_grad(new BoolOptional(true))
                .dtype(new ScalarTypeOptional(ScalarType.Float))
                .layout(new LayoutOptional(layout))
                .memory_format(new MemoryFormatOptional(memory_format))
                .device_index((byte)1)
                .pinned_memory(new BoolOptional(true));
        var tensor = torch.tensor(new float[]{1.0f, 2.0f, 3.0f}, tensorOptions);
        
TensorOptions device = torch.device(new Device(DeviceType.CPU));
                
TensorOptions gradient = torch.requires_grad(true);
        
TensorOptions dtype = torch.dtype(ScalarType.Float);
        
TensorOptions layout = torch.layout(Layout.Strided);
        
TensorOptions memory_format = torch.memory_format(MemoryFormat.Contiguous);
        
TensorOptions device_index =  torch.device_index((byte)1);
        
boolean pinned_memory = torch.pinned_memory_or_default(new BoolOptional(true))
        

```
现在，从 Python 列表创建一个张量：

```scala 3
// 从 Scala 列表创建张量
val data_list = Seq(Seq(1, 2), Seq(3, 4))
val tensor_from_list = torch.tensor(data_list)

println("从列表生成的张量:")
println(tensor_from_list)
println(s"数据类型: ${tensor_from_list.dtype}")
println(s"形状: ${tensor_from_list.shape}")
```

```java
 float[][] dataList = {{1, 2}, {3, 4}};

            // 2. 计算数组总长度和形状
 int rows = dataList.length;
 int cols = dataList[0].length;
 int totalElements = rows * cols;

            // 3. 将二维数组展平为一维数组（PyTorch 张量底层是连续内存）
float[] flatData = new float[totalElements];
int index = 0;

for (float[] floats : dataList) {
                for (int j = 0; j < cols; j++) {
                    flatData[index++] = floats[j];
                }
            }
            // 4. 将一维数组转换为 javacpp FloatPointer（PyTorch Java 绑定的核心类型）  *flatdata
FloatPointer floatPointer = new FloatPointer(flatData);

            // 5. 定义张量形状（rows × cols）
SizeTPointer shape1 = new SizeTPointer(new long[]{rows, cols});
//            TensorOptions options = new TensorOptions().dtype(kFloat).device(kCPU);
var tensorOptions = new TensorOptions() //tensorBuilder
                    .layout(new LayoutOptional(Layout.Strided))
                    .dtype(new ScalarTypeOptional(ScalarType.Float))
                    .device(new DeviceOptional(new Device(DeviceType.CPU)))
                    .memory_format(new MemoryFormatOptional(MemoryFormat.Contiguous));
            // 6. 创建张量（指定数据、形状、数据类型、设备）
            Tensor tensor = torch.tensor(floatPointer, tensorOptions).reshape(new LongArrayRef());
            


```


这将输出：

```
从列表生成的张量:
tensor([[1, 2],
        [3, 4]])
数据类型: torch.int64
形状: torch.Size([2, 2])
```

请注意 PyTorch 如何根据输入整数判断数据类型为 `torch.int64`（一个 64 位整数）。

您也可以从 NumPy 数组开始，获得相同的结果：

```scala 3
// 从 NumPy 数组创建张量
val data_numpy = np.array(Seq(Seq(5.0, 6.0), Seq(7.0, 8.0)))
val tensor_from_numpy = torch.tensor(data_numpy)

println("\n从 NumPy 数组生成的张量:")
println(tensor_from_numpy)
println(s"数据类型: ${tensor_from_numpy.dtype}")
println(s"形状: ${tensor_from_numpy.shape}")
```

输出：

```
从 NumPy 数组生成的张量:
tensor([[5., 6.],
        [7., 8.]], dtype=torch.float64)
数据类型: torch.float64
形状: torch.Size([2, 2])
```

```java
     // 如果是 long 类型
            long[] flatDataLong = {1, 2, 3, 4};
            LongPointer longPtr = new LongPointer(flatDataLong);
            var tensorOptions2 = new TensorOptions()
                    .layout(new LayoutOptional(Layout.Strided))
                    .dtype(new ScalarTypeOptional(ScalarType.Long))
                    .device(new DeviceOptional(new Device(DeviceType.CPU)))
                    .memory_format(new MemoryFormatOptional(MemoryFormat.Contiguous));
// 注意：Java long 对应 C++ int64 (kLong)
            Tensor longTensor = torch.from_blob(longPtr, new long[]{2, 2}, tensorOptions2).clone();
            System.out.println("从数组生成的 long 类型张量:" + longTensor);
         

```
为了方便输出 我们写一个 展平数组的工具
```java
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

public class TensorToolkit {

    // Get Multidimensional array Shape
    public static long[] getShape(Object array) {
        if (array == null || !array.getClass().isArray()) return new long[0];
        List<Long> shape = new ArrayList<>();
        Object current = array;
        while (current != null && current.getClass().isArray()) {
            int len = Array.getLength(current);
            shape.add((long) len);
            current = (len > 0) ? Array.get(current, 0) : null;
        }
        return shape.stream().mapToLong(i -> i).toArray();
    }

    // flatten Multidimensional array
    public static Object flatten(Object multiDimArray) {
        if (multiDimArray == null) return null;
        Class<?> componentType = multiDimArray.getClass();
        while (componentType.isArray()) componentType = componentType.getComponentType();

        int size = 1;
        for (long d : getShape(multiDimArray)) size *= d;

        Object result = Array.newInstance(componentType, size);
        fill(multiDimArray, result, new int[]{0});
        return result;
    }

    private static void fill(Object src, Object dest, int[] idx) {
        int len = Array.getLength(src);
        for (int i = 0; i < len; i++) {
            Object el = Array.get(src, i);
            if (el != null && el.getClass().isArray()) fill(el, dest, idx);
            else Array.set(dest, idx[0]++, el);
        }
    }
}


```


这里，数据类型被判断为 `torch.float64`，因为 NumPy 数组包含浮点数。本章后面将讨论 PyTorch 张量与 NumPy 数组之间的关系，包括更有效的转换方法。

### 创建具有特定形状和值的张量

很多时候，您需要在没有预先数据的情况下创建特定大小的张量，例如用零、一或随机值进行初始化。PyTorch 为这些情况提供了专门的函数。形状通常作为元组或整数序列传递。

**零张量、一张量或未初始化数据张量：**

- `torch.zeros(*size, ...)`: 创建一个填充零的张量。
- `torch.ones(*size, ...)`: 创建一个填充一的张量。
- `torch.empty(*size, ...)`: 创建一个指定大小的张量，但其内容未被设定。其中的值是分配内存时该位置的任意数据。如果您计划在创建后立即填充张量，使用 `torch.empty` 会快一些，但请注意，初始值是不确定的。

```scala 3
// 定义期望的形状
val shape = Seq(2, 3) // 2 行, 3 列

// 创建具有特定值的张量
val zeros_tensor = torch.zeros(shape)
val ones_tensor = torch.ones(shape)
val empty_tensor = torch.empty(shape) // 值是任意的

println(s"\n零张量 (形状 {shape}):")
println(zeros_tensor)
println(s"\n一张量 (形状 {shape}):")
println(ones_tensor)

println(s"\n空张量 (形状 {shape}):")
println(empty_tensor)
```

```java
   long[] shape = {2, 3}; // 2 行, 3 列

            // 创建具有特定值的张量
  Tensor zeros_tensor = torch.zeros(shape);
  Tensor ones_tensor = torch.ones(shape);
  Tensor empty_tensor = torch.empty(shape); // 值是任意的

  System.out.println("\n零张量 (形状 " + shape[0] + "x" + shape[1] + "):");
  print(zeros_tensor);
  System.out.println("\n一张量 (形状 " + shape[0] + "x" + shape[1] + "):");
  print(ones_tensor);
  System.out.println("\n空张量 (形状 " + shape[0] + "x" + shape[1] + "):");
  print(empty_tensor);

```

输出（请注意 `empty_tensor` 的值会有所不同）：

```
零张量 (形状 (2, 3)):
tensor([[0., 0., 0.],
        [0., 0., 0.]])

一张量 (形状 (2, 3)):
tensor([[1., 1., 1.],
        [1., 1., 1.]])

空张量 (形状 (2, 3)):
tensor([[2.1321e-38, 5.0837e+24, 3.0763e-41],
        [3.0763e-41, 1.2326e-32, 1.8750e+00]])
```

默认情况下，这些函数创建的数据类型为 `dtype=torch.float32` 的张量。您可以使用 `dtype` 参数指定不同的数据类型：

```scala 3
// 创建一个整数类型的一张量
val ones_int_tensor = torch.ones(shape, dtype=torch.int32)
println(s"\n一张量 (dtype=torch.int32):")
println(ones_int_tensor)
```

```

   TensorOptions int32Options = new TensorOptions().dtype(new ScalarTypeOptional(ScalarType.Int))
   Tensor ones_int_tensor = torch.ones(shape, int32Options);// dtype_int32());
   System.out.println("\n一张量 (dtype=torch.int32):");
   print(ones_int_tensor);
```
输出：

```
一张量 (dtype=torch.int32):
tensor([[1, 1, 1],
        [1, 1, 1]], dtype=torch.int32)
```

**带随机值的张量：**

初始化模型参数通常会从随机值开始。PyTorch 为此提供了函数：

- `torch.rand(*size, ...)`: 创建一个从区间 [0, 1) 均匀采样的张量。
- `torch.randn(*size, ...)`: 创建一个从标准正态分布（均值 0，方差 1）采样的张量。

```scala 3
// 创建带随机值的张量
val rand_tensor = torch.rand(shape) // 均匀分布 [0, 1)
val randn_tensor = torch.randn(shape) // 标准正态分布

println(s"\n随机张量 (均匀分布 [0, 1), 形状 {shape}):")
println(rand_tensor)

println(s"\n随机张量 (标准正态分布, 形状 {shape}):")
println(randn_tensor)
```

```java
      // 创建带随机值的张量
            Tensor rand_tensor2 = torch.rand(shape); // 均匀分布 [0, 1)
            Tensor randn_tensor = torch.randn(shape); // 标准正态分布
                   Tensor rnadint_tensor3 = torch.randint(shape); //随机整数

            System.out.println("\n随机张量 (均匀分布 [0, 1), 形状 " + shape[0] + "x" + shape[1] + "):");
            torch.print(rand_tensor2);
            System.out.println("\n随机张量 (标准正态分布, 形状 " + shape[0] + "x" + shape[1] + "):");
            torch.print(randn_tensor);
                 System.out.println("\n随机整数 张量 (标准正态分布, 形状 " + shape[0] + "x" + shape[1] + "):");
            torch.print(rnadint_tensor3);

```

输出（每次运行结果会有所不同）：

```
随机张量 (均匀分布 [0, 1), 形状 (2, 3)):
tensor([[0.6580, 0.5089, 0.1642],
        [0.3742, 0.5989, 0.7775]])

随机张量 (标准正态分布, 形状 (2, 3)):
tensor([[-0.2651, -0.3249, -1.0134],
        [ 1.1314,  1.1751, -0.1411]])
```

### 基于其他张量创建张量

有时，您需要创建一个新张量，使其与现有张量具有相同的属性（如形状和 `dtype`）。这对于确保操作兼容性很有帮助。PyTorch 为此提供了 `_like` 变体函数：

- `torch.zeros_like(input_tensor, ...)`
- `torch.ones_like(input_tensor, ...)`
- `torch.rand_like(input_tensor, ...)`
- `torch.randn_like(input_tensor, ...)`

这些函数接受一个现有张量作为输入，并返回一个新张量，其内容为指定的值（零、一、随机），但会与输入张量的形状和 `dtype` 匹配，除非明确覆盖。

```scala 3
// 使用现有张量作为模板
val base_tensor = torch.tensor(Seq(Seq(1, 2), Seq(3, 4)), dtype=torch.float32)
println(s"\n基础张量 (形状 {base_tensor.shape}, dtype {base_tensor.dtype}):")
println(base_tensor)

// 创建与基础张量属性匹配的张量
val zeros_like_base = torch.zeros_like(base_tensor)
val rand_like_base = torch.rand_like(base_tensor)

println("\n类似基础张量的零张量:")
println(zeros_like_base)
println(s"形状: ${zeros_like_base.shape}, dtype: ${zeros_like_base.dtype}")

println("\n类似基础张量的随机张量:")
println(rand_like_base)
println(s"形状: ${rand_like_base.shape}, dtype: ${rand_like_base.dtype}")
```

```java
  int [][] existing_array = {{1, 2}, {3,4}};
            var flatArray = TensorToolkit.flatten(existing_array);
            var shapes = TensorToolkit.getShape(existing_array);
            Tensor base_tensor = torch.tensor((int[]) flatArray).reshape(shapes).to(ScalarType.Float);
            System.out.println("\n基础张量 (形状 " + base_tensor.sizes() + ", dtype " + base_tensor.dtype() + "):");
            print(base_tensor);

            // 创建与基础张量属性匹配的张量
            Tensor zeros_like_base = torch.zeros_like(base_tensor);
            Tensor rand_like_base = torch.rand_like(base_tensor);
                   Tensor ones_like_base = torch.ones_like(base_tensor);
            System.out.println("\n类似基础张量的零张量:");
            print(zeros_like_base);
            System.out.println("形状: " + zeros_like_base.sizes() + ", dtype: " + zeros_like_base.dtype());

            System.out.println("\n类似基础张量的随机张量:");
            print(rand_like_base);
            System.out.println("形状: " + rand_like_base.sizes() + ", dtype: " + rand_like_base.dtype());


```

输出：

```
基础张量 (形状 torch.Size([2, 2]), dtype torch.float32):
tensor([[1., 2.],
        [3., 4.]])

类似基础张量的零张量:
tensor([[0., 0.],
        [0., 0.]])
形状: torch.Size([2, 2]), dtype: torch.float32

类似基础张量的随机张量:
tensor([[0.1216, 0.5908],
        [0.3264, 0.9272]])
形状: torch.Size([2, 2]), dtype: torch.float32
```

如您所见，新张量 `zeros_like_base` 和 `rand_like_base` 自动从 `base_tensor` 继承了 `shape` (torch.Size([2, 2])) 和 `dtype` (torch.float32)。

这些方法为您生成所需的张量提供了一套全面的方式，它们支撑着深度学习模型中的计算。在接下来的章节中，我们将了解如何操作这些张量并进行重要运算。
```

请注意 PyTorch 如何根据输入整数判断数据类型为 torch.int64（一个 64 位整数）。

【Java深度学习】PyTorch On Java 系列课程 第一章 02 ：张量操作【AI Infra 3.0】[PyTorch Java 硕士研一课程]

编程语言

PyTorch张量是多维数组数据结构，支持GPU加速和自动微分，广泛应用于深度学习。本文详细介绍张量的创建方法，包括从列表/Numpy数组转换、特定形状初始化（零、一、随机值）以及基于现有张量创建新张量。掌握这些基础操作是构建神经网络模型的关键步骤。

深度学习

数据结构

Python

4核4G3M云服务器 新用户低至38元/年！

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

【Java深度学习】PyTorch On Java 系列课程 第一章 02 ：张量操作【AI Infra 3.0】[PyTorch Java 硕士研一课程]-腾讯云开发者社区-腾讯云

【Java深度学习】PyTorch On Java 系列课程第一章 02 ：张量操作【AI Infra 3.0】[PyTorch Java 硕士研一课程]

【Java深度学习】PyTorch On Java 系列课程第一章 02 ：张量操作【AI Infra 3.0】[PyTorch Java 硕士研一课程]

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

【Java深度学习】PyTorch On Java 系列课程 第一章 02 ：张量操作【AI Infra 3.0】[PyTorch Java 硕士研一课程]

【Java深度学习】PyTorch On Java 系列课程 第一章 02 ：张量操作【AI Infra 3.0】[PyTorch Java 硕士研一课程]

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

【Java深度学习】PyTorch On Java 系列课程第一章 02 ：张量操作【AI Infra 3.0】[PyTorch Java 硕士研一课程]

【Java深度学习】PyTorch On Java 系列课程第一章 02 ：张量操作【AI Infra 3.0】[PyTorch Java 硕士研一课程]