Pytorch Conv1D produces more channels than expected

I have the following neural network:

class Discriminator(nn.Module):
    def __init__(self, input_size, output_size):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Conv1d(1, 3000, 1),
            nn.LeakyReLU(0.2),
            nn.Conv1d(3000, 1, 1),
            nn.Sigmoid()
        )
    def forward(self, x):
        return self.main(x.float())

Discriminator = Discriminator()

Then I train this discriminator as follows:

        for d_index in range(d_steps):
            Discriminator.zero_grad()
            prediction = Discriminator(d_real_data).view(-1) 

The shape of real_data is [60, 1, 3000] where

• batch size: 60
• number of channels: 1
• sequence length: 3000

This input follows the documentation for Pytorch Conv1D. What I'm expecting is prediction to be [60, 1, 1] and so flattening it with .view(-1) shapes it into a 1D array with 60 values. However, what I actually end up getting for the shape of prediction is [60, 1, 3000] and flattening it gives me a 1D array with 180000 values. Why is Conv1D with Sigmoid returning an output with the same shape as my input?

The input for Conv1d is in_channels, out_channels, kernelsize.
in_channels is the depth of your data. In a colour picture with RBG it would be 3. out_channels is the depth of the output and not the length of the sequence. You are projecting your one input channel into 3000 output channels. You should also increase the kernel size

The first Conv1D will have an Ouput of (60,3000,3000) as it has the kernel size one, so it doesn't change the length.
The secound Conv1D will have an Output of (60,1,3000) as again, the kernel size is one, so it won't change the sequence length.
Yet each time you specifiy the amout of channels to be 3000 / 1.
The sigmoid function is an element wise function, so it doen't change the size at all.
As Kilian said, you need to increase the kernel size (and/or stride) to change the size of the third dimension.

Your usage of the convolutional layers in your discriminator network seems incorrect. you're using nn.Conv1d with kernel size 1 which results in each output element being computed independently, without taking into account any neighborhood information. Try updating your code into:

class Discriminator(nn.Module):
    def __init__(self, input_size, output_size):
        super(Discriminator, self).__init__()
        self.main = nn.Sequential(
            nn.Conv1d(1, 64, kernel_size=3, stride=3),
            nn.LeakyReLU(0.2),
            nn.Conv1d(64, 1, kernel_size=3, stride=3),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.main(x.float())

discriminator = Discriminator(input_size=3000, output_size=1)