常见数据的维度与shape

 
图像
有高与宽，其数字存储的shape通常为[高，宽]，
这个shape在CV中叫特征图，就是特征形成的图形/shape 
这个维度只是表示有多少个像素点，这些像素点形成了什么样的图形，
然而每个像素点还有三色，表示着这个像素点的特征，这个维度在CV中就叫特征，
特征组成事物的元素，比如
图像由什么组成？答，像素，那像素就是特征
句子由什么组成？答，单词，那单词就是特征
在torch构架中，特征维度的个数，也叫通道数，channel / C 
多张图像输入模型的shape为，[B,C,H,W]

文本 
一个又一个的句子，句子由单词组成，输入torch模型的shape通常为[B,C,L]
B是批次，C是单词的维度，L是一个句子中单词的个数 

 
在深度学习中，特征图（Feature Map）的概念通常与卷积神经网络（CNN）相关，
它指的是卷积层、池化层等处理后的输出。
在这个上下文中，特征图既不是指特征向量的维度，
也不是简单地指某个形状的二维数组（比如[H,W]），而是指经过特定层处理后的多维数据。

以RGB三色图像为例，在PyTorch框架中，一个图像张量的形状通常是 [B, C, H, W]，其中：

B 是批次大小（Batch Size），即一次处理的图像数量。
C 是通道数（Channel），对于RGB图像来说，C=3，分别对应红色、绿色和蓝色通道。
H 是图像的高度（Height）。
W 是图像的宽度（Width）。

当这样的图像数据通过卷积层或池化层等处理时，
每个通道上的数据会被独立处理（或有时跨通道组合处理，如深度可分离卷积），
并生成新的特征图。
这些新的特征图通常具有不同的通道数（由卷积核的数量决定）和
可能不同的空间维度（高度和宽度，取决于步长、填充和池化等因素）。

因此，在卷积神经网络中，特征图通常指的是经过某层处理后输出的多维数据，
其形状一般为 [B, C', H', W']，
其中 C' 是新的通道数，H' 和 W' 是新的高度和宽度。
    

 
具体到你的问题，以 [B, 3, H, W] 的图像为例，
特征图既不是指 3（这是输入图像的通道数），也不是指 [H, W]（这是输入图像的空间维度）。
特征图是指经过某个卷积层或池化层等处理后得到的输出张量，
其形状可能是 [B, C'', H'', W'']，其中 C''、H'' 和 W'' 取决于该层的参数和输入数据的形状。

例如，如果有一个卷积层具有 16 个 3x3 的卷积核，
步长为 1，填充为 1，那么对于输入形状为 [B, 3, H, W] 的图像，
该卷积层的输出特征图形状将是 [B, 16, H, W]
（假设高度和宽度没有因为步长或填充而改变，这在实际中可能不成立，因为边界效应可能会导致尺寸变化）。
    
    

欺诈交易

 
一个交易是否为欺诈是基于历史交易的
将列的个数作为C 
取最近n条连续的交易记录，作为一个周期的数据 

最近一条记录为欺诈，则确定整个周期的标签为欺诈；否则为正常

这只是个人的一个猜测.... 实际上交易数据常用的转化方法为下面的方法
- L对应列，C=1 

原论文复现

 
import torch
from torch import nn
from torch.nn import functional as F

class TextCNN1(nn.Module):
    """1维卷积实现文本分类
        TextCNN论文实现
    """
    def __init__(self,num_embeddings, embedding_dim,padding_idx,seq_len):
        super().__init__()
        
        self.embed = nn.Embedding(num_embeddings=num_embeddings,
                                    embedding_dim=embedding_dim,
                                    padding_idx=padding_idx)
        
        # [N, C, seq_len] -- [N, C, seq_len-1],[N, C, seq_len-kernel_size+1]
        self.gram_2 = nn.Sequential(
            nn.Conv1d(in_channels=embedding_dim, out_channels=2, kernel_size=2),
            # 因为kernel为2，又没有补，所以卷积后序列长度减1
            nn.MaxPool1d(kernel_size=seq_len-1)  # [N, C, 1]
        )

        # [N, C, seq_len, 1] -- [N, C, seq_len-2, 1]
        self.gram_3 = nn.Sequential(
            nn.Conv1d(in_channels=embedding_dim, out_channels=2, kernel_size=3),
            # 因为kernel为3，又没有补，所以卷积后序列长度减2
            nn.MaxPool1d(kernel_size=seq_len-2) # [N, C, 1]
        )
        
        # [N, C, seq_len, 1] -- [N, C, seq_len-3, 1]
        self.gram_4 = nn.Sequential(
            nn.Conv1d(in_channels=embedding_dim, out_channels=2, kernel_size=4),
            nn.MaxPool1d(kernel_size=seq_len-3) # [N, C, 1]
        )

        self.dropout1 = nn.Dropout(p=0.2)
        self.fc1 = nn.Linear(in_features=2*3, out_features=2)
        
    
    def forward(self,X):
        # [B,seq_len,embedding_dim]
        x = self.embed(X)

        # [B, seq_len, embedding_dim] -- [B, embedding_dim, seq_len] 
        x = torch.permute(input=x, dims=(0, 2, 1))
        print(x.shape)  # torch.Size([128, 256, 87])

        x1 = self.gram_2(x)
        print(f"x1.shape={x1.shape}")  #torch.Size([128, ２, 1])
        x2 = self.gram_3(x)
        x3 = self.gram_4(x)

        x = torch.concat(tensors=(x1,x2,x3),dim=1)
        print(x.shape)  # torch.Size([128, ６, 1])
        x = torch.squeeze(x)

        x = self.dropout1(x)
        x = self.fc1(x)

        return x 

原论文优化

 
import torch
from torch import nn
from torch.nn import functional as F
class TextCNN3(nn.Module):
    """
        TextCNN优化，
    """
    def __init__(self,num_embeddings, embedding_dim,padding_idx,seq_len):
        super().__init__()
        
        self.embed = nn.Embedding(num_embeddings=num_embeddings,
                                    embedding_dim=embedding_dim,
                                    padding_idx=padding_idx)
        
        # [N, C, seq_len] -- [N, C, seq_len-1],[N, C, seq_len-kernel_size+1]
        self.gram_2 = nn.Sequential(
            nn.Conv1d(in_channels=embedding_dim, out_channels=256, kernel_size=2),
            nn.BatchNorm1d(num_features=256),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=seq_len-1)  # [N, C, 1]
        )

        # [N, C, seq_len, 1] -- [N, C, seq_len-2, 1]
        self.gram_3 = nn.Sequential(
            nn.Conv1d(in_channels=embedding_dim, out_channels=256, kernel_size=3),
            nn.BatchNorm1d(num_features=256),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=seq_len-2) # [N, C, 1]
        )
        # [N, C, seq_len, 1] -- [N, C, seq_len-3, 1]
        self.gram_4 = nn.Sequential(
            nn.Conv1d(in_channels=embedding_dim, out_channels=256, kernel_size=4),
            nn.BatchNorm1d(num_features=256),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=seq_len-3) # [N, C, 1]
        )

        self.dropout1 = nn.Dropout(p=0.2)
        self.fc1 = nn.Linear(in_features=256*3, out_features=2)
        

    def forward(self,X):
        # [B,seq_len,embedding_dim]
        x = self.embed(X)
        # [B, seq_len, embedding_dim] -- [B, embedding_dim, seq_len] 
        x = torch.permute(input=x, dims=(0, 2, 1))
        # print(x.shape)  # torch.Size([128, 256, 87])

        x1 = self.gram_2(x)
        # print(f"x1.shape={x1.shape}")  #torch.Size([128, 256, 1])
        x2 = self.gram_3(x)
        x3 = self.gram_4(x)

        x = torch.concat(tensors=(x1,x2,x3),dim=1)
        # print(x.shape)  # torch.Size([128, 768, 1])
        x = torch.squeeze(x)

        x = self.dropout1(x)
        x = self.fc1(x)

        return x