selective kernel networks

选择性核网络 (Selective Kernel Networks) 是一种新型的深度学习架构，它通过在网络的不同层使用不同的核函数来提高模型的效率和性能。这些核函数可以是高斯核、多项式核等。选择性核网络可以在计算和存储资源有限的环境中获得更高的准确率。

相关问题

用python写一个Selective Kernel Attention 注意力模块的代码

好的，以下是Selective Kernel Attention 注意力模块的 Python 代码：

import torch
import torch.nn as nn


class ScaledDotProductAttention(nn.Module):
    def __init__(self, temperature):
        super().__init__()
        self.temperature = temperature
        
    def forward(self, q, k, v, mask=None):
        attn = torch.matmul(q / self.temperature, k.transpose(2, 3))
        if mask is not None:
            attn = attn.masked_fill(mask == 0, -1e9)
        attn = nn.Softmax(dim=-1)(attn)
        output = torch.matmul(attn, v)
        return output, attn

class SKAttention(nn.Module):
    def __init__(self, d_model, d_k, d_v, n_heads, n_sk, dropout):
        super().__init__()
        self.n_heads = n_heads
        self.n_sk = n_sk
        self.d_k = d_k
        self.d_v = d_v
        
        self.w_qs = nn.Linear(d_model, n_heads * n_sk * d_k, bias=True)
        self.w_ks = nn.Linear(d_model, n_heads * n_sk * d_k, bias=True)
        self.w_vs = nn.Linear(d_model, n_heads * n_sk * d_v, bias=True)
        
        self.attention = ScaledDotProductAttention(temperature=d_k ** 0.5)
        self.proj_o = nn.Linear(n_heads * n_sk * d_v, d_model, bias=True)
        
        self.dropout = nn.Dropout(dropout)
        self.layer_norm = nn.LayerNorm(d_model, eps=1e-6)
        self.fc = nn.Linear(d_model, d_model, bias=True)
        
    def forward(self, query, key, value, mask=None):
        batch_size = query.size(0)
        residual_xs = query
        
        q_s = self.w_qs(query).view(batch_size, -1, self.n_heads, self.n_sk, self.d_k)
        k_s = self.w_ks(key).view(batch_size, -1, self.n_heads, self.n_sk, self.d_k)
        v_s = self.w_vs(value).view(batch_size, -1, self.n_heads, self.n_sk, self.d_v)
        
        q = q_s.permute(2, 0, 3, 1, 4).contiguous().view(-1, self.n_sk, self.d_k)
        k = k_s.permute(2, 0, 3, 1, 4).contiguous().view(-1, self.n_sk, self.d_k)
        v = v_s.permute(2, 0, 3, 1, 4).contiguous().view(-1, self.n_sk, self.d_v)
        
        mask = mask.repeat(self.n_heads, self.n_sk, 1, 1)
        
        output, attn = self.attention(q, k, v, mask=mask)
        
        output = output.view(self.n_heads, batch_size, self.n_sk, self.d_v)
        output = output.permute(1, 2, 0, 3).contiguous().view(batch_size, -1, self.n_heads * self.n_sk * self.d_v)

        proj_o = self.proj_o(output)
        output = self.layer_norm(residual_xs + proj_o)
        
        fc_output = self.fc(output)
        output = self.dropout(fc_output)
        output = self.layer_norm(output + output)
        
        return output, attn

希望能够帮到你。

insertSelective

`insertSelective` 是一个在数据库中执行插入操作的方法。它的作用是向数据库表中插入一条新的记录，但只插入指定的非空字段，忽略其他为空的字段。

这个方法通常用于在插入数据时避免将空字段插入到数据库中，只插入有值的字段，以保持数据的完整性和一致性。

使用这个方法时，你需要提供一个包含需要插入的字段和对应值的对象或实体，并调用数据库操作的方法来执行插入操作。这样就可以只插入指定非空字段的记录了。

需要注意的是，具体使用方法可能因不同的编程语言和数据库框架而有所不同。在具体使用时，请参考相应的文档或示例代码来正确调用 `insertSelective` 方法。