tensor.nozero(), mask, [mask]

已于 2022-08-02 15:51:47 修改
阅读量1k 收藏 4
点赞数 1
分类专栏： 面试题（Interview Questions） 目标检测（Object Detection） PyTorch 文章标签： 深度学习 pytorch 人工智能
于 2022-08-02 15:46:51 首次发布
搬的时候标注一下来源，谢谢。
本文链接：https://blog.csdn.net/weixin_44878336/article/details/126117812
版权

1. nozero()

https://pytorch.org/docs/stable/generated/torch.nonzero.html?highlight=nonzero#torch.nonzero

torch.nonzero(input, *, out=None, as_tuple=False) → LongTensor or tuple of LongTensors

torch.nonzero(..., as_tuple=False) (default) returns a 2-D tensor where each row is the index for a nonzero value.
torch.nonzero(..., as_tuple=False) (默认)返回一个2-D张量，其中每一行是一个非零值的索引。

tensor.nozero()默认返回一个2维的tensor, 里面是符合条件的索引.

举个例子:

import torch


x = torch.randint(low=2, high=3, size=[2, 3])
idx = x.nonzero()

print(f"x:\n{x}\n")
print(f"idx:\n{idx}\n")

print(f"x.size: {x.size()}")
print(f"idx.size: {idx.size()}")

结果:

x:
tensor([[2, 2, 2],
        [2, 2, 2]])

idx:
tensor([[0, 0],
        [0, 1],
        [0, 2],
        [1, 0],
        [1, 1],
        [1, 2]])

x.size: torch.Size([2, 3])
idx.size: torch.Size([6, 2])

可以看到, 这里的idx是用2-D tensor来表示x中符合条件元素的索引.

因为x有两个维度, 所以idx中的size()[1]也是2

如果输入是多维的tensor, 那么表示也只会用2-D的tensor. 例子如下:

import torch


x = torch.randint(low=2, high=3, size=[2, 3, 4])
idx = x.nonzero()

print(f"x:\n{x}\n")
print(f"idx:\n{idx}\n")

print(f"x.size: {x.size()}")
print(f"idx.size: {idx.size()}")

结果:

x:
tensor([[[2, 2, 2, 2],
         [2, 2, 2, 2],
         [2, 2, 2, 2]],

        [[2, 2, 2, 2],
         [2, 2, 2, 2],
         [2, 2, 2, 2]]])

idx:
tensor([[0, 0, 0],
        [0, 0, 1],
        [0, 0, 2],
        [0, 0, 3],
        [0, 1, 0],
        [0, 1, 1],
        [0, 1, 2],
        [0, 1, 3],
        [0, 2, 0],
        [0, 2, 1],
        [0, 2, 2],
        [0, 2, 3],
        [1, 0, 0],
        [1, 0, 1],
        [1, 0, 2],
        [1, 0, 3],
        [1, 1, 0],
        [1, 1, 1],
        [1, 1, 2],
        [1, 1, 3],
        [1, 2, 0],
        [1, 2, 1],
        [1, 2, 2],
        [1, 2, 3]])

x.size: torch.Size([2, 3, 4])
idx.size: torch.Size([24, 3])

因为x有3个维度, 所以idx中的size()[1]也是3

再举个例子:

import torch


x = torch.randint(low=2, high=3, size=[2, 3, 4, 2])
idx = x.nonzero()

print(f"x:\n{x}\n")
print(f"idx:\n{idx}\n")

print(f"x.size: {x.size()}")
print(f"idx.size: {idx.size()}")

结果:

x:
tensor([[[[2, 2],
          [2, 2],
          [2, 2],
          [2, 2]],

         [[2, 2],
          [2, 2],
          [2, 2],
          [2, 2]],

         [[2, 2],
          [2, 2],
          [2, 2],
          [2, 2]]],


        [[[2, 2],
          [2, 2],
          [2, 2],
          [2, 2]],

         [[2, 2],
          [2, 2],
          [2, 2],
          [2, 2]],

         [[2, 2],
          [2, 2],
          [2, 2],
          [2, 2]]]])

idx:
tensor([[0, 0, 0, 0],
        [0, 0, 0, 1],
        [0, 0, 1, 0],
        [0, 0, 1, 1],
        [0, 0, 2, 0],
        [0, 0, 2, 1],
        [0, 0, 3, 0],
        [0, 0, 3, 1],
        [0, 1, 0, 0],
        [0, 1, 0, 1],
        [0, 1, 1, 0],
        [0, 1, 1, 1],
        [0, 1, 2, 0],
        [0, 1, 2, 1],
        [0, 1, 3, 0],
        [0, 1, 3, 1],
        [0, 2, 0, 0],
        [0, 2, 0, 1],
        [0, 2, 1, 0],
        [0, 2, 1, 1],
        [0, 2, 2, 0],
        [0, 2, 2, 1],
        [0, 2, 3, 0],
        [0, 2, 3, 1],
        [1, 0, 0, 0],
        [1, 0, 0, 1],
        [1, 0, 1, 0],
        [1, 0, 1, 1],
        [1, 0, 2, 0],
        [1, 0, 2, 1],
        [1, 0, 3, 0],
        [1, 0, 3, 1],
        [1, 1, 0, 0],
        [1, 1, 0, 1],
        [1, 1, 1, 0],
        [1, 1, 1, 1],
        [1, 1, 2, 0],
        [1, 1, 2, 1],
        [1, 1, 3, 0],
        [1, 1, 3, 1],
        [1, 2, 0, 0],
        [1, 2, 0, 1],
        [1, 2, 1, 0],
        [1, 2, 1, 1],
        [1, 2, 2, 0],
        [1, 2, 2, 1],
        [1, 2, 3, 0],
        [1, 2, 3, 1]])

x.size: torch.Size([2, 3, 4, 2])
idx.size: torch.Size([48, 4])

因为x有4个维度, 所以idx中的size()[1]也是4

终于, 我们可以发现结论了:

  • tensor.nozero()默认返回的是一个2-Dtensor, 行表示非零元素的索引, 列的大小 = 输入tensor维度的数量

2. mask

在手撸YOLOv3时, 需要写mask, 一般是根据置信度是否大于阈值来判断是否为正样本:

  • ≥ thresh: 张样本
  • < thresh: 负样本

在YOLOv3中, 网络的前向推理结果一般为 [N, H, W, 3, 8], 其中:

  • N: batch size
  • H: height
  • W: weight
  • 3: 3种预测尺度
  • 8: conf + loc + cls = 1 + 4 + 3

为了能够取到置信度conf, 因此output[..., 0], 由此就可以得到mask:

output = net(input)  # [N, H, W, 3, 8]

mask = output[..., 0] > thresh  # [N, H, W, 3]

那么问题来了: 为什么得到的mask的size为[N, H, W, 3]呢?

我们讲一下mask这样的取法究竟是在做什么.

import torch


x = torch.randint(low=2, high=3, size=[2, 3])

mask = x[..., 0] > 1  # 最后一个维度中的第一个元素如果大于1, 则前面的维度返回True, 否则返回False

print(f"x:\n{x}\n")
print(f"x[..., 0]:\n{x[..., 0]}\n")
print(f"x[..., 0].size:\n{x[..., 0].size()}\n")
print(f"mask:\n{mask}\n")
print(f"mask.size:\n{mask.size()}\n")

x:
tensor([[2, 2, 2],
        [2, 2, 2]])

x[..., 0]:
tensor([2, 2])

x[..., 0].size:
torch.Size([2])

mask:
tensor([True, True])

mask.size:
torch.Size([2])

或许这样看还不够明显, 那么我们将x的值修改一下:

import torch


x = torch.tensor(data=[[0, 2, 2],
                       [0, 2, 2]], dtype=torch.int8)

mask = x[..., 0] > 1  # 最后一个维度中的第一个元素如果大于1, 则前面的维度返回True, 否则返回False

print(f"x:\n{x}\n")
print(f"x[..., 0]:\n{x[..., 0]}\n")
print(f"x[..., 0].size:\n{x[..., 0].size()}\n")
print(f"mask:\n{mask}\n")
print(f"mask.size:\n{mask.size()}\n")

结果:

x:
tensor([[0, 2, 2],
        [0, 2, 2]], dtype=torch.int8)

x[..., 0]:
tensor([0, 0], dtype=torch.int8)

x[..., 0].size:
torch.Size([2])

mask:
tensor([False, False])

mask.size:
torch.Size([2])

看起来, 这个函数取的是第一列(这里的描述并不准确). 那么我们在将x的维度扩充一下看看:

import torch


x = torch.randint(low=0, high=3, size=[2, 3, 2])

mask = x[..., 0] > 1  # 最后一个维度中的第一个元素如果大于1, 则前面的维度返回True, 否则返回False

print(f"x:\n{x}\n")
print(f"x[..., 0]:\n{x[..., 0]}\n")
print(f"x[..., 0].size:\n{x[..., 0].size()}\n")
print(f"mask:\n{mask}\n")
print(f"mask.size:\n{mask.size()}\n")

结果:

x:
tensor([[[2, 1],
         [2, 1],
         [1, 0]],

        [[2, 0],
         [1, 2],
         [0, 0]]])

x[..., 0]:
tensor([[2, 2, 1],
        [2, 1, 0]])

x[..., 0].size:
torch.Size([2, 3])

mask:
tensor([[ True,  True, False],
        [ True, False, False]])

mask.size:
torch.Size([2, 3])

结论仍然是对的, 我们再将x扩充至 [N, H, W, 3]:

import torch


x = torch.randint(low=0, high=3, size=[2, 3, 2, 1])

mask = x[..., 0] > 1  # 最后一个维度中的第一个元素如果大于1, 则前面的维度返回True, 否则返回False

print(f"x:\n{x}\n")
print(f"x[..., 0]:\n{x[..., 0]}\n")
print(f"x[..., 0].size:\n{x[..., 0].size()}\n")
print(f"mask:\n{mask}\n")
print(f"mask.size:\n{mask.size()}\n")

x:
tensor([[[[0],
          [0]],

         [[0],
          [1]],

         [[2],
          [2]]],


        [[[1],
          [2]],

         [[2],
          [2]],

         [[2],
          [2]]]])

x[..., 0]:
tensor([[[0, 0],
         [0, 1],
         [2, 2]],

        [[1, 2],
         [2, 2],
         [2, 2]]])

x[..., 0].size:
torch.Size([2, 3, 2])

mask:
tensor([[[False, False],
         [False, False],
         [ True,  True]],

        [[False,  True],
         [ True,  True],
         [ True,  True]]])

mask.size:
torch.Size([2, 3, 2])

结论是对的.

3. [mask]

上面我们分析了mask究竟是在取什么, 那么将mask应用到x中(x[mask])会是怎么样的呢?

import torch


x = torch.randint(low=0, high=3, size=[2, 3])

mask = x[..., 0] > 1  # 最后一个维度中的第一个元素如果大于1, 则前面的维度返回True, 否则返回False

filtered_x = x[mask]

print(f"x:\n{x}\n")
print(f"x.size:\n{x.size()}\n")

print("-" * 50)

print(f"x[..., 0]:\n{x[..., 0]}\n")
print(f"x[..., 0].size:\n{x[..., 0].size()}\n")

print("-" * 50)

print(f"mask:\n{mask}\n")
print(f"mask.size:\n{mask.size()}\n")

print("-" * 50)

print(f"filtered_x:\n{filtered_x}\n")
print(f"filtered_x.size:\n{filtered_x.size()}\n")

结果2:

x:
tensor([[2, 2, 1],
        [0, 0, 2]])

x.size:
torch.Size([2, 3])

--------------------------------------------------
x[..., 0]:
tensor([2, 0])

x[..., 0].size:
torch.Size([2])

--------------------------------------------------
mask:
tensor([ True, False])

mask.size:
torch.Size([2])

--------------------------------------------------
filtered_x:
tensor([[2, 2, 1]])

filtered_x.size:
torch.Size([1, 3])

mask负责筛选"列", x[mask]负责取出符合条件的行, 且这个行是一个2D tensor.

结果2:

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

x.size:
torch.Size([2, 3])

--------------------------------------------------
x[..., 0]:
tensor([0, 1])

x[..., 0].size:
torch.Size([2])

--------------------------------------------------
mask:
tensor([False, False])

mask.size:
torch.Size([2])

--------------------------------------------------
filtered_x:
tensor([], size=(0, 3), dtype=torch.int64)

filtered_x.size:
torch.Size([0, 3])

mask负责筛选"列", x[mask]负责取出符合条件的行, 且这个行是一个2D tensor.

我们将x的维度提升:

import torch


x = torch.randint(low=0, high=3, size=[2, 3, 2])

mask = x[..., 0] > 1  # 最后一个维度中的第一个元素如果大于1, 则前面的维度返回True, 否则返回False

filtered_x = x[mask]

print(f"x:\n{x}\n")
print(f"x.size:\n{x.size()}\n")

print("-" * 50)

print(f"x[..., 0]:\n{x[..., 0]}\n")
print(f"x[..., 0].size:\n{x[..., 0].size()}\n")

print("-" * 50)

print(f"mask:\n{mask}\n")
print(f"mask.size:\n{mask.size()}\n")

print("-" * 50)

print(f"filtered_x:\n{filtered_x}\n")
print(f"filtered_x.size:\n{filtered_x.size()}\n")

结果1:

x:
tensor([[[0, 2],
         [0, 2],
         [0, 2]],

        [[2, 2],
         [1, 0],
         [1, 2]]])

x.size:
torch.Size([2, 3, 2])

--------------------------------------------------
x[..., 0]:
tensor([[0, 0, 0],
        [2, 1, 1]])

x[..., 0].size:
torch.Size([2, 3])

--------------------------------------------------
mask:
tensor([[False, False, False],
        [ True, False, False]])

mask.size:
torch.Size([2, 3])

--------------------------------------------------
filtered_x:
tensor([[2, 2]])

filtered_x.size:
torch.Size([1, 2])

结果2:

x:
tensor([[[1, 0],
         [2, 0],
         [2, 1]],

        [[2, 0],
         [2, 0],
         [2, 1]]])

x.size:
torch.Size([2, 3, 2])

--------------------------------------------------
x[..., 0]:
tensor([[1, 2, 2],
        [2, 2, 2]])

x[..., 0].size:
torch.Size([2, 3])

--------------------------------------------------
mask:
tensor([[False,  True,  True],
        [ True,  True,  True]])

mask.size:
torch.Size([2, 3])

--------------------------------------------------
filtered_x:
tensor([[2, 0],
        [2, 1],
        [2, 0],
        [2, 0],
        [2, 1]])

filtered_x.size:
torch.Size([5, 2])

我们可以发现, 结论 mask负责筛选"列", x[mask]负责取出符合条件的行, 且这个行是一个2D tensor 依然是符合的, 我们再扩充一下维度:

import torch


x = torch.randint(low=0, high=3, size=[2, 3, 2, 2])

mask = x[..., 0] > 1  # 最后一个维度中的第一个元素如果大于1, 则前面的维度返回True, 否则返回False

filtered_x = x[mask]

print(f"x:\n{x}\n")
print(f"x.size:\n{x.size()}\n")

print("-" * 50)

print(f"x[..., 0]:\n{x[..., 0]}\n")
print(f"x[..., 0].size:\n{x[..., 0].size()}\n")

print("-" * 50)

print(f"mask:\n{mask}\n")
print(f"mask.size:\n{mask.size()}\n")

print("-" * 50)

print(f"filtered_x:\n{filtered_x}\n")
print(f"filtered_x.size:\n{filtered_x.size()}\n")

结果1:

x:
tensor([[[[0, 0],
          [0, 1]],

         [[1, 1],
          [0, 0]],

         [[0, 1],
          [2, 1]]],


        [[[2, 2],
          [0, 1]],

         [[0, 2],
          [0, 2]],

         [[0, 0],
          [2, 2]]]])

x.size:
torch.Size([2, 3, 2, 2])

--------------------------------------------------
x[..., 0]:
tensor([[[0, 0],
         [1, 0],
         [0, 2]],

        [[2, 0],
         [0, 0],
         [0, 2]]])

x[..., 0].size:
torch.Size([2, 3, 2])

--------------------------------------------------
mask:
tensor([[[False, False],
         [False, False],
         [False,  True]],

        [[ True, False],
         [False, False],
         [False,  True]]])

mask.size:
torch.Size([2, 3, 2])

--------------------------------------------------
filtered_x:
tensor([[2, 1],
        [2, 2],
        [2, 2]])

filtered_x.size:
torch.Size([3, 2])

结果2:

x:
tensor([[[[2, 2],
          [2, 2]],

         [[1, 0],
          [0, 2]],

         [[0, 2],
          [2, 2]]],


        [[[0, 0],
          [1, 0]],

         [[1, 1],
          [0, 1]],

         [[2, 1],
          [1, 0]]]])

x.size:
torch.Size([2, 3, 2, 2])

--------------------------------------------------
x[..., 0]:
tensor([[[2, 2],
         [1, 0],
         [0, 2]],

        [[0, 1],
         [1, 0],
         [2, 1]]])

x[..., 0].size:
torch.Size([2, 3, 2])

--------------------------------------------------
mask:
tensor([[[ True,  True],
         [False, False],
         [False,  True]],

        [[False, False],
         [False, False],
         [ True, False]]])

mask.size:
torch.Size([2, 3, 2])

--------------------------------------------------
filtered_x:
tensor([[2, 2],
        [2, 2],
        [2, 2],
        [2, 1]])

filtered_x.size:
torch.Size([4, 2])

结论依然存在!

4. 结论

到现在我们终于明白了,

output = net(input)  # [N, H, W, 3, 8]

mask = output[..., 0] > thresh  # [N, H, W, 3]
  • mask: 取出的是符合条件的列 (判断用的维度就消失了, 所以[N, H, W, 3, 8] -> [N, H, W, 3])
  • output[mask]: 取出符合条件的行 (是一个2-D tensor)

举个例子:

def get_idx_and_info(self, output, thresh):
    output = output.permute(0, 2, 3, 1)  # [N, 24, H, W] -> [N, H, W, 3*8]
    N, H, W, _ = output.size()
    output = output.reshape(N, H, W, 3, -1)  # N, H, W, 24] -> N, H, W, 3, 8]
    
    # 定义掩码(符合条件的行)
    mask = output[..., 0] > thresh  # 置信度 > thresh  # [N, H, W, 3] (这里应该是自动squeeze了)
    
    idx = mask.nonzero()  # size -> [符合条件数的个数, 4]  # 因为mask的维度个数有4个, 所以这里是4, 
    info = output[mask]  # size -> [符合条件数的个数, 8]  # 8 = c + loc + cls
    
    return idx, info
Le0v1n
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【分割】TensorMask: A Foundation for Dense Object Segmentation
HTS's Blog
04-01 539
论文阅读：TensorMask: A Foundation for Dense Object Segmentation 这是第一次看分割的论文，据说相当于分割界的yolo。 现在分割界的方法主要是由先检测出目标的bounding boxes，再修剪和分割这些区域，大致都是mask rcnn一类的。这篇论文研究了密集的基于滑动窗口的实例分割。这项任务远远不同于语义分割和目标检测，因为在每个空间位置的...
python3 nonzero_Python tensor.nonzero方法代码示例
weixin_39793708的博客
12-10 380
# 需要导入模块: from theano import tensor [as 别名]# 或者: from theano.tensor import nonzero [as 别名]def past_weight_grad_step(xs, es, kp_x, kd_x, kp_e, kd_e, shape, dws=None):"""Do an efficient update of the we...
对tensor的处理函数：expand_as（尺寸扩展），nonzero（获取非零元素索引）
最新发布
m0_48086806的博客
11-23 285
对tensor的处理函数：expand_as（尺寸扩展），nonzero（获取非零元素索引）
TensorMask
weixin_30684743的博客
04-11 578
原文地址：https://arxiv.org/pdf/1903.12174.pdf 论文阅读：http://www.zhenzhujue.cn/article-36456-1.html https://blog.csdn.net/qq_37014750/article/details/88916756 转载于:https://www.cnblogs.com/herd/p/10687406.ht...
将二维tensor矩阵中不为0元素转换为一维向量
zxs0222的博客
07-31 1775
将二维tensor矩阵中不为0元素转换为一维向量
PyTorch中 tensor.detach() 和 tensor.data 的区别详解
09-18
今天小编就为大家分享一篇PyTorch中 tensor.detach() 和 tensor.data 的区别详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
基于tf.shape(tensor)和tensor.shape()的区别说明
09-16
在TensorFlow中，理解和掌握`tf.shape(tensor)`与`tensor.shape()`的区别是非常重要的，因为它们在处理张量的形状信息时有不同的特性和用途。这里我们将深入探讨这两种方法，并提供一些实用的示例来帮助理解。 首先...
pytorch中tensor.expand()和tensor.expand_as()函数详解
12-23
tensor.expend()函数 >>> import torch >>> a=torch.tensor([[2],[3],[4]]) >>> print(a.size()) torch.Size([3, 1]) >>> a.expand(3,2) tensor([[2, 2], [3, 3], [4, 4]]) >>> a tensor([[2], [3], [4]]) 可以...
one hot编码：`torch.Tensor.scatter_()`函数用法详解
01-07
torch.Tensor.scatter_()是torch.gather()函数的方向反向操作。两个函数可以看成一对兄弟函数。gather用来解码one hot，scatter_用来编码one hot。 scatter_(dim, index, src) → Tensor dim (python:int) – 用来...
tensorflow 生成一个tensor的mask
曲草的博客
09-17 3183
import tensorflow as tf a = tf.constant([[-1, 2, 3], [2, -3, 4], [5, 6, -7]], dtype=tf.float32) d = tf.ones(shape=[3, 3], name='a') e = tf.zeros(shape=[3, 3], name=...
TensorMask: A Foundation for Dense Object Segmentation
761527200_leili的博客
10-18 340
一.摘要 1.基于滑动窗口的目标检测生成稠密，规则网格的bounding-box是很火热的 2.相比之下，现代的实例分割方法被后述的方法所主导，它首先检测对象边界框，然后裁剪和分割这些区域，如Mask R-CNN所推广的那样 3.object detection中有dense的方法（如yolo，ssd，retinanet），也有R-CNN这类two-stage的方法；然而在instance s...
三维Tensor维度分析,举例mask[0,:],mask[:,:,0],mask[:,0,:]
weixin_43889476的博客
06-10 1468
设三维张量的shape是x、y、z，则可理解为它是由x个二维张量构成，每个二维张量由y个一维张量构成，每个一维张量由z个标量构成。 三种颜色分别代表三个维度.
【深度学习】【ICCV2019】TensorMask：A Foundation for Dense Object Segmentation
Hana
04-16 335
【ICCV2019】TensorMask：A Foundation for Dense Object Segmentation概要结构实验 概要 目前(2019年前）基于密集网格式的滑动窗口目标检测器很流行也很成功(SSD，RetinaNet等)，但是实例分割仍是由先检测再分割的Mask R-CNNR-CNN主导。本文提出了一个4D张量来代表预测的mask(其实就是将通道表示成一个固定大小区域的...
计算机视觉与深度学习 | TensorMask: A Foundation for Dense Object Segmentation（何凯明团队新作）近5年目标检测综述
尘世冰封的专栏
03-30 3350
博主github：https://github.com/MichaelBeechan 博主CSDN：https://blog.csdn.net/u011344545 TensorMask：https://arxiv.org/pdf/1903.12174.pdf 2019 RCNN：https://arxiv.org/pdf/1311.2524v3.pdf ...
【简单理解】torch.nonzero（同样适用于获取tensor中某一元素的索引）
pywin
06-09 5530
torch.nonzero其实就是找出tensor中非零的元素的索引 import torch label = torch.tensor([[1,0,0], [1,0,1]]) print(label.nonzero()) 返回的结果： tensor([[0, 0], [1, 0], [1, 2]]) 返回的结果就是非零元素的索引，其中[0,0]对应了第一行第一列的1，[1,0]对应了第二行第一列的1，[1,2]对应了第
Pytorhc中的Torch.tensor.masked_fill_(mask, value)函数拓展
乄洛尘
04-29 1307
照例，吐槽一下之前CSDN博客中关于tensor.masked_fill_ (mask,value)函数，如你所见，大部分的博客都是强调 mask 的 shape 必须和tensor一样，但是咋就没有同学考虑广播机制的存在捏？
记录一个torch.tensor的语法，用于mask挑选tensor中的值
weixin_44587732的博客
03-22 672
kk = torch.tensor([[4,5],[7,8]]) x = torch.zeros(2,2) y = torch.tensor([[1,0],[0,1]]) print([x.byte() |y.byte()]) print(kk[x.byte() |y.byte()]) outputs:
nonzero()函数
c_living的博客
06-25 2914
该函数是获得矩阵中的非0数据的下标的，会通过什么来表示呢？我们通过下面的例子就可以清楚的发现了： 假设有程序如下： from numpy import * b = array([ [1,1,1,0,1,1], [1,1,1,0,1,0], [1,1,1,0,1,1] ]) mat(b) c = nonzero(b) print mat(c) 那么输出会是： [[...
torch.nonezero()的用法
打呼噜的星
09-06 965
如果输入input有n维，则输出的索引张量output的形状为 z x n, 这里 z 是输入张量input中所有非零元素的个数。返回一个包含输入input中非零元素索引的张量。输出张量中的每行包含输入中非零元素的索引。out (LongTensor, optional) – 包含索引值的结果张量。input (Tensor) – 源张量。
torch.nn.transformer进行文本分类
05-27
mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0)) return mask def init_weights(self): initrange = 0.1 self.encoder.weight.data.uniform_(-initrange, ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值