PyTorch教程（1）张量以及张量操作

最新推荐文章于 2024-05-29 12:43:52 发布
最新推荐文章于 2024-05-29 12:43:52 发布
阅读量2.1k 收藏 10
点赞数 2
分类专栏： PyTorch 文章标签： pytorch python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43229348/article/details/119242954
版权

PyTorch有各种组件：

  • Torch有与NumPy类似的功能，但是支持GPU。
  • torch.autograd提供了用于实现任意标量值函数的自动微分的类、方法和函数。它只需要对现有代码进行最小的更改。你只需要声明class:‘Tensor’，它的梯度应该用requires_grad=True关键字计算。
  • NN是PyTorch中的一个神经网络库
  • Optim提供用于函数最小化和最大化的优化算法。
  • Multiprocessing是一个用于在多个张量之间共享内存的有用库。
  • Utils有加载数据的实用函数;它还有其他功能。

使用张量

PyTorch中使用的数据结构是基于图和张量的，因此理解基本运算和定义张量非常重要。
让我们看一下以下张量和张量运算基础的例子，包括数学运算。
对象x是一个列表。我们可以使用下面的语法来检查Python中的一个对象是否是一个张量对象。通常，is_tensor函数和is_storage函数检查对象是否被存储为张量对象。

import torch
x = [12, 13, 14, 15, 56,57,58]
print(torch.is_tensor(x))
# False
print(torch.is_storage(x))
# False

现在，让我们创建一个包含来自Torch的随机数的对象，类似于NumPy库。我们可以检查张量和存储类型。

import torch
x = torch.randn(1,2,3,4,5)
print(torch.is_tensor(x))
# True
print(torch.is_storage(x))
# False
print(torch.numel(x))
# 120

x是一个张量;但是，它不会被存储。为了检查输入张量对象中的元素总数，可以使用数值元素函数。

像NumPy操作一样，eye函数创建一个对角矩阵，其中对角元素为1，非对角元素为0。eye函數可以通过提供形状选项进行操作。下面的示例演示如何提供形状参数。

import torch
print(torch.eye(3,4))
# tensor([[1., 0., 0., 0.],
#        [0., 1., 0., 0.],
#        [0., 0., 1., 0.]])

线性空间和线性空间之间的点可以用张量操作来创建。让我们使用一个例子，在一个线性空间中创建25个点，从值2开始，以10结束。Torch可以讀取一个NumPy数组格式。

import torch
import numpy as np
x = torch.randn(1,2,3)
x1=np.array(x)
print(x)
x2 = torch.from_numpy(x1)
print(x2)
x3 = torch.linspace(2,10,steps=25)
print(x3)
# tensor([[[-1.1404,  1.7232,  0.3831],
#         [-0.0787, -0.7935, -0.4067]]])
# tensor([[[-1.1404,  1.7232,  0.3831],
#         [-0.0787, -0.7935, -0.4067]]])
# tensor([ 2.0000,  2.3333,  2.6667,  3.0000,  3.3333,  3.6667,  4.0000,  4.3333,
#         4.6667,  5.0000,  5.3333,  5.6667,  6.0000,  6.3333,  6.6667,  7.0000,
#         7.3333,  7.6667,  8.0000,  8.3333,  8.6667,  9.0000,  9.3333,  9.6667,
#        10.0000])

随机数生成是数据科学中常见的生成或收集空间样本数据点以模拟数据中的结构的过程。随机数可以由统计分布、任意两个值或预定义的分布生成。与NumPy函数一样，可以使用以下示例生成随机数。均匀分布是指每个结果发生的概率相等的分布;因此，事件概率是常数。

import torch
print(torch.rand(10))
# tensor([0.2826, 0.6338, 0.7633, 0.8168, 0.7536, 0.3857, 0.5816, 
#         0.6116, 0.1355,0.3790])

算术平均值为0，标准差为1的正态分布的随机数也可以如下创建。

import torch
print(torch.randn(2,3))
print(torch.randn(5))
# tensor([[ 0.8980, -0.5173,  0.4493],
#         [-0.4232, -0.4060, -0.0471]])
# tensor([-0.4057, -0.0752, -1.2323, -0.3223, -0.0600])

要使用随机排列从值的范围中选择随机值，需要首先定义范围。这个范围可以通过使用arrange函数创建。在使用arrange函数时，必须定义步长，将所有值放置在相等的距离空间中。缺省情况下，步长为1。

import torch
print(torch.randperm(10))
print(torch.arange(10,40,2))
print(torch.arange(10,20))
# tensor([4, 3, 9, 6, 0, 5, 8, 2, 7, 1])
# tensor([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38])
# tensor([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

为了求一维张量的最小值和最大值，可以使用argmin和argmax。如果输入是一个矩阵，以便沿着行或列搜索最小值，则需要提到维数。

import torch
d = torch.randn(2,3)
print(d)
print(torch.argmin(d,dim=1))
print(torch.argmax(d,dim=1))
# tensor([[-0.8461,  0.6282, -0.0616],
#        [-0.2727,  0.6879, -0.7773]])
# tensor([0, 2])
# tensor([1, 1])

如果它是行或列，则它是一个维度，称为一维张量。如果输入是一个矩阵，其中有行和列，它被称为2D张量。如果它大于二维，就称为多维张量。

现在，让我们创建一个二维张量样本，并通过对张量的连接操作来执行索引和连接。

import torch
x = torch.randn(2,3)
print(x)
print(torch.cat((x,x)))
# tensor([[-0.6394, -1.7363, -0.9337],
#         [-0.4853, -0.5483,  0.9684]])
# tensor([[-0.6394, -1.7363, -0.9337],
#         [-0.4853, -0.5483,  0.9684],
#         [-0.6394, -1.7363, -0.9337],
#         [-0.4853, -0.5483,  0.9684]])

print(torch.cat((x,x,x), 1))
# tensor([[-0.6394, -1.7363, -0.9337, -0.6394, -1.7363, -0.9337, -0.6394, -1.7363, -0.9337],
#         [-0.4853, -0.5483,  0.9684, -0.4853, -0.5483,  0.9684, -0.4853, -0.5483, 0.9684]])
print(torch.cat((x,x), 0))
# tensor([[-0.6394, -1.7363, -0.9337],
#         [-0.4853, -0.5483,  0.9684]])
# tensor([[-0.6394, -1.7363, -0.9337],
#         [-0.4853, -0.5483,  0.9684],
#         [-0.6394, -1.7363, -0.9337],
#         [-0.4853, -0.5483,  0.9684]])

张量可以被分割成多个块。这些小块可以沿着行和列创建。下面的例子显示了一个大小为(4,4)的样本张量。块是使用函数中的第三个参数创建的，如0或1。

import torch
a = torch.randn(3,4)
print(a)
print(torch.chunk(a,2))
# tensor([[-1.1775, -0.4398, -0.7885, -0.3994],
#         [-0.0575,  1.0633,  0.0104, -1.1750],
#         [ 0.9005,  0.5154,  0.2212,  2.0248]])
# (tensor([[-1.1775, -0.4398, -0.7885, -0.3994],
#          [-0.0575,  1.0633,  0.0104, -1.1750]]),
# tensor([[0.9005, 0.5154, 0.2212, 2.0248]]))
print(torch.chunk(a,2, 0))
# tensor([[-1.1775, -0.4398, -0.7885, -0.3994],
#         [-0.0575,  1.0633,  0.0104, -1.1750],
#         [ 0.9005,  0.5154,  0.2212,  2.0248]])
# (tensor([[-1.1775, -0.4398, -0.7885, -0.3994],
#          [-0.0575,  1.0633,  0.0104, -1.1750]]),
# tensor([[0.9005, 0.5154, 0.2212, 2.0248]]))
print(torch.chunk(a,2, 1))
# (tensor([[-1.1775, -0.4398],
#          [-0.0575,  1.0633],
#          [ 0.9005,  0.5154]]), 
#  tensor([[-0.7885, -0.3994],
#          [ 0.0104, -1.1750],
#          [ 0.2212,  2.0248]]))

gather函数从一个张量中收集元素，并使用索引参数将其放到另一个张量中。指标位置由PyTorch中的LongTensor张量函数确定。

# input(tensor):   待操作数。不妨设其维度为（x1, x2, …, xn）
# dim(int):   待操作的维度。
# index(LongTensor):   如何对input进行操作。其维度有限定，例如当dim=i时，# index的维度为（x1, x2, …y, …,xn），既是将input的第i维的大小更改为y，且
# 要满足y>=1（除了第i维之外的其他维度，大小要和input保持一致）。
# out:   注意输出和index的维度是一致的
# out[i][j][k] = input[index[i][j][k]][j][k]  # if dim == 0
# out[i][j][k] = input[i][index[i][j][k]][k]  # if dim == 1
# out[i][j][k] = input[i][j][index[i][j][k]]  # if dim == 2

import torch
x = torch.Tensor([[11,12],[23,24]])
print(x)
y = torch.gather(x, 1, torch.LongTensor([[0,0],[1,0]]))
print(y)
# tensor([[11., 12.],
#         [23., 24.]])
# tensor([[11., 11.],
#         [24., 23.]])

LongTensor张量函数或index选择函数可用于从张量获取相关值。下面的示例代码显示了两个选项:沿行选择和沿列选择。如果第二个参数为0，则它用于行。如果它是1，那么它沿着列。

import torch
a = torch.randn(4, 4)
print(a)
indices=torch.LongTensor([0,2])
print(torch.index_select(a,0,indices))
# tensor([[-0.5025,  0.4290, -1.6302,  0.1779],
#         [ 2.6009,  0.1825, -0.6760,  1.2428],
#         [ 0.7389, -0.3886,  0.3135,  1.5179],
#         [-0.5978, -1.2262,  1.0765, -0.0700]])
# tensor([[-0.5025,  0.4290, -1.6302,  0.1779],
#         [ 0.7389, -0.3886,  0.3135,  1.5179]])
print(torch.index_select(a,1,indices))
# tensor([[-0.5025, -1.6302],
#         [ 2.6009, -0.6760],
#         [ 0.7389,  0.3135],
#         [-0.5978,  1.0765]])

检查张量中的非零元素是一种常见的方法，其目的是确定一个张量中的非零元素。

import torch
print(torch.nonzero(torch.tensor([10,00,23,0,0.0])))
# tensor([[0],
#         [2]])
print(torch.nonzero(torch.Tensor([10,00,23,0,0.0])))
# tensor([[0],
#         [2]])

将输入张量重构为更小的张量不仅可以简化计算过程，而且有助于分布式计算。split函数把一个张量分裂成更小的张量。

import torch 
print(torch.split(torch.tensor([12,23,34,56,78,78,89]), 2))
# (tensor([12, 23]), tensor([34, 56]), tensor([78, 78]), tensor([89]))
print(torch.split(torch.tensor([12,23,34,56,78,78,89]), 3))
# (tensor([12, 23, 34]), tensor([56, 78, 78]), tensor([89]))

现在，让我们看一个例子，看看输入张量如何在计算困难的情况下调整大小。转置函数主要用于重塑张量。转置函数有两种写法.t和.transpose 。

import torch
x = torch.randn(2, 3)
print(x)
print(x.t())
print(x.transpose(1,0))
# tensor([[ 0.7303, -0.5896, -0.5453],
#         [-0.3005, -0.3102, -1.3666]])
# tensor([[ 0.7303, -0.3005],
#         [-0.5896, -0.3102],
#         [-0.5453, -1.3666]])
# tensor([[ 0.7303, -0.3005],
#         [-0.5896, -0.3102],
#         [-0.5453, -1.3666]])

解绑定函数从张量中除去一个维数。要删除维度行，需要传递0值。要删除列，需要传递1值。

import torch
x = torch.randn(2, 3)
print(x)
print(torch.unbind(x,1))
# tensor([[ 0.8387,  0.3207, -0.1184],
#         [-1.0266, -1.1429, -0.4148]])
# (tensor([ 0.8387, -1.0266]), 
#  tensor([ 0.3207, -1.1429]), 
#  tensor([-0.1184, -0.4148]))
print(torch.unbind(x,0))
# (tensor([ 0.8387,  0.3207, -0.1184]), 
#  tensor([-1.0266, -1.1429, -0.4148]))

算術運算

import torch
x = torch.randn(2, 3)
print(x)
print(torch.add(x, 20))
# tensor([[ 0.2973,  0.0619, -0.8902],
#         [-0.5823,  1.7563, -0.7741]])
# tensor([[20.2973, 20.0619, 19.1098],
#         [19.4177, 21.7563, 19.2259]])
print(torch.mul(x,2))
# tensor([[ 0.5946,  0.1237, -1.7804],
#         [-1.1646,  3.5126, -1.5481]])

组合数学运算，例如将线性方程表示为张量运算，可以使用下面的示例脚本完成。这里我们将结果y表示为值乘以独立的x的线性组合，加上常数项。

import torch
intercept = torch.randn(1)
print(intercept)
x = torch.randn(2,2)
print(x)
beta=0.7
# OUTPUT=Constant + (beta*Independent)
print(torch.mul(intercept,x))
# y = intercept + (beta * x)
print(torch.add(intercept, torch.mul(x,beta)))
# tensor([-2.4064])
# tensor([[ 0.5145,  0.3955],
#         [ 2.8828, -1.9659]])
# tensor([[-1.2381, -0.9517],
#         [-6.9371,  4.7307]])
# tensor([[-2.0462, -2.1295],
#         [-0.3884, -3.7825]])

与NumPy操作一样，张量必须通过使用ceiling或flooring函数进行四舍五入。

import torch
torch.manual_seed(1234)
x = torch.randn(5,5)
print(x)
# tensor([[-0.1117, -0.4966,  0.1631, -0.8817,  0.0539],
#         [ 0.6684, -0.0597, -0.4675, -0.2153, -0.7141],
#         [-1.0831, -0.5547,  0.9717, -0.5150,  1.4255],
#         [ 0.7987, -1.4949,  1.4778, -0.1696, -0.9919],
#         [-1.4569,  0.2563, -0.4030,  0.4195,  0.9380]])
torch.manual_seed(1234)
x = torch.ceil(torch.randn(5,5))
print(x)
# tensor([[-0., -0.,  1., -0.,  1.],
#         [ 1., -0., -0., -0., -0.],
#         [-1., -0.,  1., -0.,  2.],
#         [ 1., -1.,  2., -0., -0.],
#         [-1.,  1., -0.,  1.,  1.]])
torch.manual_seed(1234)
x = torch.floor(torch.randn(5,5))
print(x)
# tensor([[-1., -1.,  0., -1.,  0.],
#         [ 0., -1., -1., -1., -1.],
#         [-2., -1.,  0., -1.,  1.],
#         [ 0., -2.,  1., -1., -1.],
#         [-2.,  0., -1.,  0.,  0.]])

在一定范围内限制任何张量的值可以使用最小和最大参数以及使用clamp函数来完成。下面的示例显示了2D场景中的实现。

import torch
torch.manual_seed(1234)
y = torch.clamp(torch.floor(torch.randn(5,5)), min=0.3, max=0.4)
print(y)
# tensor([[0.3000, 0.3000, 0.3000, 0.3000, 0.3000],
#         [0.3000, 0.3000, 0.3000, 0.3000, 0.3000],
#         [0.3000, 0.3000, 0.3000, 0.3000, 0.4000],
#         [0.3000, 0.3000, 0.4000, 0.3000, 0.3000],
#         [0.3000, 0.3000, 0.3000, 0.3000, 0.3000]])
torch.manual_seed(1234)
y = torch.clamp(torch.floor(torch.randn(5,5)), min=0.3)
print(y)
# tensor([[0.3000, 0.3000, 0.3000, 0.3000, 0.3000],
#         [0.3000, 0.3000, 0.3000, 0.3000, 0.3000],
#         [0.3000, 0.3000, 0.3000, 0.3000, 1.0000],
#         [0.3000, 0.3000, 1.0000, 0.3000, 0.3000],
#         [0.3000, 0.3000, 0.3000, 0.3000, 0.3000]])
torch.manual_seed(1234)
y = torch.clamp(torch.floor(torch.randn(5,5)), max=0.3)
print(y)
# tensor([[-1.0000, -1.0000,  0.0000, -1.0000,  0.0000],
#         [ 0.0000, -1.0000, -1.0000, -1.0000, -1.0000],
#         [-2.0000, -1.0000,  0.0000, -1.0000,  0.3000],
#         [ 0.0000, -2.0000,  0.3000, -1.0000, -1.0000],
#         [-2.0000,  0.0000, -1.0000,  0.0000,  0.0000]])

我们如何得到一个张量的指数?如果张量有小数位,我们如何得到它的小数部分并且被定义为浮点数据类型?

import torch
torch.manual_seed(1234)
x = torch.randn(2,3)
print(x)
# tensor([[ 0.0461,  0.4024, -1.0115],
#         [ 0.2167, -0.6123,  0.5036]])
print(torch.exp(x))
# tensor([[1.0472, 1.4954, 0.3637],
#         [1.2420, 0.5421, 1.6547]])
import numpy as np
print(np.exp(x))
# tensor([[1.0472, 1.4954, 0.3637],
#         [1.2420, 0.5421, 1.6547]])
print(np.exp(np.array(x)))
# [[1.0472, 1.4954, 0.3637],
#  [1.2420, 0.5421, 1.6547]]
print(torch.add(x,10))
# tensor([[10.0461, 10.4024,  8.9885],
#         [10.2167,  9.3877, 10.5036]])
print(torch.frac(torch.add(x,10)))
# tensor([[0.0461, 0.4024, 0.9885],
#         [0.2167, 0.3877, 0.5036]])

下面的语法解释了张量中的对数值。带负号的值被转换为nan。幂函数计算张量中任意值的指数。

import torch
torch.manual_seed(1234)
x = torch.randn(2,3)
print(x)
print(torch.log(x))
print(torch.pow(x,2))
# tensor([[ 0.0461,  0.4024, -1.0115],
#         [ 0.2167, -0.6123,  0.5036]])
# tensor([[-3.0763, -0.9103,     nan],
#         [-1.5291,     nan, -0.6860]])
# tensor([[0.0021, 0.1619, 1.0232],
#         [0.0470, 0.3749, 0.2536]])

为了计算变换函数(即s形、双曲正切、径向基函数等，它们是深度学习中最常用的传递函数)，你必须构造张量。下面的示例脚本展示了如何创建一个s形函数并将其应用于一个张量。
在这里插入图片描述

import torch
torch.manual_seed(1234)
x = torch.randn(2,3)
print(x)
# tensor([[ 0.0461,  0.4024, -1.0115],
#         [ 0.2167, -0.6123,  0.5036]])
print(torch.sigmoid(x))
# tensor([[0.5115, 0.5993, 0.2667],
#         [0.5540, 0.3515, 0.6233]])
print(torch.sqrt(x))
# tensor([[0.2148, 0.6344,    nan],
#         [0.4656,    nan, 0.7097]])

總結

对于有PyTorch和Python经验的人来说，本章是复习。但是本章对新入行人来说，是学习PyTorch框架的的基本组成部分。在开始高级主题之前，熟悉术语和基本语法是很重要的。下一章将介绍如何使用PyTorch实现概率模型，其中包括创建随机变量、应用统计分布和进行统计推断。

求则得之，舍则失之
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PyTorch常用的张量创建、变形及运算总结（速查表）
CaiNiao_hu的博客
10-25 1444
PyTorch张量常用的创建方式及数学运算总结 1. 张量（tensor）的创建 1.1 torch.Tensor()与torch.tensor() torch.Tensor(3，2)返回一个尺寸为3*2的未初始化的张量 torch.Tensor(data)返回一个torch.FloatTensor类型的data torch.tensor(3, 2)报错，tensor函数参数必须为一个基本数据类型或引用数据类型数据如整型、浮点型或列表 torch.tensor(data)返回一个给定数值的张量 区别： to
pytorch张量创建与操作
01-20
张量创建 1. 直接创建 1.1 torch.tensor() 1.2 torch.from_numpy(ndarray) #从numpy创建tensor， 与原ndarray共享内存 2. 通过数值创建 2.1 torch.zeros() torch.zeros_like() torch.ones() torch.ones_like() ...
如何得到PyTorch中张量的值？
weixin_36670529的博客
03-01 2319
1、将张量转换为numpy： x.numpy()[0] 2、使用x.item()从有一个元素的张量中获取Python数
PyTorch自定义张量操作开发指南【CFFI+CUDA】
最新发布
新缸中之脑
05-29 1196
PyTorch 已成为深度学习研究和开发的标准工具。即使是不常见的张量运算或神经网络层也可以使用 PyTorch 提供的各种操作轻松实现。但是，对于某些特殊操作，求助于高效的 C 和 CUDA 实现可能是有意义的。在本文中，我想展示如何使用 CFFI 轻松扩展 PyTorch 进行 CPU 操作和使用 CuPy 进行 GPU 操作。作为示例，我将展示如何实现张量运算，计算两个张量之间的元素级、位级汉明距离。本文的代码可在GitHub上找到，并且可以轻松扩展和调整。
pytroch取张量数据
yangqiang1997的博客
03-16 2097
print('1111',loss) print('2222',loss.data)#tensor且GPU print('3333',loss.cpu()) print('4444',loss.cpu().data)#tensor且CPU # print('5555',loss.cpu().data[0])#报错 IndexError: invalid index of a 0-dim tensor. Use tensor.item() to convert a 0-dim tensor to a Pyth
Pytorch基础操作 —— 12. 从张量中选取数据
老程的技术笔记
11-03 5898
维度扩张 torch.unsqueeze(…) 函数原型为 torch.unsqueeze(input, dim) -> Tensor 返回一个新的张量，按照输入的指定方向插入维度 1 例程 >>> x = torch.tensor([1, 2, 3, 4]) >>> torch.unsqueeze(x, 0) tensor([[ 1, 2, 3, 4]]) >>> torch.unsqueeze(x, 1) tensor([[ 1
pytorch torch.view().expand().long()
VIEO
10-31 3227
print(torch.arange(0, n_class)) # n_class=60 print(torch.arange(0, n_class).view(n_class, 1, 1)) # 变换形状view(x,y,z),xyz是维度 print(torch.arange(0, n_class).view(n_class, 1, 1).expand(n_class, n_query,...
pytorch中tensor张量数据类型的转化方式
09-18
例如，`torch.Tensor.numpy()`方法将PyTorch张量转换为NumPy数组，而`torch.from_numpy()`函数则将NumPy数组转化为PyTorch张量。需要注意的是，如果张量是CPU上的，则转换过程几乎是零拷贝的，提高了效率。 示例：...
PyTorch张量与操作1
08-03
下面我们将深入探讨PyTorch张量的创建、操作以及与Numpy数组的转换。 首先，我们来看如何创建PyTorch张量： 1. `torch.empty()`：这个函数用于创建一个未初始化的张量，即其元素值随机分布，通常不建议用于数值...
PyTorch | （2）PyTorch 入门-张量
01-06
PyTorch | （1）初识PyTorch PyTorch | （2）PyTorch 入门-张量 PyTorch 是一个基于 Python 的科学计算包，主要定位两类人群： NumPy 的替代品，可以利用 GPU 的性能进行计算。 深度学习研究平台拥有足够的灵活性...
pytorch张量操作
丶夜未央丶的博客
10-19 951
pytorch张量操作张量的数据类型张量的生成torch.tensor()torch.Tensor()torch.ones_like()/torch.zeros_like()张量和numpy数据的相互转换随机数生成张量张量的操作torch.reshapetorch.unsqueeze()torch.squeeze().expend()/.expend_as().repeat()拼接与拆分张量的计算 张量的数据类型 数据类型 CPU tensor GPU tensor 32位浮点型 torch
将pytorch转成longtensor的简单方法
09-17
今天小编就为大家分享一篇将pytorch转成longtensor的简单方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
PyTorch基本数据类型（一）
01-01
PyTorch基础入门一：PyTorch基本数据类型 1）Tensor(张量) Pytorch里面处理的最基本的操作对象就是Tensor（张量），它表示的其实就是一个多维矩阵，并有矩阵相关的运算操作。在使用上和numpy是对应的，它和numpy唯一的不同就是，pytorch可以在GPU上运行，而numpy不可以。所以，我们也可以使用Tensor来代替numpy的使用。当然，二者也可以相互转换。 Tensor的基本数据类型有五种： 32位浮点型：torch.FloatTensor。pyorch.Tensor()默认的就是这种类型。 64位整型：torch.LongTensor。 32
torch.long()
热门推荐
woxiangxinwang的博客
02-10 1万+
torch.long():向下取整 >>> b1 = torch.rand(3,3) >>> b1 tensor([[0.7498, 0.2052, 0.9352], [0.1171, 0.2046, 0.1682], [0.3003, 0.7483, 0.0089]]) >>> b1.long() tensor([[0, 0, 0], [0, 0, 0], [0, 0, 0]]) .
[PyTroch系列-10]：PyTorch基础 - 张量元素的比较运算
文火冰糖（王文兵）的博客
08-06 6373
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址： 目录 第1章 Tensor运算概述 1.1 概述 1.3 “in place“运算 1.4Tensor的广播机制: 不同维度的tensor实例运算 1.5 环境准备 1.6 比较运算概述 第2章 常规值的比较示例 2.1 equal：比较两个tensor是否完全相同 2.2 eq：比较两个tensor的每个元素是否相等关系 2.3 gt：比较两个tensor的每个...
pytorch一些函数的基本用法及作用
学习笔记
02-09 1941
之前写写过 见pytorch中的torch.cat()矩阵拼接的用法及理解这个函数的作用主要是将矩阵交换两个维度。 结果 这个函数能对维度进行变换，view中的参数即为每一维应当包含的元素个数，如果-1即让其自动计算出。 运行结果 这个函数能够对任意维度进行任意交换，transpose只能对两个维度进行交换。用法是：原本0，1，2代表第1，2，3维，那么现在b.permute(2，0，1)即现在第一维是原来的第三维，第二维是原来的第一维，第三维是原来的第二维。 运行结果 作用就是降维，去掉维度中元素为1的维
PyTorch常用函数(5)
weixin_43229348的博客
09-15 1148
1. torch.Storage 一个 torch.Storage 是一个单一数据类型的连续一维数组。每个 torch.Tensor 都有一个对应的、相同数据类型的存储。 byte()：将此存储转为byte类型 char()：将此存储转为char类型 clone()：返回此存储的一个副本 cpu()：如果当前此存储不在 CPU 上，则返回一个它的 CPU 副本 cuda(device=None, async=False)：返回此对象在 CUDA 内存中的一个副本。如果此对象已在 CUDA 内存中且在正确的
pytorch 常用函数
无左无右的博客
06-29 351
通过索引赋值 a = torch.zeros([5,5]) index = (torch.LongTensor([0,1]),torch.LongTensor([1,2])) a.index_put_((index), torch.Tensor([1,1])) a[index] = torch.Tensor([4,4]) print(a) tensor([[0., 4., 0., 0....
tensor的矩阵运算.pptx
09-15
供Pytorch的初学者们免费学习张量数据类型

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值