PyTorch学习系统之 scatter() 函数详解 one hot 编码

torch.Tensor.scatter_

scatter()scatter_() 的作用是一样的,只不过 scatter() 不会直接修改原来的 Tensor,而 scatter_() 会

torch.Tensor.scatter_()torch.gather()函数的方向反向操作。两个函数可以看成一对兄弟函数。gather用来解码one hot,scatter_用来编码one hot。

PyTorch 中,一般函数加下划线代表直接在原来的 Tensor 上修改

scatter_(dimindexsrc) → Tensor

参数:

  • dim:沿着哪个维度进行索引
  • index:用来 scatter 的元素索引
  • src:用来 scatter 的源元素,可以是一个标量或一个张量

这个 scatter  可以理解成放置元素或者修改元素

简单说就是通过一个张量 src  来修改另一个张量,哪个元素需要修改、用 src 中的哪个元素来修改由 dim 和 index 决定

官方文档给出了 3维张量 的具体操作说明,如下所示

self[index[i][j][k]][j][k] = src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] = src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] = src[i][j][k]  # if dim == 2
x = torch.rand(2, 5)

#tensor([[0.1940, 0.3340, 0.8184, 0.4269, 0.5945],
#        [0.2078, 0.5978, 0.0074, 0.0943, 0.0266]])

torch.zeros(3, 5).scatter_(0, torch.tensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]]), x)

#tensor([[0.1940, 0.5978, 0.0074, 0.4269, 0.5945],
#        [0.0000, 0.3340, 0.0000, 0.0943, 0.0000],
#        [0.2078, 0.0000, 0.8184, 0.0000, 0.0266]])

具体地说,我们的 index 是 torch.tensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]]),一个二维张量,下面用图简单说明

我们是 2维 张量,一开始进行 self[index[0][0]][0]self[index[0][0]][0],其中 index[0][0]index[0][0] 的值是0,所以执行 self[0][0]=x[0][0]=0.1940self[0][0]=x[0][0]=0.1940 

self[index[i][j]][j]=src[i][j]

 

再比如self[index[1][0]][0]self[index[1][0]][0],其中 index[1][0]index[1][0] 的值是2,所以执行 self[2][0]=x[1][0]=0.2078self[2][0]=x[1][0]=0.2078 

计算过程:index[0,0]=0→self[0,0]→src[0,0] =0.1940

index[0,1]=1→self[1,1]→src[0,1] =0.3340

index[0,2]=2→self[2,2]→src[0,2] =0.8184

 

example:

torch.zeros(3, 5).scatter_(0, torch.tensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]]), 7)

#tensor([[7., 7., 7., 7., 7.],
#        [0., 7., 0., 7., 0.],
#        [7., 0., 7., 0., 7.]]

计算过程:index[0,0]=0→self[0,0]→src[0,0] =7

index[0,1]=1→self[1,1]→src[0,1] =7

index[0,2]=2→self[2,2]→src[0,2] =7

scatter() 一般可以用来对标签进行 one-hot 编码,这就是一个典型的用标量来修改张量的一个例子

用于产生one hot编码的向量

example:

class_num = 10
batch_size = 4
label = torch.LongTensor(batch_size, 1).random_() % class_num
#tensor([[6],
#        [0],
#        [3],
#        [2]])
torch.zeros(batch_size, class_num).scatter_(1, label, 1)
#tensor([[0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
#        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
#        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
#        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.]])
indices = torch.tensor(list(range(5))).view(5,1)  
indices
result = torch.zeros(5, 5)
result.scatter_(1, indices, 1)        

 

当没有src值时,则所有用于填充的值均为value值。

需要注意的时候,这个时候index.shape[dim]必须与result.shape[dim]相等,否则会报错。

result = torch.zeros(3, 5)
indices = torch.tensor([[0, 1, 2, 0, 0], 
                        [2, 0, 3, 1, 2],
                        [2, 1, 3, 1, 4]])
result.scatter_(1, indices, value=1)        

输出为

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

参考资料

https://pytorch.org/docs/stable/tensors.html?highlight=scatter_#torch.Tensor.scatter_

https://www.cnblogs.com/dogecheng/p/11938009.html

  • 4
    点赞
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: PyTorch中可以使用torch.nn.functional.one_hot()函数实现one-hot编码。该函数的输入是一个张量,输出是一个one-hot编码的张量。 具体实现方法如下: ```python import torch # 定义一个需要进行one-hot编码的张量 x = torch.tensor([1, 2, , 3]) # 计算one-hot编码 one_hot = torch.nn.functional.one_hot(x) # 输出结果 print(one_hot) ``` 输出结果为: ``` tensor([[, 1, , ], [, , 1, ], [1, , , ], [, , , 1]]) ``` 其中,输入张量x的每个元素都被转换为一个one-hot编码的向量,向量的长度等于x中不同元素的个数。例如,在上面的例子中,x中有4个不同的元素,因此每个one-hot编码的向量的长度为4。如果x中有n个不同的元素,那么每个one-hot编码的向量的长度就为n。 ### 回答2: PyTorch 是一个深度学习框架,支持张量(tensor)计算以及梯度优化。在 PyTorch 中实现 one-hot 编码非常简单。具体实现过程为: 首先,将需要进行 one-hot 编码的数组或列表使用 PyTorch 的 tensor() 函数转换为张量。例如: data = torch.tensor([1, 2, 3, 0, 1]) 其次,使用 PyTorch 的 nn.functional.one_hot() 函数进行 one-hot 编码处理。其输入参数为数据张量,以及需要指定编码向量的长度,即包含的类别数目。例如: one_hot = torch.nn.functional.one_hot(data, num_classes=4) 最后,通过 one_hot 的 shape 属性获取输出的编码向量的维度,即查看是否正确进行了编码。例如: print(onehot.shape) # 输出: torch.Size([5, 4]) 在此基础上,我们可以将这个 one_hot 张量转换为 numpy 数组进行后续操作。实际上,PyTorch 的张量并不需要专门转换为 numpy 数组,而是通过 PyTorch 的支持,使用自带的函数计算并进行后续处理,方便实用。 总之,在 PyTorch 中实现 one-hot 编码非常简单,只需要利用 PyTorch 提供的 nn.functional.one_hot() 函数即可。同时,PyTorch 的张量也提供了非常丰富的计算和操作方法,可用于各种深度学习模型的实现。 ### 回答3: 在机器学习和深度学习领域中,经常需要将类别型变量转换为数值型变量。而将分类变量转换为数值型变量的方式之一就是使用one-hot编码PyTorch提供了一个简单的方法实现one-hot编码。 首先,创建一个列表,其中包含将要进行预测的所有类别。例如:['cat', 'dog', 'bird']。 然后,使用PyTorch的torch.eye()函数。该函数将返回一个矩阵,其中对角线元素均为1,其他元素均为0。函数签名为:`torch.eye(n, m=None, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) -> Tensor`,其中n为行数,m为列数。默认情况下,当m为None时,torch.eye()函数返回一个n*n的方阵。 为了使用torch.eye()函数实现one-hot编码,需要将一个列表转换为一个张量,要求每个类别都是一个数字。例如,将['cat', 'dog', 'bird']转化为[0, 1, 2]。然后使用如下的代码实现one-hot编码: ``` import torch categories = ['cat', 'dog', 'bird'] cat_tensor = torch.tensor([0]) dog_tensor = torch.tensor([1]) bird_tensor = torch.tensor([2]) one_hot = torch.eye(len(categories)) print(one_hot[cat_tensor]) # tensor([1., 0., 0.]) print(one_hot[dog_tensor]) # tensor([0., 1., 0.]) print(one_hot[bird_tensor]) # tensor([0., 0., 1.]) ``` 这样,一个类别将被编码为在one-hot张量中对应位置为1,其余位置为0的向量。每个向量大小相同,维数等于类别数,这样对于每个类别,都可以由该类别对应的索引所得到的one-hot向量来表示。 总之,pytorch实现one-hot编码非常简单,只需使用torch.eye()函数即可。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值