【笔记】scatter_函数：用法如 torch.zeros(target.size(0), 2).scatter_(1,target,1).to(self.device)

已于 2022-06-17 21:10:34 修改
阅读量3k 收藏
点赞数
分类专栏： 小菜鸡加油 文章标签： pytorch 深度学习 python
于 2021-07-06 14:57:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nyist_yangguang/article/details/118520299
版权

target内容：

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

类型：

<class 'torch.Tensor'>

target.shape

torch.Size([100])

target.size()

torch.Size([100])

程序1：error 

要知道错误的原因

RuntimeError: Expected index [1, 100] to be smaller than self [100, 2] apart from dimension 1 and to be smaller size than src [100, 2]
 

程序2： true

import torch
from PIL import Image
import numpy as np
import torch.nn as nn
import os
from torch.utils.data import Dataset, DataLoader


class mydataset(Dataset):
    def __init__(self, path):
        self.path = path
        self.dataset = os.listdir(self.path)
        self.mean = [0.4878, 0.4545, 0.4168]
        self.std = [0.2623, 0.2555, 0.2577]

    def __getitem__(self, index):
        name = self.dataset[index]
        name_list = name.split(".")
        target = int(name_list[0])
        target = torch.tensor(target)
        img = Image.open(os.path.join(self.path, name))
        img = np.array(img) / 255
        # 去均值
        img = (img - self.mean) / self.std
        # img 是 float64
        data = torch.tensor(img, dtype=torch.float32).permute(2, 0, 1)
        return data, target

    def __len__(self):
        return len(self.dataset)


class mynetwork(nn.Module):
    def __init__(self):
        super(mynetwork, self).__init__()

    # 有序容器
        self.line1 = nn.Sequential(
            nn.Linear(3 * 100 * 100, 5120),
            nn.ReLU(),
            nn.Linear(5120, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 2560),
            nn.ReLU(),
            nn.Linear(2560, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 2),
        )

    #  parse  vt. 解析；从语法上分析
    def forward(self, parse):
        data = torch.reshape(parse, shape=(-1, 3 * 100 * 100))
        return self.line1(data)


class train(object):
    def __init__(self, path):
        self.path = path
        self.test_dataset = mydataset(self.path)
        self.train_dataset = mydataset(self.path)
        self.criterion = torch.nn.MSELoss()
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.net = mynetwork().to(self.device)
        self.optimize = torch.optim.Adam(self.net.parameters())

    def dataloader(self, batch):
        train_data_loader = DataLoader(dataset=self.train_dataset, batch_size=batch, shuffle=True)
        test_data_loader = DataLoader(dataset=self.test_dataset, batch_size=batch, shuffle=True)
        return train_data_loader, test_data_loader

    def trainnet(self, batch, epoch):
        train_data_loader, test_data_loader = self.dataloader(batch)
        losses = []
        accuracy = []
        for i in range(epoch):
            for j, (input, target) in enumerate(train_data_loader):
                input = input.to(self.device)
                output = self.net(input)
                print(target,type(target),target.shape,target.size())
                target = torch.zeros(target.size(0), 2).scatter_(1,target.view(1,-1),1).to(self.device)
                print(target,type(target),target.shape,target.size())
                print(target)
                input()


if __name__ == "__main__":
    path = r"./cat_dog/img"
    t = train(path)
    t.trainnet(100, 10)

输出：

/home/wangbin/anaconda3/envs/deep_learning/bin/python3.7 /media/wangbin/F/深度学习_程序/dog_cat/cat_dog.py
tensor([0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
        0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
        0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
        0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
        0, 1, 1, 0]) <class 'torch.Tensor'> torch.Size([100]) torch.Size([100])
tensor([[1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [1., 0.]], device='cuda:0') <class 'torch.Tensor'> torch.Size([100, 2]) torch.Size([100, 2])
tensor([[1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [0., 1.],
        [1., 0.],
        [0., 1.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [1., 0.],
        [0., 1.],
        [0., 1.],
        [1., 0.]], device='cuda:0')

附：

 

函数资料：

torch._C._TensorBase._TensorBase def scatter_(self,
             dim: int,
             index: Any,
             src: Any,
             reduce: str = None) -> None
scatter_(dim, index, src, reduce=None) -> Tensor
Writes all values from the tensor src into self at the indices specified in the index tensor. For each value in src, its output index is specified by its index in src for dimension != dim and by the corresponding value in index for dimension = dim.
For a 3-D tensor, self is updated as:
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
This is the reverse operation of the manner described in ~Tensor.gather.
self, index and src (if it is a Tensor) should have same number of dimensions. It is also required that index.size(d) <= src.size(d) for all dimensions d, and that index.size(d) <= self.size(d) for all dimensions d != dim.
Moreover, as for ~Tensor.gather, the values of index must be between 0 and self.size(dim) - 1 inclusive, and all values in a row along the specified dimension dim must be unique.
Additionally accepts an optional reduce argument that allows specification of an optional reduction operation, which is applied to all values in the tensor src into self at the indicies specified in the index. For each value in src, the reduction operation is applied to an index in self which is specified by its index in src for dimension != dim and by the corresponding value in index for dimension = dim.
Given a 3-D tensor and reduction using the multiplication operation, self is updated as:
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
Reducing with the addition operation is the same as using ~torch.Tensor.scatter_add_.
Note
Reduction is not yet implemented for the CUDA backend.
Example:
>>> x = torch.rand(2, 5)
>>> x
tensor([[ 0.3992,  0.2908,  0.9044,  0.4850,  0.6004],
        [ 0.5735,  0.9006,  0.6797,  0.4152,  0.1732]])
>>> torch.zeros(3, 5).scatter_(0, torch.tensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]]), x)
tensor([[ 0.3992,  0.9006,  0.6797,  0.4850,  0.6004],
        [ 0.0000,  0.2908,  0.0000,  0.4152,  0.0000],
        [ 0.5735,  0.0000,  0.9044,  0.0000,  0.1732]])

>>> z = torch.zeros(2, 4).scatter_(1, torch.tensor([[2], [3]]), 1.23)
>>> z
tensor([[ 0.0000,  0.0000,  1.2300,  0.0000],
        [ 0.0000,  0.0000,  0.0000,  1.2300]])

>>> z = torch.ones(2, 4).scatter_(1, torch.tensor([[2], [3]]), 1.23, reduce='multiply')
>>> z
tensor([[1.0000, 1.0000, 1.2300, 1.0000],
        [1.0000, 1.0000, 1.0000, 1.2300]])
Params:
dim – the axis along which to index
index – the indices of elements to scatter, can be either empty or the same size of src. When empty, the operation returns identity
src – the source element(s) to scatter, incase `value` is not specified
reduce – reduction operation to apply, can be either 'add' or 'multiply'.
  < Python 3.7 (deep_learning) >

程序猿的探索之路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
torch_scatter-2.1.2-cp310-cp310-macosx_11_0_x86_64.whl.zip
02-19
`torch_scatter`库还提供了其他函数，如`scatter_max`和`scatter_min`，它们分别用于找到索引处的最大值和最小值，并将结果分散到目标张量上。此外，`scatter_mean`用于计算平均值。 总结来说，`torch_scatter`是...
torch_scatter-2.1.2-cp311-cp311-macosx_10_9_universal2.whl.zip
02-19
scatter_add(src, index, dim_size=target.size(0), out=target) # 输出：tensor([9., 8.]) ``` 在这个例子中，`src`中的元素根据`index`中的值在`target`上进行累加，结果是第一行元素之和为9，第二行元素之和为8...
pytorch中torch.Tensor.scatter用法
qq_39004117的博客
07-16 1万+
今天读代码，看到有人用了torch.Tensor.scatter这个函数。这个函数之前我也看到过，但是没有搞明白是干啥用的，今天我搞明白了。 首先看一下官方文档的定义：（可跳过） ==============================pytorch docs分割线==================================== scatter_(dim, index, src)...
torch.scatter
芒果干的博客
10-18 6129
本文目录一、函数简介二、二维举例三、详解执行过程1. 第一步2. 第二步3. 第三步4. 问题 一、函数简介 torch.scatter(input, dim, index, src) dim ([int]) – the axis along which to index index (LongTensor) – the indices of elements to scatter, can be either empty or of the same dimensionality as src. Whe
torch.scatter函数详解
热门推荐
yangyanbao8389的博客
11-22 1万+
#torch.scatter函数官方解释 scatter(output, dim, index, src) → Tensor Writes all values from the tensor src into self at the indices specified in the index tensor. For each value in src, its output index is specified by its index in src for dimension != dim and
self._device.open(port, device
qq_38163468的博客
05-28 331
树莓派已开启SPI下的错误： File “/usr/local/lib/python3.7/dist-packages/Adafruit_GPIO-1.0.4py3.7.egg/Adafruit_GPIO/SPI.py”, line 42, in init self._device.open(port, device) FileNotFoundError: [Errno 2] No such file or directory 经过https://blog.csdn.net/shenzhonglaoxu/a
.scatter_函数
qq_31225201的博客
03-11 1947
.scatter_函数放置元素或者修改元素。 >>> x = torch.rand(2, 5) >>> x tensor([[0.6132, 0.8931, 0.7345, 0.6793, 0.6606], [0.0630, 0.1785, 0.7312, 0.6456, 0.6307]]) >>> torch.zeros(3, 5).scatter_(0, torch.LongTensor([[0, 1, 2, 0,
torch_scatter-2.1.2-cp39-cp39-macosx_11_0_x86_64.whl.zip
02-19
target = torch.zeros(2) result = scatter_add(src, index, dim=0, target=target) print(result) # 输出：[4, 7] ``` 以上代码中，`scatter_add`将`src`张量中对应`index`位置的元素累加到`target`张量上，结果...
torch_scatter-2.1.0-cp38-cp38-macosx_10_15_x86_64.whl.zip
12-20
《torch_scatter模块详解及其与torch的协同使用》 torch_scatter是PyTorch生态中的一个关键扩展库，主要用于处理张量的分散操作，尤其在图神经网络（GNN）和分布式计算中扮演着重要角色。这个库为PyTorch提供了...
torch_scatter-2.1.1-cp37-cp37m-macosx_10_15_x86_64.whl.zip
12-20
target = torch.zeros(2) torch_scatter.scatter_add(src, index, target) ``` 四、适用场景 torch_scatter在图神经网络中有着广泛的应用。例如，在计算节点的邻居特征的聚合时，可以使用scatter_add将所有邻居的...
理论学习：target.size(0)
最新发布
llf000000的博客
04-17 90
被用来获取批次中样本的数量。
torch.zeros(log_probs.size()).scatter_(1, targets.unsqueeze(1).data.cpu(), 1)报错
我有明珠一颗的博客
05-06 771
复现HOReID代码时遇到的问题，详细报错： Expected object of scalar type Long but got scalar type Int for argument #3 'index' 内外网都没有找到解决办法，我搞了一晚上，最后调通了（不知道后续有没有影响，至少当下是可以跑通代码了） 改成如下： targets = torch.zeros(log_probs.size()).scatter_(1, (targets.unsqueeze(1).data.cpu()).
Pytorch中scatter_ 的使用详细解读
qq1483661204的博客
07-20 1265
先看一个例子： torch.zeros(3, 5).scatter_(0, torch.tensor([[0, 1, 1, 1, 1]]), 2) tensor([[2., 0., 0., 0., 0.], [0., 2., 2., 2., 2.], [0., 0., 0., 0., 0.]]) 首先是定义了一个3行5列的数组，_scatter中第一个参数0.表示沿着第0轴， 后面第二个参数是坐标，第三个是对应坐标的值，整个意思就是给torch.zeros(3, 5)对
Using a target size (torch.Size([270, 429])) that is different to the input size (torch.Size([270]))
baiye_nini的博客
09-27 1852
torch.Size([270, 429]指的是输出的tensor，target（y）和data（x）使用的是同一个集合train。torch.Size([270]指的是本应输出的tensor。原来是粗心大意······
Using a target size (torch.Size([442])) that is different to the input size (torch.Size([442, 1]))
weixin_44482737的博客
07-06 4272
pytorch 错误： 1.ValueError: Using a target size (torch.Size([442])) that is different to the input size (torch.Size([442, 1])) is deprecated. Please ensure they have the same size. 报错信息说输入的尺寸和目标尺寸不同，导致的错误。 在前馈函数中 添加x = x.squeeze(-1) 达到降维就可以解决该问题。2.UserWarni
pytorch中model=model.to(device)用法
Akita·Wang's Semantic Segmentation
04-23 1353
有一些论文公布的代码采用了model=model.to(device)这种模式 按照我的理解，应该是和model.cuda()是一样的功能 使用cpu运算：将torch.load()函数中的map_location参数设置为torch.device('cpu') device = torch.device('cpu') model = TheModelClass(*args, **kwargs) model.load_state_dict(torch.load(PATH, map_location=
Using a target size (torch.Size([10, 1])) that is different to the input size (torch.Size([10])) is
qq_43981607的博客
04-24 527
【代码】Using a target size (torch.Size([10, 1])) that is different to the input size (torch.Size([10])) is。
全面理解python中self的用法
weixin_30363981的博客
07-24 215
self代表类的实例，而非类。 class Test: def prt(self): print(self) print(self.__class__) t = Test() t.prt() 执行结果如下 <__main__.Test object at 0x000000000284E080> <cl...
【笔记】pytorch 中的广播：tensor对tensor、array对array、array对list，这三种不会报错，可以正常进行广播运算
nyist_yangguang的博客
07-06 568
tensor 对 tensor：OK # std，mean求取程序 from torch.utils.data import Dataset,DataLoader import torch import os from PIL import Image import numpy as np # target1=torch.tensor([]) # target2=torch.tensor([]) # target3=torch.tensor([]) # # mean=torch.tensor...
torch.zeros(1,10).scatter_(1,a,1)
04-04
This line of code creates a tensor of size 1x10 filled with zeros using the `torch.zeros` function. It then calls the `scatter_` method on the tensor, which takes three arguments. The first argument is the dimension along which to scatter the values. In this case, we're scattering along the second dimension (since the tensor has shape 1x10). The second argument is a tensor containing the indices where we want to scatter the values. In this case, `a` is a tensor of shape 1x5 containing five indices between 0 and 9 (inclusive). The third argument is the value to scatter at each index. In this case, we're scattering the value 1 at each of the five indices specified in `a`. Overall, this line of code creates a tensor of size 1x10 with five 1's at the positions specified by `a`, and zeros everywhere else.
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序猿的探索之路

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

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

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

打赏作者

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

抵扣说明：

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

余额充值