종헌's Causal convolution!

[JaeheeRyu]

    def __init__(self, args):
        super(MyModel, self).__init__()
        self.args = args
        self.dr_rate = args.drop_out
        self.device = args.device

        self.hidden_dim = self.args.hidden_dim
        self.n_layers = self.args.n_layers

        # Embedding 
        # interaction은 현재 correct로 구성되어있다. correct(1, 2) + padding(0)
        self.embedding_interaction = nn.Embedding(3, self.hidden_dim)
        self.embedding_test = nn.Embedding(self.args.n_test + 1, self.hidden_dim)
        self.embedding_question = nn.Embedding(self.args.n_questions + 1, self.hidden_dim)
        self.embedding_tag = nn.Embedding(self.args.n_tag + 1, self.hidden_dim)

        # embedding combination projection
        self.comb_proj = nn.Linear((self.hidden_dim)*4, self.hidden_dim)
        
        self.hidden_dim *= 2
        self.conv1 = self.conv2d(1, self.hidden_dim//4, (5,3), stride=(1,1), padding=(2,0))
        self.conv2 = self.conv2d(self.hidden_dim//4, self.hidden_dim//4, (4,1), stride=(2,1), padding=(1,0))
        self.conv3 = self.sepConv2d(self.hidden_dim//4, self.hidden_dim//2, (5,3), stride=(1,1), padding=(2,0))
        self.conv4 = self.conv2d(self.hidden_dim//2, self.hidden_dim//2, (4,1), stride=(2,1), padding=(1,0))
        self.conv5 = self.sepConv2d(self.hidden_dim//2, self.hidden_dim//2, (5,3), stride=(1,1), padding=(2,0))
        self.conv6 = self.conv2d(self.hidden_dim//2, self.hidden_dim//2, (4,1), stride=(2,1), padding=(1,0))
        self.conv7 = self.sepConv2d(self.hidden_dim//2, self.hidden_dim//2, (5,3), stride=(1,1), padding=(2,0))
        self.conv8 = self.conv2d(self.hidden_dim//2, self.hidden_dim//2, (4,1), stride=(2,1), padding=(1,0))
        self.conv9 = self.sepConv2d(self.hidden_dim//2, self.hidden_dim//2, (5,3), stride=(1,1), padding=(2,0))
        self.deconv1 = self.convTranspose2d(self.hidden_dim//2, self.hidden_dim//2, (4,1), stride=(2,1), padding=(1,0))
        self.conv10 = self.sepConv2d(self.hidden_dim, self.hidden_dim//2, (5,3), stride=(1,1), padding=(2,0))
        self.deconv2 = self.convTranspose2d(self.hidden_dim//2, self.hidden_dim//2, (4,1), stride=(2,1), padding=(1,0))
        self.conv11 = self.sepConv2d(self.hidden_dim, self.hidden_dim//2, (5,3), stride=(1,1), padding=(2,0))
        self.deconv3 = self.convTranspose2d(self.hidden_dim//2, self.hidden_dim//2, (4,1), stride=(2,1), padding=(1,0))
        self.conv12 = self.sepConv2d(self.hidden_dim, self.hidden_dim//2, (5,3), stride=(1,1), padding=(2,0))
        self.deconv4 = self.convTranspose2d(self.hidden_dim//2, self.hidden_dim//4, (4,1), stride=(2,1), padding=(1,0))
        self.conv13 = self.sepConv2d(self.hidden_dim//2, self.hidden_dim//4, (5,3), stride=(1,1), padding=(2,0))
        self.conv14 = torch.nn.Conv2d(self.hidden_dim//4, 1, (1,1), stride=1)
        
        self.hidden_dim = self.hidden_dim // 2
        # Fully connected layer
        self.fc = nn.Linear(self.hidden_dim, 1)

        self.activation = nn.Sigmoid()
        
        self.drop_out = nn.Dropout(self.dr_rate)
        
    def forward(self, input):

        test, question, tag, _, _, interaction, _ = input

        batch_size = interaction.size(0)

        # Embedding

        embed_interaction = self.embedding_interaction(interaction)
        embed_test = self.embedding_test(test)
        embed_question = self.embedding_question(question)
        embed_tag = self.embedding_tag(tag)
        
        embed = torch.cat([embed_interaction,
                           embed_test,
                           embed_question,
                           embed_tag,], 2)

        x = self.comb_proj(embed)
        
        x = torch.unsqueeze(torch.transpose(x, 2, 1), dim=1)

        x1 = self.conv1(x)
        x2 = self.conv2(x1)
        x3 = self.conv3(x2)
        x4 = self.conv4(x3)
        x5 = self.conv5(x4)
        x6 = self.conv6(x5)
        x7 = self.conv7(x6)
        x8 = self.conv8(x7)
        x9 = self.conv9(x8)
        x10 = self.deconv1(x9) 
        x10 = torch.cat((x7[:,:,:,2:],x10),dim=1)        
        x11 = self.conv10(x10)
        x12 = self.deconv2(x11)
        x12 = torch.cat((x5[:,:,:,6:],x12),dim=1)
        x13 = self.conv11(x12)
        x14 = self.deconv3(x13)
        x14 = torch.cat((x3[:,:,:,10:],x14),dim=1)
        x15 = self.conv12(x14)
        x16 = self.deconv4(x15)
        x16 = torch.cat((x1[:,:,:,14:],x16),dim=1)        
        x17 = self.conv13(x16)
        x18 = self.conv14(x17)
        
        out = torch.transpose(torch.squeeze(x18, dim=1), 2, 1)
        out = self.fc(out)
        out = self.drop_out(out)
        preds = self.activation(out).view(batch_size, -1)
        
        return preds
    
    def sepConv2d(self, in_channels, out_channels, kernel_size, stride, padding):
        return torch.nn.Sequential(torch.nn.Conv2d(in_channels, in_channels, kernel_size, stride, padding, groups=in_channels, bias=False),
                                   torch.nn.BatchNorm2d(in_channels),
                                   torch.nn.PReLU(),
                                   torch.nn.Conv2d(in_channels, out_channels, kernel_size=(1,1), bias=False),
                                   torch.nn.BatchNorm2d(out_channels),
                                   torch.nn.PReLU())
    
    def conv2d(self, in_channels, out_channels, kernel_size, stride, padding):
        return torch.nn.Sequential(torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=False),
                                   torch.nn.BatchNorm2d(out_channels),
                                   torch.nn.PReLU())

    def convTranspose2d(self, in_channels, out_channels, kernel_size, stride, padding):
        return torch.nn.Sequential(torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding, bias=False),
                                   torch.nn.BatchNorm2d(out_channels),
                                   torch.nn.PReLU())

[JaeheeRyu]

해당 모델에 대한 실험 결과를 여기에 공유해주세요! @PJHgh