title: Unexpected result of convolution operation
body: <p>Here is code I wrote to perform a single convolution and output the shape.</p>
  
  <p>Using formula from <a href="http://cs231n.github.io/convolutional-networks/" rel="nofollow noreferrer">http://cs231n.github.io/convolutional-networks/</a> to calculate output size : </p>
  
  <blockquote>
    <p>You can convince yourself that the correct formula for calculating how
    many neurons “fit” is given by (W−F+2P)/S+1</p>
  </blockquote>
  
  <p>The formula for computing the output size has been implemented below as </p>
  
  <pre><code>def output_size(w , f , stride , padding) : 
          return (((w - f) + (2 * padding)) / stride) + 1
  </code></pre>
  
  <p>The issue is <code>output_size</code> computes a size of 2690.5 which differs to the result of the convolution which is 1350 : </p>
  
  <pre><code>%reset -f
  
  import torch
  import torch.nn.functional as F
  import numpy as np
  from PIL import Image
  import torch.nn as nn
  import torchvision
  import torchvision.transforms as transforms
  from pylab import plt
  plt.style.use('seaborn')
  %matplotlib inline
  
  width = 60
  height = 30
  kernel_size_param = 5
  stride_param = 2
  padding_param = 2
  
  img = Image.new('RGB', (width, height), color = 'red')
  
  in_channels = 3
  out_channels = 3
  
  class ConvNet(nn.Module):
      def __init__(self):
          super(ConvNet, self).__init__()
          self.layer1 = nn.Sequential(
              nn.Conv2d(in_channels, 
                        out_channels, 
                        kernel_size=kernel_size_param, 
                        stride=stride_param, 
                        padding=padding_param))
  
      def forward(self, x):
          out = self.layer1(x)
  
          return out
  
  # w : input volume size
  # f : receptive field size of the Conv Layer neurons
  # output_size computes spatial size of output volume - spatial dimensions are (width, height)
  def output_size(w , f , stride , padding) : 
      return (((w - f) + (2 * padding)) / stride) + 1
  
  w = width * height * in_channels
  f = kernel_size_param * kernel_size_param
  
  print('output size :' , output_size(w , f , stride_param , padding_param))
  
  model = ConvNet()
  
  criterion = nn.CrossEntropyLoss()
  optimizer = torch.optim.Adam(model.parameters(), lr=.001)
  
  img_a = np.array(img)
  img_pt = torch.tensor(img_a).float()
  result = model(img_pt.view(3, width , height).unsqueeze_(0))
  an = result.view(30 , 15 , out_channels).data.numpy()
  
  # print(result.shape)
  # print(an.shape)
  
  # print(np.amin(an.flatten('F')))
  
  print(30 * 15 * out_channels)
  </code></pre>
  
  <p>Have I implemented output_size correctly ? How to amend this model so the result of <code>Conv2d</code> has same shape as result of <code>output_size</code> ?</p>