PyTorch张量类型创建与转换的详细指南_Asp.net

引言

在pytorch的深度学习开发中，张量（tensor）作为核心数据结构，其类型的灵活创建与转换是基础且关键的操作。不同的业务场景、硬件环境对张量数据类型有着不同的要求，比如轻量化训练常用float16，常规训练多用float32，高精度计算会用到float64。今天就带大家系统掌握pytorch中张量指定类型的创建方法，以及多种类型转换技巧，从基础概念到实操代码，一站式吃透

一、前置基础：比特位与数据类型的小知识

在学习张量类型之前，我们先理清一个基础概念：比特位（bit）与字节（byte）的关系，这是理解不同数值类型的核心。

1个字节 = 8个比特位，而pytorch中的数值类型正是通过比特位数量定义的，比如float16代表16个比特位，换算下来就是2个字节，这也决定了该类型的存储大小和精度：比特位越少，占用内存越小，精度相对越低；比特位越多，占用内存越大，精度也越高。

给大家整理了pytorch中常用张量数据类型的对应关系，一张表就能看明白

类型函数	对应pytorch类型	比特位数	字节数	适用场景
half()	torch.float16	16	2	轻量化训练、低显存硬件
float()	torch.float32	32	4	常规深度学习训练/推理
double()	torch.float64	64	8	高精度科学计算
short()	torch.int16	16	2	低精度整数运算
int()	torch.int32	32	4	常规整数运算
long()	torch.int64	64	8	索引、大整数运算
小提示：pytorch中创建整数张量时，默认类型是torch.int64；创建浮点张量时，默认类型是torch.float32，这也是深度学习中最常用的浮点类型，大家一定要记牢

二、小技巧：pytorch文件重命名的快捷操作

在实际开发中，我们常会遇到文件命名错误的情况，比如把“张量类型转换”的文件命名成了“张亮元素类型转换”，这里分享两个pytorch项目（pycharm编辑器）中高效的文件重命名方法，告别手动删除重建的繁琐：

方法1：基础法——右键删除重建

操作简单，适合新手：右键错误命名的文件→删除→新建同名（正确名称）的.py文件，缺点是需要重新写文件头和导入代码，效率较低。

方法2：快捷法——重构重命名（推荐）

这是开发中最常用的方法，快捷键shift+f6，步骤如下：

选中需要重命名的文件；
按下shift+f6，或右键选择refactor（重构）→rename（重命名）；
输入正确的文件名，回车确认，整个项目中对该文件的引用会自动更新，无需手动修改！

三、核心操作1：创建指定类型的张量

创建张量时直接指定类型，是最常用、最高效的方式，避免后续二次转换的麻烦。在使用torch.tensor()创建张量时，通过dtype参数即可指定张量的元素类型，这里先理清两个极易混淆的概念，避免踩坑：

tensor.dtype：查看张量内元素的类型（如torch.float32、torch.int64），这是我们最常关注的属性；
tensor.type()：查看张量本身的类型，结果一般为torch.tensor，代表这是一个张量对象。

3.1 基础创建：默认类型张量

当我们不指定dtype时，pytorch会根据输入的数值类型自动分配默认张量类型：

import torch  # 导入pytorch库，版本建议2.0+

# 创建整数张量，默认dtype=torch.int64
t1 = torch.tensor([1,2,3,4,5])
print(f"张量元素类型：{t1.dtype}")  # 输出：torch.int64
print(f"张量本身类型：{t1.type()}") # 输出：torch.longtensor（对应int64）

# 创建浮点张量，默认dtype=torch.float32
t2 = torch.tensor([1.0,2.0,3.0])
print(f"张量元素类型：{t2.dtype}")  # 输出：torch.float32
print(f"张量本身类型：{t2.type()}") # 输出：torch.floattensor（对应float32）

3.2 精准创建：指定dtype的张量

通过dtype=torch.xxx即可自定义张量元素类型，满足不同场景需求，代码示例如下：

import torch

# 创建float16类型张量
t_float16 = torch.tensor([1,2,3], dtype=torch.float16)
# 创建float64类型张量
t_float64 = torch.tensor([1,2,3], dtype=torch.float64)
# 创建int16类型张量
t_int16 = torch.tensor([1,2,3], dtype=torch.int16)
# 创建int32类型张量
t_int32 = torch.tensor([1,2,3], dtype=torch.int32)

print(f"float16张量：{t_float16.dtype}")  # torch.float16
print(f"float64张量：{t_float64.dtype}")  # torch.float64
print(f"int16张量：{t_int16.dtype}")      # torch.int16
print(f"int32张量：{t_int32.dtype}")      # torch.int32

重点：在深度学习训练中，我们几乎都会用dtype=torch.float32创建张量，这是框架默认的训练精度，兼顾速度和精度💪

四、核心操作2：张量的类型转换

实际开发中，我们常会遇到已创建的张量类型不符合需求的情况，比如把默认的int64转成float32，把float32转成float16做轻量化。pytorch提供了两种类型转换方法，一种通用万能（推荐掌握），一种针对性便捷（适合有java基础的同学），下面详细讲解。

4.1 万能转换法：type()函数（强推）

type()函数是pytorch中张量类型转换的通用方法，支持任意类型之间的转换，只需在函数中传入目标类型torch.xxx即可，语法简单、记忆成本低，是新手必掌握的方法。

代码实操：type()函数转换示例

import torch

# 第一步：创建基础张量（float32类型）
t = torch.tensor([1,2,3,4,5], dtype=torch.float32)
print(f"原始类型：{t.dtype}")  # 输出：torch.float32

# 转换为int16类型
t_int16 = t.type(torch.int16)
print(f"转换为int16：{t_int16.dtype}")  # 输出：torch.int16

# 转换为float16类型
t_float16 = t.type(torch.float16)
print(f"转换为float16：{t_float16.dtype}")  # 输出：torch.float16

# 转换为float64类型
t_float64 = t.type(torch.float64)
print(f"转换为float64：{t_float64.dtype}")  # 输出：torch.float64

# 转换为int64类型
t_int64 = t.type(torch.int64)
print(f"转换为int64：{t_int64.dtype}")  # 输出：torch.int64

核心优势：无论是什么原始类型，只需改变type()中的目标参数，就能实现任意转换，无需记忆多个函数，一招鲜吃遍天

4.2 便捷转换法：专属类型函数

pytorch为每种常用类型都提供了专属的转换函数，比如half()、float()、double()、short()等，这些函数的命名和java中的基本类型转换高度相似，有java基础的同学会很容易上手。

需要注意的是，这类函数无需传入参数，调用后直接将张量转换为对应类型，下面是具体的函数与类型对应关系，再配合代码实操理解

专属函数与类型对应表

专属转换函数	转换后的目标类型	等价type()写法
tensor.half()	torch.float16	tensor.type(torch.float16)
tensor.float()	torch.float32	tensor.type(torch.float32)
tensor.double()	torch.float64	tensor.type(torch.float64)
tensor.short()	torch.int16	tensor.type(torch.int16)
tensor.int()	torch.int32	tensor.type(torch.int32)
tensor.long()	torch.int64	tensor.type(torch.int64)

代码实操：专属函数转换示例

import torch

# 创建基础张量（int16类型）
t = torch.tensor([1,2,3,4,5], dtype=torch.int16)
print(f"原始类型：{t.dtype}")  # 输出：torch.int16

# half() → float16
t_half = t.half()
print(f"half()转换：{t_half.dtype}")  # torch.float16

# float() → float32
t_float = t.float()
print(f"float()转换：{t_float.dtype}")  # torch.float32

# double() → float64
t_double = t.double()
print(f"double()转换：{t_double.dtype}")  # torch.float64

# short() → int16（原类型，无变化）
t_short = t.short()
print(f"short()转换：{t_short.dtype}")  # torch.int16

# int() → int32
t_int = t.int()
print(f"int()转换：{t_int.dtype}")  # torch.int32

# long() → int64
t_long = t.long()
print(f"long()转换：{t_long.dtype}")  # torch.int64

4.3 两种转换方法的对比🆚

为了让大家更清晰区分两种转换方法的优劣、精准匹配自身使用场景，我用mermaid流程图做了直观可视化对比，核心优缺点与适配人群一目了然，新手也能快速选对方法

图表核心解读：左侧通用type()函数主打一个“全能适配”，不需要额外记忆多个函数，完全贴合深度学习新手的学习路径，哪怕后续遇到特殊类型转换也能轻松应对；右侧专属函数写法更简洁，适合有java基础的同学快速简写，但场景局限性更强。日常做pytorch项目开发，优先吃透type()函数，足以搞定99%的张量类型转换需求，稳妥又高效