pytorch 学习之 Tensor 基础

最新推荐文章于 2024-03-08 09:55:05 发布
最新推荐文章于 2024-03-08 09:55:05 发布
阅读量563 收藏 3
点赞数 1
分类专栏： pytorch 文章标签： pytorch tensor
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maizousidemao/article/details/108412967
版权

tensor作为pytorch的基本操作对象，是首先要了解的。

一、tensor的8个属性：

# 数据相关
t.data		# tensor的数据
t.dtype		# tensor的数据类型
t.shape		# tensor的形状
t.device	# tensor所在的设备

# 梯度相关
t.grad			# data的梯度
t.grad_fn		# 创建tensor的function
t.requires_grad	# 是否需要求导
t.is_leaf		# 是否是叶子结点

二、tensor的创建：

1. 直接创建
t = torch.tensor([[0, 5, 4, 5, 8, 9], [2, 7, 5, 8, 8, 6]])
2. 从ndarray创建（ndarray转tensor）
# 创建的tensor和原来的ndarray共享内存
arr = np.array([[1, 3, 3], [4, 5, 6]])
t = torch.from_numpy(arr)
3. 创建全0张量（可用于对张量初始化）
# 创建3*3的全0张量
t = torch.zeros((3, 3))
# 按照input的形状创建全0张量
t1 = torch.zeros_like(input)
4. 创建全1张量
# 创建3*3的全1张量
t = torch.ones((3, 3))
# 按照input的形状创建全1张量
t1 = torch.ones_like(input)
5. 创建自定义全值张量
# 创建3*3的全5张量，需是float，int会报warning
t = torch.full((3, 3), 5.)
# 按照input的形状创建全6张量
t1 = torch.full_like(input, 6)
6. 创建等差1维张量
# 步长为2的等差数列1维张量,范围[0,10)
t = torch.arange(0, 10, 2)
7. 创建均分1维张量
# 创建均分1维张量，范围[0,10]，长度默认100
t = torch.linspace(0, 10)
# 创建均分1维张量，范围[0,10]，长度5
t1 = torch.linspace(0, 10, steps=5)

---------------------- output ----------------------
tensor([ 0.0000,  0.1010,  0.2020,  0.3030,  0.4040,  0.5051,  0.6061,  0.7071,
         0.8081,  0.9091,  1.0101,  1.1111,  1.2121,  1.3131,  1.4141,  1.5152,
         1.6162,  1.7172,  1.8182,  1.9192,  2.0202,  2.1212,  2.2222,  2.3232,
         2.4242,  2.5253,  2.6263,  2.7273,  2.8283,  2.9293,  3.0303,  3.1313,
         3.2323,  3.3333,  3.4343,  3.5354,  3.6364,  3.7374,  3.8384,  3.9394,
         4.0404,  4.1414,  4.2424,  4.3434,  4.4444,  4.5455,  4.6465,  4.7475,
         4.8485,  4.9495,  5.0505,  5.1515,  5.2525,  5.3535,  5.4545,  5.5556,
         5.6566,  5.7576,  5.8586,  5.9596,  6.0606,  6.1616,  6.2626,  6.3636,
         6.4646,  6.5657,  6.6667,  6.7677,  6.8687,  6.9697,  7.0707,  7.1717,
         7.2727,  7.3737,  7.4747,  7.5758,  7.6768,  7.7778,  7.8788,  7.9798,
         8.0808,  8.1818,  8.2828,  8.3838,  8.4848,  8.5859,  8.6869,  8.7879,
         8.8889,  8.9899,  9.0909,  9.1919,  9.2929,  9.3939,  9.4949,  9.5960,
         9.6970,  9.7980,  9.8990, 10.0000])
tensor([ 0.0000,  2.5000,  5.0000,  7.5000, 10.0000])
8. 创建对数均分1维张量
# 创建对数均分1维张量，范围[0,10]，长度默认100，底默认10
# 在区间 base^(start)和 base^(end) 上按照 [start,end] 均分的 steps 个点
t = torch.logspace(0, 4, steps=2, base=2)

---------------------- output ----------------------
tensor([1., 16.])
9. 创建单位对角阵张量
t = torch.eye(3)
t = torch.eye(2, 3)
依概率分布创建张量
10. 正态分布（高斯分布）
# mean:张量 std:张量
# 此时mean和std维数（n）要相等，由他们生成n个正态分布，
# 从每个分布随机抽取一个数，组成一个1维张量
mean = torch.arange(1, 5, dtype=torch.float)
std = torch.arange(1, 5, dtype=torch.float)
t_normal = torch.normal(mean, std)
print(t_normal)
---------------------- output ----------------------
tensor([1.2151, 1.2076, 3.8062, 9.3667])
-------------------- end output --------------------

# mean:标量 std:标量
# 生成1个分布，随机取size大小的数
# 1维
t_normal = torch.normal(0, 1, size=(4,))
# 4*2维
t_normal1 = torch.normal(0, 1, size=(4, 2))
print(t_normal)
print(t_normal1)
---------------------- output ----------------------
tensor([0.2177, 0.1591, 1.2840, 0.8412])
tensor([[ 0.9582,  1.6487],
        [-1.0021,  2.0398],
        [ 0.2099,  0.9041],
        [ 2.0284, -0.2725]])
-------------------- end output --------------------

# mean:张量 std:标量
# 生成同mean大小个分布，所有分布的std相同
# 从每个分布随机抽取一个数，组成一个1维张量
# mean:标量 std:张量 同理
mean = torch.arange(1, 5, dtype=torch.float)
# 1维
t_normal = torch.normal(mean, 1)
print(t_normal)
---------------------- output ----------------------
tensor([ 1.0105, -0.4155,  3.2346,  2.8099])
-------------------- end output --------------------
11. 标准正态分布(mean=0, std=1)
# 由于均值和标准差都确定了，所以只需size就可以创建
t_normal = torch.randn(2, 3)
12. 均匀分布
# 默认在区间[0,1)上，生成标准均匀分布
# 以下两个是等效的
# 生成2*3的tensor
t_normal = torch.rand(2, 3)
t_normal1 = torch.rand(size=(2, 3))
# torch.rand_like()

# 在区间[low,high)上，生成整数均匀分布
t_normal_int = torch.randint(2, 13, size=(5,))
# output: tensor([4, 3, 9, 5, 5])
# torch.randint_like()
13. 创建0到n-1的整数随机排列
# 常用来生成乱序索引
# 返回1维张量
t_normal = torch.randperm(5)

---------------------- output ----------------------
tensor([1, 4, 2, 3, 0])
14. 伯努利分布/0-1分布/两点分布
input = torch.rand(1, 6)
t_normal = torch.bernoulli(input)
# p 为概率，此时input的概率作用失效
t_normal1 = torch.bernoulli(input, p=0)

---------------------- output ----------------------
tensor([[0., 1., 1., 1., 0., 0.]])
tensor([[0., 0., 0., 0., 0., 0.]])

三、tensor的操作方法：

拼接
1. 将tensor按维度进行拼接 torch.cat()
import torch

# torch.cat(tensors, 	# 张量序列
#           dim=0,  	# 要拼接的维度
#           out=None)
t = torch.ones((2, 3))
t_0 = torch.cat([t, t], dim=0)
t_1 = torch.cat([t, t], dim=1)

---------------------- output ----------------------
t:tensor([[1., 1., 1.],
        [1., 1., 1.]]) shape:torch.Size([2, 3])
t_0:tensor([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]]) shape:torch.Size([4, 3])
t_1:tensor([[1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1.]]) shape:torch.Size([2, 6])

2. 在新创建的维度上进行拼接 torch.stack()

import torch

# torch.stack(tensors,	# 张量序列
#             dim=0,	# 要拼接的维度
#             out=None)
t = torch.ones((3, 4))
t_stack_0 = torch.stack([t, t], dim=0)
t_stack_1 = torch.stack([t, t], dim=2)

---------------------- output ----------------------
t:tensor([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]]) shape:torch.Size([3, 4])
t_stack_0:tensor([[[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]],

        [[1., 1., 1., 1.],
         [1., 1., 1., 1.],
         [1., 1., 1., 1.]]]) shape:torch.Size([2, 3, 4])
t_stack_1:tensor([[[1., 1.],
         [1., 1.],
         [1., 1.],
         [1., 1.]],

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

        [[1., 1.],
         [1., 1.],
         [1., 1.],
         [1., 1.]]]) shape:torch.Size([3, 4, 2])
分割

1. 将tensor按维度进行平均切分 torch.chunk()

# torch.chunk(input, 	# 要切分的张量
#             chunks, 	# 要切分的分数
#             dim=0) 	# 要切分的维度
# 返回张量列表
# 若不能整除，最后一份小于其他张量
a = torch.ones((2, 5))
list_of_tensors = torch.chunk(a, chunks=3, dim=1)
print(a)

for idx, t in enumerate(list_of_tensors):
print("第{}个张量：{}，shape is {}".format(idx + 1, t, t.shape))

---------------------- output ----------------------
tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])
第1个张量：tensor([[1., 1.],
        [1., 1.]])，shape is torch.Size([2, 2])
第2个张量：tensor([[1., 1.],
        [1., 1.]])，shape is torch.Size([2, 2])
第3个张量：tensor([[1.],
        [1.]])，shape is torch.Size([2, 1])

2. 将tensor按维度进行切分，可指定切分的长度 torch.split()

# torch.split(tensor,
#             split_size_or_sections, # 为int时，表示每一份的长度；为list时，按list元素切分
#             dim=0)

a = torch.ones((2, 5))
print(a)

# 为 int
# list_of_tensors = torch.split(a, 3, dim=1)
# 为 list, list各项和，需等于原tensor的长度，否则报错
list_of_tensors = torch.split(a, [1, 3, 1], dim=1)
for idx, t in enumerate(list_of_tensors):
	print("第{}个张量：{}，shape is {}".format(idx + 1, t, t.shape))
	
---------------------- output ----------------------
tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])
第1个张量：tensor([[1.],
        [1.]])，shape is torch.Size([2, 1])
第2个张量：tensor([[1., 1., 1.],
        [1., 1., 1.]])，shape is torch.Size([2, 3])
第3个张量：tensor([[1.],
        [1.]])，shape is torch.Size([2, 1])
索引

1. 根据 index

# torch.index_select(input,		# 要操作的tensor
#					dim,		# 要索引的维度
#					index,		# 索引，int或list
#					out=None)
					
a = torch.randint(0, 9, size=(3, 3))

# 按行索引，0行和2行
# index_select的index必须是long(int64)类型
inx = torch.tensor([0, 2], dtype=torch.long)

t_select = torch.index_select(a, dim=0, index=inx)
print("{}\n{}".format(a, t_select))

---------------------- output ----------------------
tensor([[8, 4, 5],
        [5, 3, 5],
        [5, 0, 7]])
tensor([[8, 4, 5],
        [5, 0, 7]])

2. 根据 mask

# torch.masked_select(input,
#                     mask, # 与input同形状的布尔类型张量
#                     out=None)
# 通常用来筛选数据，找出所有符合要求的项，返回1维张量

a = torch.randint(0, 9, size=(3, 3))
# 对a中数据进行判断，大于等于5为True
# ge means greater than or equal, gt:greater than. le lt
mask = a.ge(5)
t_select = torch.masked_select(a, mask)
print("a:{}\nmask:{}\nt_select:{}".format(a, mask, t_select))
万俟淋曦
关注
专栏目录
Pytorch 基础-tensor 数据结构
专注计算机视觉算法训练，算法优化部署以及SDK开发的知识分享。
09-09 1429
torch.Tensor 是一种包含单一数据类型元素的多维矩阵，类似于 numpy 的 array。 Tensor 可以使用 torch.tensor() 转换 Python 的 list 或序列数据生成，生成的是dtype 默认是 torch.FloatTensor。
pytorch每日一学15(torch.as_strided())根据步长创建一个现有tensor的视图
Fluid_ray的博客
11-13 4889
第15个方法 torch.as_strided(input, size, stride, storage_offset=0)—>Tensor 此方法是根据现有tensor以及给定的步长来创建一个视图（类型仍然为tensor）。 视图   视图是指创建一个方便查看的东西，与原数据共享内存，它并不占用内存，也不存储数据，只是将原有的数据进行整理，显示其中部分内容或者进行重排序后显示出来等等。 接下来介绍此方法，首先看一个示例： 这样创建出来的b就是a的一个视图，可以发现，b中的元素都是a中的元素，
PyTorch学习笔记：torch.ge、torch.gt、torch.le、torch.lt、torch.ne、torch.eq
qq_50001789的博客
02-10 2731
PyTorch学习笔记：torch.ge、torch.gt、torch.le、torch.lt、torch.ne、torch.eq，逐元素对比
torch.lt(input, other, out=None)和lt(other)的使用举例
敲代码的小风
12-30 1141
参考链接: torch.lt(input, other, out=None) → Tensor 参考链接: lt(other) → Tensor 函数使用说明: 两个可广播的张量之间进行逐元素比较操作, 判断是否满足小于的条件. 代码实验举例: Microsoft Windows [版本 10.0.18363.1256] (c) 2019 Microsoft Corporation。保留所有权利。 C:\Users\chenxuqi>conda activate ssd4pytorch1_2_0
PyTorch基础（20）-- torch.gt() / torch.ge() / torch.le() / torch.lt()方法
最新发布
奋斗の博客
03-08 1194
嗯……最近遇到的奇奇怪怪的方法很多了，学无止境啊！学不完啊，根本学不完！torch.gt()、torch.ge()、torch.le()和torch.lt()方法，由于这四个方法很相似，所以放到一块解析了！函数作用inputotherinput≥otherinput≤otherinputother。
Pytorch中tensor.T（torch.T）解析
flyingluohaipeng的博客
05-30 2542
一. tensor.T解析 1. 说明： tensor.T表示对tensor张量进行转置 2. 代码例子 2.1 一维张量转置（与原张量相同） a = torch.randn(3) a,a.T 结果如下所示： (tensor([ 1.62, -0.06, -1.31]), tensor([ 1.62, -0.06, -1.31])) 2.2 二维张量转置 a = torch.randn(2,3) a,a.T #a.T结果由两行三列变成三行两列 结果如下所示： (tensor([[-1.14, 0.3
pytorch学习——Tensor
weixin_44170204的博客
11-02 542
pytorch的学习，Tensor基础
Pytorch 之修改Tensor部分值方式
09-18
Pytorch是一个广泛使用的深度学习框架，其中Tensor是其核心数据结构，类似于NumPy的ndarray，但是可以...通过这篇文章，初学者可以快速掌握如何在Pytorch中操作Tensor，从而为后续的深度学习模型训练打下坚实的基础。
PyTorch & Tensor基础必学
05-03
在深入探讨PyTorch与Tensor的基础知识之前，我们先理解一下这两个概念的重要性。PyTorch是Facebook开源的一个深度学习框架，以其灵活性、易用性和强大的动态计算图功能而备受推崇。Tensor则是PyTorch中的核心数据...
pytorch 实现删除tensor中的指定行列
09-18
在PyTorch中，操作张量（Tensor）是深度学习模型构建的基础，而有时我们需要根据需求删除张量中的特定行或列。标题和描述中提到的问题是如何在PyTorch中实现这一功能。虽然PyTorch并没有提供直接删除指定行列的函数...
Pytorch：输出整个tensor的方法
热门推荐
qq_39355160的博客
05-19 3万+
Pytorch：输出整个tensor的方法 torch.set_printoptions(profile="full") print(x) # prints the whole tensor torch.set_printoptions(profile="default") # reset print(x) # prints the truncated tensor 将这个代码放在import torch之后就可以了，full代表输出所有，deflaut是默认输出部分 ...
TensorFlow之Tensor对象
大脸猫的博客
01-26 1012
Tensor翻译成中文是指张量，tf.Tensor对象是数据对象的句柄。数据对象包括输入的常量和变量，以及计算节点的输出数据对象。所有Python语言中的常见类型的数据需要转为TensorFlow中的Tensor对象后，才能使用TensorFlow框架中的计算节点。 Tensor翻译成中文是指张量，零维度张量表示的是标量，一维张量表示的是向量，二维张量表示的是矩阵。TensorFlow中，训练卷...
pytorch Tensor及其基本操作 01
溪c的博客
05-30 1204
文章目录1. Tensor 属性1.1 Tensor(张量）的属性torch.dtypetorch.devicetorch.layout2. Tensor类型操作2.1 Tensor类型判断torch.is_tensor(obj)torch.is_storage(obj)2.2 类型设置torch.set_default_dtype(d)torch.get_default_dtype()Tensor.dtype属性2.3 类型转换Tensor.to(...)3 Tensor 基本属性获取3.1 基本属性获取
Tensorflow中Tensor对象的常用方法（持续更新）
思念殇千寻的博客
05-31 315
　　Tensor是Tensorflow中重要的对象。下面是Tensor的常用方法，后面还会写一篇随笔记录Variable的用法。 　　1. 生成一个（常）Tensor对象 >>>A = tf.constant(4) >>>B = tf.constant([[1, 2], [3, 4])) >>>A <tf.Tensor: ...
【pytorch】 获得索引的方法
luolinll1212的专栏
08-30 1万+
运算 函数 大于 torch.gt 小于 torch.lt 等于 torch.eq ...
PyTorch 生成随机数Tensor（标准分布、标准正态、离散正态……）
MarsLee_U的博客
06-02 3万+
在使用PyTorch做实验时经常会用到生成随机数Tensor的方法，比如：torch.rand()torch.randn()torch.normal()torch.linespace()均匀分布torch.rand(*sizes, out=None) → Tensor返回一个张量，包含了从区间[0, 1)的均匀分布中抽取的一组随机数。张量的形状由参数sizes定义。参数:sizes (int…) ...
torch.max用法（指定维度dim）
路过人间，一叶知秋
10-26 4052
torch中的dim和numpy中的axis是一个东西，通过理解axis来理解dim，一举两得。
tensor基础操作及用法
韩绘锦的博客
02-17 2888
2.2 数据操作 import torch torch.manual_seed(0) torch.cuda.manual_seed(0) print(torch.__version__) 0.4.1 2.2.1 创建Tensor 创建一个5x3的未初始化的Tensor： x = torch.empty(5, 3) print(x) tensor([[0.0000e+00, 1.0842e-...
TensorFlow生成常量，序列和随机值
qq_38446366的博客
06-20 1680
注意：接受 Tensor 参数的函数也可以接受任何接受的内容 tf.convert_to_tensor. 常数值张量 TensorFlow 提供了几种可用于生成常量的操作. tf.zeros 创建一个所有元素都设置为零的张量. 该操作返回一个带有形状shape的类型为dtype张量,并且所有元素都设为零. 原型： tf.zeros( shape, dtype=tf.float32,...
PyTorch基础：Tensor操作入门
"PyTorch基础知识" PyTorch是一个广泛使用的深度学习框架，它以其灵活性、易用性和高效性在人工智能研究和开发中占据了一席之地。本资源主要介绍了PyTorch中的基本概念，特别是张量（Tensor）的创建和操作。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

万俟淋曦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值