精华内容
下载资源
问答
  • 这里重点介绍pandas的where mask函数,如果能从这两个函数的用法get到pandas的精髓就再好不过了。 用法说明,官方的用法说明比较简洁: where :替换条件(condition)为Flase处的值 mask :替换条件(condition)为...

    Pandas是Python数据科学生态中重要的基础成员,功能强大,用法灵活,简单记录之。更佳阅读体验可移步 Pandas核心概述

    这里重点介绍pandas的where mask函数,如果能从这两个函数的用法get到pandas的精髓就再好不过了。

    用法说明,官方的用法说明比较简洁:
    where :替换条件(condition)为Flase处的值
    mask :替换条件(condition)为True处的值

    where(self, cond, other=nan, inplace=False,
    	  axis=None, level=None, errors='' raise', try_cast=False)
    	  
    mask(self, cond, other=nan, inplace=False,
    	  axis=None, level=None, errors='' raise', try_cast=False)
    

    当然,这里的condition 自然就是参数列表中的 cond,既然是替换值。
    那么替换后的值是什么呢,就是参数列表中的other ,方法还为other指定了默认值None。

    下面先用pandas中的Series对象测试一下:

    #定义一个Series
    s = pd.Series(range(5))
    s
    0    0
    1    1
    2    2
    3    3
    4    4
    dtype: int64
    
    #执行where函数
    s.where(s > 2,"我的自定义")
    0    我的自定义
    1    我的自定义
    2    我的自定义
    3        3
    4        4
    dtype: object
    #符合条件的显示原来的数据,不符合条件的显示 **other**参数给定的值
    
    #执行mask函数
    s.mask(s > 2,"我的自定义")
    0        0
    1        1
    2        2
    3    我的自定义
    4    我的自定义
    dtype: object
    #符合条件的显示 **other**参数给定的值,不符合条件的显示原来的数据
    

    上面解释说参数 cond传入布尔值,那么我们来看下s>2,究竟是什么东西

    s > 2
    0    False
    1    False
    2    False
    3     True
    4     True
    dtype: bool
    

    以上的操作已经很容易看懂这俩函数的用法,好像这俩函数就是一个相反的函数,在条件一致的情况下得到的结果是相反的,也就是说如果定义m=s>2, 以下两个函数的结果应该是相同的。

    m=s>2
    s.where(m,"我的自定义")
    s.mask(~m ,"我的自定义")
    

    于是以下会得到一组布尔值

    s.where(m,"我的自定义")==s.mask(~m ,"我的自定义")
    0    True
    1    True
    2    True
    3    True
    4    True
    dtype: bool
    

    上面我们仅仅是用了自己定义的一个数,如果我们用一组数呢

    s.where(s > 2,  pd.Series(range(10,15)))
    0    10
    1    11
    2    12
    3     3
    4     4
    dtype: int64
    
    

    也成功的替换成了给定Series对应下标的值

    那么我们猜测他就是按照下标去对应值,我们换一个长度不一致的Series呢

    s.where(s > 2,  pd.Series(range(10,300)))
    
    #结果和上面一致
    

    下面用DataFrame进行测试,验证一下就好了

    df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])
    df
    	A	B
    0	0	1
    1	2	3
    2	4	5
    3	6	7
    4	8	9
    

    测试函数:
    条件是 DF中的元素被3除尽 根据函数要求返回-df中的相应值

    m=df % 3 == 0
    m
     	 A	       B
    0	True	False
    1	False	True
    2	False	False
    3	True	False
    4	False	True
    
    #where : 不满足条件返回other
    df.where(m, -df)
    A	B
    0	0	-1
    1	-2	-3
    2	-4	-5
    3	6	7
    4	8	9
    
    #mask : 满足条件返回other
    df.mask(m,-df)
    	A	B
    0	0	1
    1	2	3
    2	4	5
    3	-6	-7
    4	-8	-9
    
    df.where(m, -df) == df.mask(~m, -df)
    A	B
    0	True	True
    1	True	True
    2	True	True
    3	True	True
    4	True	True
    

    官方文中还讲了numpy中另外一个函数的用法与这俩相同

    np.where(m, df, -df)
    array([[ 0, -1],
           [-2,  3],
           [-4, -5],
           [ 6, -7],
           [-8,  9]])
    #输出上好像格式不太一样
    
    df.where(m, -df) == np.where(m, df, -df)
    A	B
    0	True	True
    1	True	True
    2	True	True
    3	True	True
    4	True	True
    

    也能说明pandas和numpy的关系,pansdas是基于Numpy的一种工具

    df.where()   
    df.mask()  
    np.where()  
    

    以上三个函数
    上面我们也看到DF的操作其实是非常随心所欲的一个“-df”就把里面所有的元素都取相反数了,一个比较运算符(如 df>2)就可以取所有元素运算的布尔结果,感觉excel是不是弱爆了。

    可能会有些啰嗦,但我觉得这样展示出来,可能才会有点收获😂

    展开全文
  • tf.boolean_mask 的作用是 通过布尔值 过滤元素 def boolean_mask(tensor, mask, name="boolean_mask", axis=None): """Apply boolean mask to tensor. tensor:被过滤的元素 mask:一堆 bool 值,它的维度不...

    tf.boolean_mask 的作用是 通过布尔值 过滤元素

    def boolean_mask(tensor, mask, name="boolean_mask", axis=None):
      """Apply boolean mask to tensor.

    tensor:被过滤的元素

    mask:一堆 bool 值,它的维度不一定等于 tensor

    return: mask 为 true 对应的 tensor 的元素

    当 tensor 与 mask 维度一致时,return 值为一维

    那么return值的维度是否有规律可循呢?是有的:

    shape

    有如下规则,假设 tensor.shape=(m,n,p,q),则

    (1)当mask.shape=(m,n,p,q),结果返回(?,)

    (2)当mask.shape=(m,n,p),结果返回(?,q),表示 q 维度没有过滤

    (3)当mask.shape=(m,n),结果返回(?,p,q),p,q维度未被过滤

    (4)当mask.shape=(m),结果返回(?,n,p,q),m维度被过滤

    这个函数最大的特点就是无论哪种调用方式return值得shape都是动态的

    展开全文
  • keras中的mask操作 1.使用背景 最常见的一种情况, 在NLP问题的句子补全方法中, 按照一定的长度, 对句子进行填补和截取操作. 一般使用keras.preprocessing.sequence包中的pad_sequences方法, 在句子前面或者后面补0. ...

    keras中的mask操作
    1.使用背景
    最常见的一种情况, 在NLP问题的句子补全方法中, 按照一定的长度, 对句子进行填补和截取操作. 一般使用keras.preprocessing.sequence包中的pad_sequences方法, 在句子前面或者后面补0. 但是这些零是我们不需要的, 只是为了组成可以计算的结构才填补的. 因此计算过程中, 我们希望用mask的思想, 在计算中, 屏蔽这些填补0值得作用. keras中提供了mask相关的操作方法.
    2.原理
    在keras中, Tensor在各层之间传递, Layer对象接受的上层Layer得到的Tensor, 输出的经过处理后的Tensor.
    keras是用一个mask矩阵来参与到计算当中, 决定在计算中屏蔽哪些位置的值. 因此mask矩阵其中的值就是True/False, 其形状一般与对应的Tensor相同. 同样与Tensor相同的是, mask矩阵也会在每层Layer被处理, 得到传入到下一层的mask情况.
    3.使用方法
    最直接的, 在NLP问题中, 对句子填补之后, 就要输入到Embedding层中, 将token由id转换成对应的vector. 我们希望被填补的0值在后续的计算中不产生影响, 就可以在初始化Embedding层时指定参数mask_zero为True, 意思就是屏蔽0值, 即填补的0值.
    在Embedding层中的compute_mask方法中, 会计算得到mask矩阵. 虽然在Embedding层中不会使用这个mask矩阵, 即0值还是会根据其对应的向量进行查找, 但是这个mask矩阵会被传入到下一层中, 如果下一层, 或之后的层会对mask进行考虑, 那就会起到对应的作用.
    也可以在keras.layers包中引用Masking类, 使用mask_value指定固定的值被屏蔽. 在调用call方法时, 就会输出屏蔽后的结果.
    需要注意的是Masking这种层的compute_mask方法, 源码如下:

    def compute_mask(self,inputs,mask=None):
    	output_mask = K.any(K.not_equal(inputs,self.mask_value),axis=-1)
    	return output_mask
    

    可以看到,这一层输出的mask矩阵,是根据这层的输入得到的,具体的说是会比较输入的第一个维度,这是因为最后一个维度被K.any(axis=-1)给去掉了,在使用时需要注意这种操作的意义以及维度的变化。
    4.自定义使用方法
    更多的,我们还是在自定义的层中,需要支持mask的操作,因此需要对应的逻辑。
    如果我们希望自定义的这个层支持mask操作,就需要在__init__方法中指定

    self.supports_masking = True
    

    如果在本层计算中需要使用到mask,则call方法需要多传入一个mask参数,即

    def call(self,inputs,mask=None):
    	pass
    

    然后,如果还要继续输出mask,供之后的层使用,如果不对mask矩阵进行变换,这不用进行任何操作,否则就需要实现compute_mask函数

    def compute_mask(self,inputs,mask=None):
    	pass
    

    这里的inputs就是输入的Tensor,与call方法中接收到的一样,mask就是上层传入的mask矩阵。
    如果希望mask到此为止,之后的层不再使用,则该函数直接返回None即可。

    def compute_mask(self,inputs,mask=None):
    	return  None
    

    如果你看到一个网络层的call函数如下定义的:

    class MultiHeadAttention(keras.layers.Layer):
    	def __init__():
    
    	def call(self,inputs,mask=None,**kwargs):
    

    发现这里的call函数中有mask的对应值,但是找不到mask在哪定义的,有可能是上一个网络层往下一个网络层之中传入的参数
    回看上一层网络层之中的compute_mask函数的定义:

    class Embedding(keras.layers.Embedding):
    	def compute_mask(self,inputs,mask=None):
    		mask = super(Embedding,self).compute_mask(inputs,mask)
    

    此时这里的mask就被定义出来了
    接着回看父类定义的compute_mask的内容

    def compute_mask(self, inputs, mask=None):
        if not self.mask_zero:
            return None
        output_mask = K.not_equal(inputs, 0)
        return output_mask
    

    因此这里的compute_mask的相应内容起源于keras.layers.Embedding之中定义的compute_mask函数的相应运算

    从Embedding层中对应的计算mask的compute_mask函数会传入下一个网络层的call函数之中

    def compute_mask(self, inputs, mask=None):
        if K.ndim(inputs) == 2:
            #before mask = None
            #inputs = Tensor("Input-Token:0",shape=(?,?),dtype=float32)
            mask = super(Embedding, self).compute_mask(inputs, mask)
            #after mask = (?,?),Tensor("Embedding-Token",shape=(?,?)
            if mask is not None:
                mask1 = K.ones_like(mask[:, :1], dtype='bool')
                mask2 = mask[:, 1:]
                return K.concatenate([mask1, mask2], 1)
        else:
            return mask
    

    这里定义的mask的内容会传入下一个网络层MultiHeadAttention的call函数之中
    下一层的MultiHeadAttention中的call函数的mask就是前面网络层使用compute_mask函数传入的mask的内容

        def call(self, inputs, mask=None, **kwargs):
            """实现多头注意力
            q_mask: 对输入的query序列的mask。
                    主要是将输出结果的padding部分置0。
            v_mask: 对输入的value序列的mask。
                    主要是防止attention读取到padding信息。
            """
            print('MultiHeadAttention call')
            q, k, v = inputs[:3]
            r"""
            q = (?,?,768),k = (?,?,768),v = (?,?,768)
            """
            q_mask, v_mask = None, None
            if mask is not None:
                q_mask, v_mask = mask[0], mask[2]
            # 线性变换
            qw = self.q_dense(q)
            kw = self.k_dense(k)
            vw = self.v_dense(v)
            # 形状变换
            qw = K.reshape(qw, (-1, K.shape(q)[1], self.heads, self.key_size))
            kw = K.reshape(kw, (-1, K.shape(k)[1], self.heads, self.key_size))
            vw = K.reshape(vw, (-1, K.shape(v)[1], self.heads, self.head_size))
            # Attention
            #qw = (?,?,12,64),kw = (?,?,12,64),vw = (?,?,12,64)
            #inputs[3:] = [<tf.Tensor 'Attention-UniLM-Mask/mul:0'
            #shape = (?,1,?,?) dtype = float32>]
            qkv_inputs = [qw, kw, vw] + inputs[3:]
            qv_masks = [q_mask, v_mask]
            #qv_masks = [Embedding-Token-Segment(?,?),Embedding-Token_Segment(?,?)]
            o, a = self.pay_attention_to(qkv_inputs, qv_masks, **kwargs)
            # 完成输出
            o = K.reshape(o, (-1, K.shape(o)[1], self.head_size * self.heads))
            o = self.o_dense(o)
            # 返回结果
            if self.return_attention_scores:
                return [o, a]
            else:
                return o
    

    这里Attention的原版公式为
    Attention(Q,K,V)=softmax(QKTdk)VAttention(Q,K,V) = softmax(\frac{QK^{T}}{\sqrt{d_{k}}})*V
    Attention(Q,K,V)=softmax(mask(QKTdk+abias))VAttention(Q,K,V) = softmax(mask(\frac{QK^{T}}{\sqrt{d_{k}}}+a_{bias}))*V
    这里放出将QKTdk+abias\frac{QK^{T}}{\sqrt{d_{k}}}+a_{bias}进行遮盖的函数源码,遮盖部分主要用于对于padding部分的遮盖

    def sequence_masking(x, mask, value=0.0, axis=None):
        """为序列条件mask的函数
        mask: 形如(batch_size, seq_len)的0-1矩阵;
        value: mask部分要被替换成的值,可以是'-inf'或'inf';
        axis: 序列所在轴,默认为1;
        """
        #这里放入的是return sequence_masking(inputs,mask,'-inf',1)
        #日常送入进去的内容为a = sequence_masking(a,v_mask,'-inf',-1)
        if mask is None:
            return x
        else:
            if K.dtype(mask) != K.dtype(x):
                mask = K.cast(mask, K.dtype(x))
            if value == '-inf':
                value = -1e12
            elif value == 'inf':
                value = 1e12
            if axis is None:
                axis = 1
            elif axis < 0:
                axis = K.ndim(x) + axis
            #axis = 3
            assert axis > 0, 'axis must be greater than 0'
            #x = (?,12,?,?),mask = (?,?),value = -1e-12
            for _ in range(axis - 1):
                mask = K.expand_dims(mask, 1)
            #mask1 = (?,1,1,?)
            for _ in range(K.ndim(x) - K.ndim(mask)):
                mask = K.expand_dims(mask, K.ndim(mask))
            #mask2 = (?,1,1,?)
            return x * mask + value * (1 - mask)
    
    展开全文
  • static int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm,  struct snd_pcm_hw_params *params,  snd_pcm_hw_param_t var,  const struct snd_mask *v
    static int snd_pcm_hw_param_mask(struct snd_pcm_substream *pcm,
                     struct snd_pcm_hw_params *params,
                     snd_pcm_hw_param_t var,
                     const struct snd_mask *val)
    {
        int changed = _snd_pcm_hw_param_mask(params, var, val);
        if (changed < 0)
            return changed;
        if (params->rmask) {
            // 如果添加了新的mask->bits[]位,
            // 那么params->rmask相应var位将被置位,进而提示是该var引发了此次改变,
            // 执行如下函数,进一步执行回掉处理函数,让
            // 新的bit参数对audio系统生效[luther.gliethttp]
            int err = snd_pcm_hw_refine(pcm, params); 《浅析alsa声卡驱动snd_pcm_hw_refine函数》
            if (err < 0)
                return err;
        }
        return 0;
    }

    static int _snd_pcm_hw_param_mask(struct snd_pcm_hw_params *params,
                      snd_pcm_hw_param_t var,
                      const struct snd_mask *val)
    {
        int changed;
        changed = snd_mask_refine(hw_param_mask(params, var), val); // 进行交集计算
        if (changed) {
            params->cmask |= 1 << var;
            params->rmask |= 1 << var; // 标识var发生改变
        }
        return changed;
    }
    展开全文
  • GEE中的掩膜函数mask,unmask,updateMask

    千次阅读 2020-11-30 14:56:51
    1. mask函数 使用方法:image.mask(),会将影像的掩膜区域与非掩膜区域用0和1区分开来,其中1代表为掩膜,0代表已掩膜。影像的边框范围内,黑色代表已被掩膜的区域,白色代表未掩膜区域。 2.unmask函数 使用方法,...
  • Pytorch mask_select 函数

    万次阅读 2018-08-14 15:21:40
    非常简单的函数,但是官网的介绍令人(令我)迷惑,所以稍加解释。 mask_select会将满足mask(掩码、遮罩等等,随便翻译)的指示,将满足条件的点选出来。 根据掩码张量mask中的二元值,取输入张量中的指定项( ...
  • ALIGN(x, mask)函数详解

    千次阅读 2017-02-06 11:56:46
    ALIGN(x, mask)函数详解 详细定义为: #define ALIGN(x, mask) (((x) + (mask-1)) & ~(mask-1)) 功能为:对x取mask的整数倍,如果x没有达到mask的最接近整数倍,补值达到最近的整数倍 实例: 设x=5,mask=32 ~...
  • 最近学习Unix的时候碰到了mode_t umask(mode_t mask函数。刚开始的时候把mask设为0022,结果得到的umask为0026。反复试验后,原因如下: umask是一个八进制的数,mask参数是一个10进制的数,10进制的22转化为八...
  • 非常简单的函数,但是官网的介绍令人(令我)迷惑,所以稍加解释。 mask_select会将满足mask(掩码、遮罩等等,随便翻译)的指示,将满足条件的点选出来。 根据掩码张量mask中的二元值,取输入张量中的指定项( ...
  • setlogmask(int mask)函数讲解

    千次阅读 2016-06-08 17:56:09
    setlogmask函数设置syslog记录屏蔽字。参数int mask低8位是syslog记录的屏蔽字,对应关系如下。 bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0 LOG_DEBUG ...
  • Mask-RCNN损失函数分析

    2021-01-16 13:14:30
    之前的文章对Faster-RCNN进行了源代码分析 faster-RCNN1faster-RCNN2faster-RCNN,本文将进一步讲解Mask-RCNN的损失函数,首先需要了解Mask-RCNN是基于Faster-RCNN实现的,只是在原有基础结构上加入了Mask层,实现...
  • tf.sequence_mask()函数

    2020-03-07 00:21:04
    文章目录tf.sequence_mask()函数例子只给定lengths时给定lengths和maxlen时(dtype不给定,默认为bool)定义lengths,maxlen,dtype时 tf.sequence_mask()函数 sequence_mask( lengths, # 原始序列长度 maxlen=...
  • tf.boolean_mask() 函数

    2020-02-02 09:52:46
    使用tf.boolean_mask用来过滤概率值比较低的锚盒,这个函数的一个参数b为滤波器掩模,生成掩模要用到逻辑表达式(>或者<)生成布尔值,假设阈值threshold=C,并且当mask和tensor的维度相同时,输出1维矩阵 def...
  • Function Name:zalloc_cpumask_var_nodeFunction:static inline bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node)Return Type:static inline boolParameter:TypeParameter NameRemarkscpu...
  • python中tf.boolean_mask()函数的使用

    千次阅读 2020-12-23 16:43:06
      tf.boolean_mask() 函数的作用是通过布尔值对指定的列的元素进行过滤。 语法结构 boolean_mask(tensor, mask, name="boolean_mask", axis=None) 其中,tensor:被过滤的元素    mask:一堆bool值,它的...
  • <div><p>module中的mask函数分为key_mask和future_mask,future_mask是decoder中防止看到未来答案的mask,key_mask是什么? what is key_mask in modules's mask????</p><p>该提问来源于开源...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,392
精华内容 956
关键字:

mask函数