学习一维卷积的代码

 沿着序列长度进行一维卷积

# -*- coding: utf-8 -*-
import torch
import torch.nn as nn

# 定义输入数据和标签
a = torch.tensor([[2, 3, 6, 4],
                  [1, 5, 9, 6]])

label = torch.tensor([[0],
                      [1]])

# CNN-BiLSTM模型定义
class CNNBiLSTMClassifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, num_layers, cnn_output_channels, cnn_kernel_size, cnn_stride):
        super(CNNBiLSTMClassifier, self).__init__()
        self.hidden_dim = hidden_dim
        self.num_layers = num_layers

        self.embedding = nn.Embedding(input_dim, hidden_dim)
        self.cnn = nn.Conv1d(in_channels=hidden_dim, out_channels=cnn_output_channels, kernel_size=cnn_kernel_size, stride=cnn_stride)
        self.bilstm = nn.LSTM(cnn_output_channels, hidden_dim, num_layers, batch_first=True, bidirectional=True)
        self.fc = nn.Linear(hidden_dim * 2, output_dim)  # *2 for bidirectional

    def forward(self, x):
        h0 = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_dim).to(x.device)  # *2 for bidirectional
        c0 = torch.zeros(self.num_layers * 2, x.size(0), self.hidden_dim).to(x.device)  # *2 for bidirectional

        x = self.embedding(x)

        x = x.permute(0, 2, 1)  # 调整张量维度以适应CNN输入 (batch_size, embedding_dim, sequence_length)
        print('embedding')
        print(x)

        x = self.cnn(x)
        print('weight')

        print(self.cnn.weight)
        print('cnn')

        print(x)
        x = x.permute(0, 2, 1)  # 调整张量维度以适应LSTM输入 (batch_size, sequence_length, cnn_output_channels)
        out, _ = self.bilstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])
        return out

# 参数设置
input_dim = 10   #(0-9)
hidden_dim = 5
output_dim = 2  # 假设是二分类
num_layers = 2
cnn_output_channels = 3
cnn_kernel_size = 3
cnn_stride = 1

# 模型实例化
model1 = CNNBiLSTMClassifier(input_dim, hidden_dim, output_dim, num_layers, cnn_output_channels, cnn_kernel_size, cnn_stride)
model1.device = torch.device('cpu')
model1.to(model1.device)

# 将输入数据转换为适合模型的形式
a = a.to(model1.device)
label = label.squeeze().to(model1.device)  # 去除标签的额外维度

# 前向传播
outputs = model1(a)

# 打印输出结果
print(f'Outputs: {outputs}')
print(f'Predicted labels: {torch.argmax(outputs, dim=1)}')
print(f'True labels: {label}')

 

 

 

 

卷积层的权重张量的形状取决于卷积层的参数：输入通道数、输出通道数和核的大小。在你的模型中，self.cnn 被定义为：

self.cnn = nn.Conv1d(in_channels=hidden_dim, out_channels=cnn_output_channels, kernel_size=cnn_kernel_size, stride=cnn_stride)

在这个例子中：

• in_channels 是输入通道数，这里是 hidden_dim。
• out_channels 是输出通道数，这里是 cnn_output_channels。
• kernel_size 是卷积核的大小，这里是 cnn_kernel_size。

假设 hidden_dim 是 5，cnn_output_channels 是 3，cnn_kernel_size 是 3，那么卷积层的权重张量的形状应该是 [out_channels, in_channels, kernel_size]，即 [3, 5, 3]。

你的权重张量形状是 [3, 5, 3]，这是正确的，因为：

• 3 是输出通道数，即 cnn_output_channels。
• 5 是输入通道数，即 hidden_dim。
• 3 是核的大小，即 cnn_kernel_size。