title: Confused about tensor dimensions and batch sizes in pytorch
body: <p>So I'm very new to PyTorch and Neural Networks in general, and I'm having some problems creating a Neural Network that classifies names by gender.<br>
  I based this off of the PyTorch tutorial for RNNs that classify names by nationality, but I decided not to go with a recurrent approach... <em>Stop me right here if this was the wrong idea!</em><br>
  However, whenever I try to run an input through the network it tells me:  </p>
  
  <pre><code>RuntimeError: matrices expected, got 3D, 2D tensors at /py/conda-bld/pytorch_1493681908901/work/torch/lib/TH/generic/THTensorMath.c:1232
  </code></pre>
  
  <p>I know this has something to do with how PyTorch always expects there to be a batch size or something, and I have my tensor set up that way, but you can probably tell by this point that I have no idea what I'm talking about.
  Here's my code:</p>
  
  <pre><code>from future import unicode_literals, print_function, division
  from io import open
  import glob
  import unicodedata
  import string
  import torch
  import torchvision
  import torch.nn as nn
  import torch.optim as optim
  import random
  from torch.autograd import Variable
  import matplotlib.pyplot as plt
  import matplotlib.ticker as ticker
  
  """------GLOBAL VARIABLES------"""
  
  all_letters = string.ascii_letters + " .,;'"
  num_letters = len(all_letters)
  all_names = {}
  genders = ["Female", "Male"]
  
  """-------DATA EXTRACTION------"""
  
  def findFiles(path):
      return glob.glob(path)
  
  def unicodeToAscii(s):
      return ''.join(
          c for c in unicodedata.normalize('NFD', s)
          if unicodedata.category(c) != 'Mn'
          and c in all_letters
      )
  
  # Read a file and split into lines
  def readLines(filename):
      lines = open(filename, encoding='utf-8').read().strip().split('\n')
      return [unicodeToAscii(line) for line in lines]
  
  for file in findFiles("/home/andrew/PyCharm/PycharmProjects/CantStop/data/names/*.txt"):
      gender = file.split("/")[-1].split(".")[0]
      names = readLines(file)
      all_names[gender] = names
  
  """-----DATA INTERPRETATION-----"""
  
  def nameToTensor(name):
      tensor = torch.zeros(len(name), 1, num_letters)
      for index, letter in enumerate(name):
          tensor[index][0][all_letters.find(letter)] = 1
      return tensor
  
  def outputToGender(output):
      gender, gender_index = output.data.topk(1)
      if gender_index[0][0] == 0:
          return "Female"
      return "Male"
  
  """------NETWORK SETUP------"""
  
  class Net(nn.Module):
      def __init__(self, input_size, output_size):
          super(Net, self).__init__()
          #Layer 1
          self.Lin1 = nn.Linear(input_size, int(input_size/2))
          self.ReLu1 = nn.ReLU()
          self.Batch1 = nn.BatchNorm1d(int(input_size/2))
          #Layer 2
          self.Lin2 = nn.Linear(int(input_size/2), output_size)
          self.ReLu2 = nn.ReLU()
          self.Batch2 = nn.BatchNorm1d(output_size)
          self.softMax = nn.LogSoftmax()
  
      def forward(self, input):
          output1 = self.Batch1(self.ReLu1(self.Lin1(input)))
          output2 = self.softMax(self.Batch2(self.ReLu2(self.Lin2(output1))))
          return output2
  
  NN = Net(num_letters, 2)
  
  """------TRAINING------"""
  
  def getRandomTrainingEx():
      gender = genders[random.randint(0, 1)]
      name = all_names[gender][random.randint(0, len(all_names[gender])-1)]
      gender_tensor = Variable(torch.LongTensor([genders.index(gender)]))
      name_tensor = Variable(nameToTensor(name))
      return gender_tensor, name_tensor, gender
  
  def train(input, target):
      loss_func = nn.NLLLoss()
  
      optimizer = optim.SGD(NN.parameters(), lr=0.0001, momentum=0.9)
  
      optimizer.zero_grad()
  
      output = NN(input)
  
      loss = loss_func(output, target)
      loss.backward()
      optimizer.step()
  
      return output, loss
  
  all_losses = []
  current_loss = 0
  
  for i in range(100000):
      gender_tensor, name_tensor, gender = getRandomTrainingEx()
      output, loss = train(name_tensor, gender_tensor)
      current_loss += loss
  
      if i%1000 == 0:
          print("Guess: %s, Correct: %s, Loss: %s" % (outputToGender(output), gender, loss.data[0]))
  
      if i%100 == 0:
          all_losses.append(current_loss/10)
          current_loss = 0
  
  # plt.figure()
  # plt.plot(all_losses)
  # plt.show()
  </code></pre>
  
  <p>Please help a newbie out!</p>