title: PyTorch: Add validation error in training
body: <p>I am using PyTorch to train a cnn model. Here is my Network architecture:</p>
  
  <pre><code>import torch
  from torch.autograd import Variable
  import torch.nn as nn
  import torch.nn.functional as F
  import torch.nn.init as I
  
  
      class Net(nn.Module):
  
          def __init__(self):
              super(Net, self).__init__()
  
              self.conv1 = nn.Conv2d(1, 32, 5)
              self.pool = nn.MaxPool2d(2,2)
              self.conv1_bn = nn.BatchNorm2d(32)
              self.conv2 = nn.Conv2d(32, 64, 5)
              self.conv2_drop = nn.Dropout2d()
              self.conv2_bn = nn.BatchNorm2d(64)
              self.fc1 = torch.nn.Linear(53*53*64, 256)
              self.fc2 = nn.Linear(256, 136)
  
  
          def forward(self, x):
  
              x = F.relu(self.conv1_bn(self.pool(self.conv1(x))))
              x = F.relu(self.conv2_bn(self.pool(self.conv2_drop(self.conv2(x)))))
              x = x.view(-1, 53*53*64)
              x = F.relu(self.fc1(x))
              x = F.dropout(x, training=self.training)
              x = self.fc2(x)
  
              return x
  </code></pre>
  
  <p>Then I train the model like below:</p>
  
  <pre><code># prepare the net for training
      net.train()
  
      for epoch in range(n_epochs):  # loop over the dataset multiple times
  
          running_loss = 0.0
  
          # train on batches of data, assumes you already have train_loader
          for batch_i, data in enumerate(train_loader):
              # get the input images and their corresponding labels
              images = data['image']
              key_pts = data['keypoints']
  
              # flatten pts
              key_pts = key_pts.view(key_pts.size(0), -1)
  
              # wrap them in a torch Variable
              images, key_pts = Variable(images), Variable(key_pts)
  
              # convert variables to floats for regression loss
              key_pts = key_pts.type(torch.FloatTensor)
              images = images.type(torch.FloatTensor)
  
              # forward pass to get outputs
              output_pts = net(images)
  
              # calculate the loss between predicted and target keypoints
              loss = criterion(output_pts, key_pts)
  
              # zero the parameter (weight) gradients
              optimizer.zero_grad()
  
              # backward pass to calculate the weight gradients
              loss.backward()
  
              # update the weights
              optimizer.step()
  
              # print loss statistics
              running_loss += loss.data[0]
  </code></pre>
  
  <p>I am wondering if it is possible to add the validation error in the training? I mean something like this (validation split) in <code>Keras</code>:</p>
  
  <pre><code>myModel.fit(trainX, trainY, epochs=50, batch_size=1, verbose=2, validation_split = 0.1)
  </code></pre>