Update:
# Train the classifier
def train_classifier(model, optimizer, criterion,train_loader, valid_loader, epochs):

    steps = 0
    print_every = 1

    for e in range(epochs):

        model.train()

        running_loss = 0

        for images, labels in iter(train_loader):            
            images, labels = images.cuda(), labels.cuda()
    
            steps += 1
            print("Steps: " + str(steps))

            optimizer.zero_grad()
        
            output = model.forward(images)
            print("Output " + str(output))
            loss = criterion(output, labels)
            print("Loss: " + str(loss))
            loss.backward()
            optimizer.step()

            running_loss += loss.item()
            print("Running loss: " + str(running_loss))

            #model.eval()

            # Turn off gradients for validation, saves memory and computations
            #with torch.no_grad():
            #    validation_loss, accuracy = validation(model, valid_loader, criterion, device)

            #print("Epoch: {}/{}.. ".format(e+1, epochs),
             #     "Training Loss: {:.3f}.. ".format(running_loss/print_every),
              #    "Validation Loss: {:.3f}.. ".format(validation_loss/len(valid_loader)),
               #   "Validation Accuracy: {:.3f}".format(accuracy/len(valid_loader)))

            running_loss = 0
            model.train()

First I removed the if statement to see if the print_every was the problem and it still did not work.
Edit: The problem seems to be with:
            # Turn off gradients for validation, saves memory and computations
            with torch.no_grad():
                validation_loss, accuracy = validation(model, valid_loader, criterion, device)

The validation function is:
def validation(model, valid_loader, criterion, device):
    
    val_loss = 0
    accuracy = 0
    
    for images, labels in iter(valid_loader):

        images, labels = images.to(device), labels.to(device)

        output = model.forward(images)
        val_loss += criterion(output, labels).item()

        probabilities = torch.exp(output)
        
        equality = (labels.data == probabilities.max(dim=1)[1])
        accuracy += equality.type(torch.FloatTensor).mean()
    
    return val_loss, accuracy