xttmp 2.3.0__py3-none-any.whl

xttmp/core/feedbackstmd_core.py

@@ -0,0 +1,61 @@
+import torch
+import torch.nn.functional as F
+
+from .base_core import BaseCore
+from .math_operator import SpatialInhibition, GammaDelay
+from ..util.create_kernel import create_2d_gaussian_kernel
+
+
+class Lobula(BaseCore):
+    """ Lobula layer of the motion detection system."""
+    
+    def __init__(self):
+        """Constructor method."""
+        # Initializes the Lobula object
+        super().__init__()
+        self.spatial_inhibition = SpatialInhibition()  # SpatialInhibition component
+        self.alpha = 1  # Parameter alpha
+        self.sigma = 1.5  # Parameters for Gaussian kernel
+
+        self.gamma_delay = GammaDelay(10, 25)  # GammaDelay component
+
+        self.register_buffer('gaussian_kernel', torch.empty(0))  # Buffer for Gaussian kernel
+
+        self.setup()
+
+    def setup(self):
+        """ Initialization method."""
+        # Initializes the Lobula layer component
+        self.spatial_inhibition.setup()
+        self.gamma_delay.setup()
+
+        self.gaussian_kernel.data = create_2d_gaussian_kernel(size=3, sigma=self.sigma)
+
+        self.reset_buffer()
+
+    def reset_buffer(self):
+        """ Resets the buffer of certain components. """
+        self.gamma_delay.reset_buffer()
+
+    def forward(self, medulla_ON, medulla_OFF):
+        """ Processing method. """
+        # Performs temporal convolution, correlation, and surround inhibition
+
+        # Formula (9)
+        feedback_output = self.alpha * self.gamma_delay.forward(torch.zeros_like(medulla_ON))
+
+        # Formula (8)
+        ON_with_feedback = torch.clamp(medulla_ON - feedback_output, min=0) 
+        OFF_with_feedback = torch.clamp(medulla_OFF - feedback_output, min=0)
+        correlation_D = ON_with_feedback * OFF_with_feedback
+
+        # Formula (10)
+        correlation_E = F.conv2d(medulla_ON * medulla_OFF, self.gaussian_kernel, padding='same')
+
+        # Only record (correlationD + correlationE) for next delay in Formula (9)
+        self.gamma_delay.buffer[-1] = correlation_D + correlation_E
+
+        # Formula (14)
+        self.output = self.spatial_inhibition(correlation_D)
+
+        return self.output

xttmp/core/fracstmd_core.py

@@ -0,0 +1,98 @@
+import math
+
+import torch
+from collections import deque
+
+from .base_core import BaseCore
+from ..util.create_kernel import create_fracdiff_kernel
+from ..core.math_operator import compute_temporal_conv_inplace
+
+
+class Lamina(BaseCore):
+    """
+    Lamina layer in ESTMD.
+    Pure PyTorch Implementation supporting both IIR (iteration) and FIR (convolution) modes.
+    """
+    def __init__(self, alpha=0.8, delta=20, mode='iteration'):
+        """
+        Constructor method.
+        
+        Parameters:
+        - alpha: Fractional differential order (0 < alpha <= 1)
+        - delta: Length of the historical buffer for convolution
+        - mode: 'iteration' (IIR, fast) or 'conv' (FIR, accurate but slower)
+        """
+        super().__init__()
+        self.alpha = alpha
+        self.delta = delta
+        self.mode = mode
+
+        self.register_buffer('frac_kernel', torch.empty(0))  
+
+        self.setup()
+
+    def setup(self):
+
+        _kernel = create_fracdiff_kernel(self.alpha, self.delta)
+        self.frac_kernel.data = _kernel
+
+        # 2. 计算迭代模式 (IIR) 的系数
+        self.para_cur = _kernel[0].item()
+        
+        if self.alpha == 1.0:
+            self.para_pre = 0.0
+        elif 0.0 < self.alpha < 1.0:
+            self.para_pre = math.exp(-self.alpha / (1.0 - self.alpha))
+        else:
+            raise ValueError("Invalid alpha value. Must be in (0, 1].")
+        
+        self.reset_buffer()
+
+    def reset_buffer(self):
+        # 3. 初始化时序状态 (State)
+        self.state_ipt = None  
+        self.state_opt = None 
+        self.buffer = deque(maxlen=self.delta) 
+
+    def forward(self, x):
+        """
+        Processing method.
+        x shape: (B, C, H, W)
+        """
+
+        # --- 1. 计算一阶差分 (First order difference) ---
+        if self.state_ipt is None:
+            diff_x = torch.zeros_like(x)
+        else:
+            diff_x = x - self.state_ipt
+        
+        # 使用 .detach() 截断计算图，防止处理长视频时 GPU 显存爆炸
+        self.state_ipt = x.detach()
+
+        # --- 2. 选择计算模式 ---
+        if self.mode == 'iteration':
+            self.output = self._compute_by_iteration(diff_x)
+        elif self.mode == 'conv':
+            self.output = self._compute_by_conv(diff_x)
+        else:
+            raise ValueError("Mode must be 'iteration' or 'conv'.")
+
+        return self.output
+
+    def _compute_by_iteration(self, diff_x):
+        """IIR (无限脉冲响应) 迭代计算法 - 极速模式"""
+        if self.state_opt is None:
+            opt = diff_x
+        else:
+            opt = self.para_cur * diff_x + self.para_pre * self.state_opt
+        
+        # 同样使用 .detach() 截断历史图
+        self.state_opt = opt.detach()
+        
+        return opt
+
+    def _compute_by_conv(self, diff_x):
+        """FIR (有限脉冲响应) 卷积计算法 - 基于历史缓存"""
+        self.buffer.append(diff_x)
+        
+        return compute_temporal_conv_inplace(self.buffer, self.frac_kernel)

xttmp/core/fstmd_core.py

@@ -0,0 +1,15 @@
+from .math_operator import GammaDelay
+
+
+class FeedbackPathway(GammaDelay):
+    """FeedbackPathway class for the feedback pathway."""
+
+    def __init__(self):
+        """Constructor method."""
+        # Initializes the FeedbackPathway object
+        super().__init__(5, 10)
+        
+        self.feedback_coefficient = 0.22
+
+    def forward(self, x):
+        return self.feedback_coefficient * super().forward(x)

xttmp/core/fstmdv2_core.py

@@ -0,0 +1,42 @@
+import numpy as np
+
+from . import fracstmd_core
+
+class Lamina(fracstmd_core.Lamina):
+    """Lamina class for the lamina layer."""
+
+    def __init__(self):
+        """Constructor method."""
+        # Initializes the Lamina object
+        super().__init__()
+        self.loopLaminaOpt = None
+        self.isInLoop = False
+
+    def forward(self, LaminaIpt):
+        """Processing method."""
+        # Processes the LaminaIpt to generate the lamina output
+        if self.preLaminaIpt is None:
+            diffLaminaIpt = np.zeros_like(LaminaIpt)
+        else:
+            # First order difference
+            diffLaminaIpt = LaminaIpt - self.preLaminaIpt
+        
+        laminaOpt = self.compute_by_iteration(diffLaminaIpt)
+        self.Opt = laminaOpt
+        
+        if not self.isInLoop:
+            self.preLaminaIpt = LaminaIpt
+
+        return laminaOpt
+
+    def compute_by_iteration(self, diffLaminaIpt):
+        """Compute lamina output by iteration."""
+        if self.preLaminaOpt is None:
+            laminaopt = self.paraCur * diffLaminaIpt
+        else:
+            if not self.isInLoop:
+                self.preLaminaIpt = self.loopLaminaOpt
+            laminaopt = self.paraCur * diffLaminaIpt + self.paraPre * self.preLaminaOpt
+        
+        self.loopLaminaOpt = laminaopt
+        return laminaopt

xttmp/core/haarstmd_core.py

@@ -0,0 +1,140 @@
+from collections import deque
+
+import torch
+from torch.nn import functional as F
+
+from .base_core import BaseCore
+from .math_operator import (compute_temporal_conv_inplace, 
+                            SpatialInhibition, GammaDelay)
+
+
+
+class Medulla(BaseCore):
+    def __init__(self):
+        super().__init__()
+        self.temporal_kernel_len = 15 # a
+        self.spatial_kernel_size = 7 # r
+        self.register_buffer('theta_list', torch.tensor([(i * torch.pi / 4) for i in range(8)]))
+
+        self.register_buffer('temporal_ON_kernel', torch.empty(0))
+        self.register_buffer('temporal_OFF_kernel', torch.empty(0))
+
+        self.delay_on = GammaDelay(10, 1)
+        self.delay_off = GammaDelay(10, 1)
+
+        self.medulla_input_buffer = deque(maxlen=self.temporal_kernel_len)
+
+        self.setup()
+
+    def setup(self):
+
+        # Temporal kernels
+        k1 = int(self.temporal_kernel_len / 2)
+
+        self.temporal_ON_kernel = torch.ones((k1, 1))
+        self.temporal_OFF_kernel = torch.vstack((torch.zeros((k1, 1)), -torch.ones((k1+1, 1))))
+
+        self.reset_buffer()
+
+    def reset_buffer(self):
+        # Allocate memory
+        self.medulla_input_buffer.clear()
+        self.delay_on.reset_buffer()
+        self.delay_off.reset_buffer()
+
+    @staticmethod
+    def direction_pooling(x, s=7):
+        """
+        高效计算 8 个方向的感受野池化 (均值)
+        x: 输入特征图 [B, C, H, W]
+        s: 池化窗口大小 (建议为奇数，例如 3, 5, 7)
+        """
+        H, W = x.shape[-2:]
+        
+        # 1. 确定最大偏移量：窗口大小减 1
+        p = s - 1
+        
+        # 2. 四周补齐 Padding
+        # 补齐后尺寸变为 (H + 2p, W + 2p)
+        padded_x = F.pad(x, (p, p, p, p))
+        
+        # 3. 仅做一次全局 AvgPool
+        # 步长设为 1，输出尺寸会自动变成 (H + p, W + p)
+        pooled = F.avg_pool2d(padded_x, kernel_size=(s, s), stride=1, padding=0)
+        pooled_on = torch.clamp(pooled, min=0)  
+        pooled_off = torch.clamp(-pooled, min=0)  
+        
+        # --- 4. 见证奇迹的切片时刻 ---
+        # 定义不同方向的起始坐标 (基于偏移量 p)
+        offset_min = 0          # 偏向上/左
+        offset_mid = p // 2     # 居中对齐
+        offset_max = p          # 偏向下/右
+        
+        spatial_ON_output = torch.cat([
+            pooled_on[..., offset_mid : offset_mid+H, offset_min : offset_min+W], # W
+            pooled_on[..., offset_max : offset_max+H, offset_min : offset_min+W], # SW
+            pooled_on[..., offset_max : offset_max+H, offset_mid : offset_mid+W], # S
+            pooled_on[..., offset_max : offset_max+H, offset_max : offset_max+W], # SE
+            pooled_on[..., offset_mid : offset_mid+H, offset_max : offset_max+W], # E
+            pooled_on[..., offset_min : offset_min+H, offset_max : offset_max+W], # NE
+            pooled_on[..., offset_min : offset_min+H, offset_mid : offset_mid+W], # N
+            pooled_on[..., offset_min : offset_min+H, offset_min : offset_min+W], # NW
+        ], dim=1)
+
+        spatial_OFF_output = torch.cat([
+            pooled_off[..., offset_mid : offset_mid+H, offset_max : offset_max+W], # E
+            pooled_off[..., offset_min : offset_min+H, offset_max : offset_max+W], # NE
+            pooled_off[..., offset_min : offset_min+H, offset_mid : offset_mid+W], # N
+            pooled_off[..., offset_min : offset_min+H, offset_min : offset_min+W], # NW
+            pooled_off[..., offset_mid : offset_mid+H, offset_min : offset_min+W], # W
+            pooled_off[..., offset_max : offset_max+H, offset_min : offset_min+W], # SW
+            pooled_off[..., offset_max : offset_max+H, offset_mid : offset_mid+W], # S
+            pooled_off[..., offset_max : offset_max+H, offset_max : offset_max+W], # SE
+        ], dim=1)
+        
+        return spatial_ON_output, spatial_OFF_output
+        
+    def forward(self, medullaIpt):
+
+        ''' Compute temporal part '''
+        self.medulla_input_buffer.append(medullaIpt)
+
+        temporal_ON_output = compute_temporal_conv_inplace(self.medulla_input_buffer, self.temporal_ON_kernel)
+        temporal_OFF_output = compute_temporal_conv_inplace(self.medulla_input_buffer, self.temporal_OFF_kernel)
+
+        # There's no need for half-wave rectification here
+        correlated_temporal_output = temporal_ON_output * temporal_OFF_output
+
+        ''' Compute spacial part '''
+        spatial_ON_output, spatial_OFF_output = self.direction_pooling(medullaIpt, self.spatial_kernel_size)
+
+        delayed_spatial_ON_output = self.delay_on.forward(spatial_ON_output)
+        delayed_spatial_OFF_output = self.delay_off.forward(spatial_OFF_output)
+
+        correlated_spatial_output = delayed_spatial_ON_output * delayed_spatial_OFF_output
+
+        # Store the output in output property
+        self.output = (correlated_spatial_output, correlated_temporal_output)
+
+        return self.output
+
+
+class Lobula(BaseCore):
+    def __init__(self):
+        super().__init__()
+        self.tau = 1  # a parameter to align the spacialOpt and temporalOpt
+        self.spatial_inhibition = SpatialInhibition()
+        self.spatial_inhibition.B = 1
+
+    def setup(self):
+        self.spatial_inhibition.setup()
+
+    def forward(self, correlated_spatial_output, correlated_temporal_output):
+        correlated_spatiotemporal_output = correlated_spatial_output * correlated_temporal_output
+
+        # Apply surround inhibition
+        self.output = torch.clamp(self.spatial_inhibition(correlated_spatiotemporal_output), min=0)
+
+        return self.output
+
+

xttmp/core/math_operator.py

@@ -0,0 +1,307 @@
+from collections import deque
+from typing import Iterable
+
+import torch
+import torch.nn.functional as F
+
+from .base_core import BaseCore
+from ..util.create_kernel import create_2d_gaussian_kernel, create_gamma_kernel, create_spatial_inhibition_kernel
+
+
+def compute_temporal_conv_inplace(buffer_refs: Iterable[torch.Tensor], 
+                                  time_kernel_tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Efficiently computes a 1D temporal convolution over a sequence of spatial feature maps
+    using in-place accumulation and automatic sequence truncation.
+
+    This function is designed for streaming video or continuous time-series processing 
+    where historical frames are stored in a FIFO queue (like collections.deque). It maps 
+    a 1D temporal kernel across the batch and spatial dimensions of the buffered frames.
+
+    Args:
+        buffer_refs (Iterable[torch.Tensor]): An iterable (e.g., list or deque) containing 
+            historical feature map tensors. 
+            - Expected shape of each tensor: [B, C, H, W]
+            - Temporal ordering: The rightmost (last) element is assumed to be the 
+              newest/most recent frame.
+        time_kernel_tensor (torch.Tensor): A 1D tensor representing the temporal convolution 
+            weights. 
+            - Expected shape: [K], where K is the kernel size.
+            - Weight ordering: The leftmost (first) element corresponds to the newest frame.
+
+    Returns:
+        torch.Tensor: The result of the temporal convolution, with shape [B, C, H, W]. 
+        Returns None if `buffer_refs` is empty.
+
+    Notes:
+        - Memory Efficiency: Uses a clone for the initial base tensor, followed by in-place 
+          additions (`add_`) for subsequent historical frames to minimize memory allocation.
+        - Automatic Truncation: The `zip` function automatically stops at the shortest 
+          iterable. If the buffer has fewer frames than the kernel size (e.g., during the 
+          initial "warm-up" phase of a stream), it safely computes a partial convolution 
+          without out-of-bounds errors or requiring explicit padding.
+    """
+    temporal_conv_out = None
+    
+    # reversed(buffer_refs) iterates from the newest frame to the oldest frame.
+    # zip automatically aligns the newest frame with the first weight and truncates safely.
+    for t_tensor, weight in zip(reversed(buffer_refs), time_kernel_tensor):
+        
+        weight_val = weight.item()
+        
+        if temporal_conv_out is None:
+            # Initialize the base tensor using the newest frame
+            temporal_conv_out = t_tensor.clone().mul_(weight_val)
+        else:
+            # In-place accumulation of historical frames onto the base tensor
+            temporal_conv_out.add_(t_tensor, alpha=weight_val)
+            
+    return temporal_conv_out
+
+
+class GaussianBlur(BaseCore):
+    """
+    Gaussian blur filter: Pure PyTorch implementation.
+    """
+
+    def __init__(self, kernel_size=3, sigma=1.0):
+        """
+        Constructor.
+        Initializes the GaussianBlur module.
+
+        Parameters:
+        - kernel_size: Size of the filter kernel (int). Should be an odd number.
+        - sigma: Standard deviation of the Gaussian distribution (float).
+        """
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.sigma = sigma
+        self.register_buffer('blur_kernel', torch.empty(0))
+
+        self.setup()
+
+    def setup(self):
+        _kernel = create_2d_gaussian_kernel(self.kernel_size, self.sigma)
+        self.blur_kernel.data = _kernel.view(1, 1, self.kernel_size, self.kernel_size)
+
+    def forward(self, x):
+        """
+        Processing method.
+        Applies the Gaussian filter to the input tensor.
+
+        Parameters:
+        - x: Input tensor of shape (B, C, H, W)
+
+        Returns:
+        - opt: Output after applying the Gaussian filter.
+        """
+
+        C = x.shape[1]
+
+        # 动态将单通道高斯核扩展至与输入特征图通道数一致, expand 不占用额外显存
+        weight = self.blur_kernel.expand(C, 1, self.kernel_size, self.kernel_size)
+
+        # 使用深度可分离卷积（groups=C），每个通道独立进行高斯模糊
+        return F.conv2d(x, weight, padding='same', groups=C)
+    
+
+class GammaDelay(BaseCore):
+    """
+    GammaDelay Class
+    
+    Implements a gamma filter used in the lamina layer of the ESTMD neural network
+    using pure PyTorch and collections.deque for efficient temporal sliding windows.
+    """
+    def __init__(self, order=1, tau=1.0, kernel_len=None):
+        """
+        Constructor method.
+        
+        Parameters:
+            order (int): Order of the gamma filter (n). Default is 1.
+            tau (float): Time constant of the filter (\tau).
+            kernel_len (int): Length of the filter kernel (T). 
+        """
+        super().__init__()
+        self.order = max(1, int(order))
+        self.tau = tau
+        # 如果未指定长度，默认使用 3 * tau (覆盖大部分有效权重)
+        self.kernel_len = int(3 * tau) if kernel_len is None else kernel_len
+
+        self.setup()
+
+    def setup(self):
+        # 1. 预计算 Gamma 滤波器的时域权重
+        kernel = create_gamma_kernel(self.order, self.tau, self.kernel_len)
+        # 注册为 buffer，随模型自动转移设备 (如 .cuda())
+        self.register_buffer('gamma_kernel', kernel)
+
+        # 2. 初始化双端队列作为时序状态缓存区
+        self.buffer = deque(maxlen=self.kernel_len)
+
+    def reset_buffer(self):
+        """
+        Resets the internal buffer by clearing all stored frames.
+        """
+        self.buffer.clear()
+
+    def forward(self, x, in_loop=False):
+        """
+        Processing method.
+        Applies the gamma filter to the input tensor.
+        
+        Parameters:
+        - x: Input tensor of shape (B, C, H, W)
+        - in_loop (bool): If True, replaces the last frame instead of appending. 
+                          (Equivalent to original isInLoop/cover logic)
+        """
+
+        if in_loop and len(self.buffer) > 0:
+            # 替换队尾元素 (最新帧)，保持缓存长度不变
+            self.buffer[-1] = x
+        else:
+            self.buffer.append(x)
+
+        return compute_temporal_conv_inplace(self.buffer, self.gamma_kernel)
+
+
+class GammaBandPassFilter(BaseCore):
+    """
+    GammaBandPassFilter: Temporal Band-pass filter for ESTMD.
+    
+    Optimized pure PyTorch implementation. Uses a single deque buffer and 
+    mathematically fuses the two Gamma filters into a single convolution kernel 
+    to halve memory usage and computation time.
+    """
+
+    def __init__(self, 
+                 order1=2, tau1=3.0, 
+                 order2=6, tau2=9.0, 
+                 kernel_len=None):
+        """
+        Constructor method.
+        
+        Parameters:
+        - order1, tau1: Parameters for the excitatory (positive) Gamma filter.
+        - order2, tau2: Parameters for the inhibitory (negative) Gamma filter.
+        - kernel_len: Temporal length of the filter. If None, auto-calculated.
+        """
+        super().__init__()
+
+        self.order1 = max(1, int(order1))
+        self.tau1 = tau1
+        self.order2 = max(1, int(order2))
+        self.tau2 = tau2
+        
+        # 自动计算所需的历史帧缓存最大长度
+        self.kernel_len = kernel_len if kernel_len is not None else max(int(3 * tau1), int(3 * tau2))
+
+        self.in_loop = False  # 默认不覆盖历史帧，直接追加
+
+        self.setup()
+
+    def setup(self):
+        # 1. 预计算两个 Gamma 滤波器的权重，并补齐到相同的长度 self.T
+        k1 = create_gamma_kernel(self.order1, self.tau1, self.kernel_len)
+        k2 = create_gamma_kernel(self.order2, self.tau2, self.kernel_len)
+
+        # 2. 算子融合 (Operator Fusion)：W_bandpass = W1 - W2
+        # 直接将差值注册为模型的 buffer，前向传播只需计算一次
+        bandpass_kernel = k1 - k2
+        self.register_buffer('bandpass_kernel', bandpass_kernel)
+
+        # 3. 初始化单一的高效时序状态缓存区
+        self.buffer = deque(maxlen=self.kernel_len)
+
+    def reset_buffer(self):
+        """
+        Resets the internal buffer by clearing all stored frames.
+        """
+        self.buffer.clear()
+
+    def forward(self, x):
+        """
+        Processing method.
+        
+        Parameters:
+        - x: Input tensor of shape (B, C, H, W) or (C, H, W) or (H, W)
+        
+        Returns:
+        - opt_tensor: Processed band-pass output tensor
+        """
+
+        # 1. 记录最新一帧
+        if self.in_loop and len(self.buffer) > 0:
+            # 替换队尾元素 (最新帧)，保持缓存长度不变
+            self.buffer[-1] = x
+        else:
+            self.buffer.append(x)
+
+        return compute_temporal_conv_inplace(self.buffer, self.bandpass_kernel) 
+
+
+class SpatialInhibition(BaseCore):
+    """
+    Gamma_Filter Gamma filter in lamina layer
+    Pure PyTorch implementation for Surround Inhibition.
+    """
+
+    def __init__(self, 
+                 kernel_size=15, 
+                 sigma1=1.5, 
+                 sigma2=3.0, 
+                 e=1.0, 
+                 rho=0.0, 
+                 A=1.0, 
+                 B=3.0):
+        """
+        Constructor
+        Initializes the SurroundInhibition module.
+        
+        Parameters:
+        - kernel_size: Size of the filter kernel
+        - sigma1: Standard deviation for the first Gaussian (Center)
+        - sigma1: Standard deviation for the second Gaussian (Surround)
+        - e: Exponent for the weighting of the second Gaussian
+        - rho: Radius for circular integration / Center offset
+        - A: Amplitude of the positive center
+        - B: Amplitude of the negative surround
+        """
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.sigma1 = sigma1
+        self.sigma2 = sigma2
+        self.e = e
+        self.rho = rho
+        self.A = A
+        self.B = B
+
+        self.register_buffer('kernel', torch.empty(0))
+
+        self.setup()
+
+    def setup(self):
+        _spatial_inhibiiton_kernel = create_spatial_inhibition_kernel(self.kernel_size, 
+                                                                    self.sigma1,
+                                                                    self.sigma2,
+                                                                    self.e,
+                                                                    self.rho,
+                                                                    self.A,
+                                                                    self.B)
+        self.kernel.data = _spatial_inhibiiton_kernel.view(1, 1, self.kernel_size, self.kernel_size)
+
+    def forward(self, x):
+        """
+        Processing method
+        Applies the surround inhibition filter to the input tensor.
+        
+        Parameters:
+        - x: Input tensor of shape (B, C, H, W)
+        """
+            
+        C = x.shape[1]
+
+        # .expand 不会真的在内存中复制数据，而是通过 stride 机制虚拟映射，极大地节省显存和耗时
+        weight = self.kernel.expand(C, 1, self.kernel_size, self.kernel_size)
+
+        # groups=C 表示进行深度可分离卷积（Depthwise Convolution），每个通道独立滤波        
+        return F.relu(F.conv2d(x, weight, padding='same', groups=C))