I am using a VAE for non-image data. Pytorch is giving me a hard time Data Types. Any help is extremely appreciated! 
input_size = 16888 
representation_size = 2
batch_size = 16

class VAE(nn.Module):
    def __init__(self):
        super(VAE, self).__init__()
        self.en1 = nn.Linear(input_size, 512)
        self.en_mu = nn.Linear(512, representation_size)
        self.en_std = nn.Linear(512, representation_size)
        self.de1 = nn.Linear(representation_size, 512)
        self.de2 = nn.Linear(512, input_size)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
        
    def encode(self, x):
        """Encode a batch of samples, and return posterior parameters for each point."""
        h1 = self.relu(self.en1(x))
        return self.en_mu(h1), self.en_std(h1)
    
    def decode(self, z):
        """Decode a batch of latent variables"""
        
        h2 = self.relu(self.de1(z))
        return self.sigmoid(self.de2(h2))
    
    def reparam(self, mu, logvar):
        """Reparameterisation trick to sample z values. 
        This is stochastic during training,  and returns the mode during evaluation."""
        
        if self.training:
            std = logvar.mul(0.5).exp_()
            eps = Variable(std.data.new(std.size()).normal_())
            return eps.mul(std).add_(mu)
        else:
            return mu
            
    
    def forward(self, x):
        """Takes a batch of samples, encodes them, and then decodes them again to compare."""
        mu, logvar = self.encode(x.view(-1, input_size))
        z = self.reparam(mu, logvar)
        return self.decode(z), mu, logvar
    
    def loss(self, reconstruction, x, mu, logvar):
        """ELBO assuming entries of x are binary variables, with closed form KLD."""
        
        bce = torch.nn.functional.cross_entropy(reconstruction, x.view(-1, input_size))
        KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
        
        # Normalise by same number of elements as in reconstruction
        KLD /= x.view(-1, input_size).data.shape[0] * input_size

        return bce + KLD

    '''# Reconstruction + KL divergence losses summed over all elements and batch
    def loss(self, recon_x, x, mu, logvar):
        #binary cross-entropy
        BCE = torch.nn.functional.mse_loss(recon_x, x.view(-1, 17470))
        #Kullback-Leibler divergence
        KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())

        return BCE + 0.1*KLD'''


    def get_z(self, x):
        """Encode a batch of data points, x, into their z representations."""
        
        mu, logvar = self.encode(x.view(-1, input_size))
        return self.reparam(mu, logvar)

model = VAE()
optimizer = torch.optim.Adam(model.parameters(), lr=0.005)
X.shape
(1062, 16888)

def train(epoch, batches_per_epoch = 124, log_interval=500):
    model.train()
    
    ind = np.arange(X.shape[0])
    for i in range(batches_per_epoch):
        data = torch.from_numpy(X[np.random.choice(ind, size=batch_size)]).float()
        print(data.shape)
        data = Variable(data, requires_grad=False)
        optimizer.zero_grad()
        recon_batch, mu, logvar = model(data)
        loss = model.loss(recon_batch, data, mu, logvar)
        loss.backward()
        #train_loss += loss.data[0]
        optimizer.step()
        #if (i % log_interval == 0) and (epoch % 5 ==0):
        #Print progress
        print('Train Epoch: {} [{}/{}]\tLoss: {:.6f}'.format(
            epoch, i * batch_size, batch_size*batches_per_epoch,
            loss.data / len(data)))

    print('====> Epoch: {} done!'.format(
          epoch))


def test(epoch, batches_per_epoch=1):
    model.eval()

    ind = np.arange(X.shape[0])
    for i in range(batches_per_epoch):
        
        data = torch.from_numpy(X[np.random.choice(ind, size=batch_size)]).float()
        data = Variable(data, requires_grad=False)
        recon_batch, mu, logvar = model(data)
        if i == 0:
            n = min(data.size(0), 2)
            print(data.view(batch_size, 2,2)[:n])
            print(recon_batch.view(batch_size, 2,2)[:n])

print_examples = False #Change to true if you want to see some examples at each step!
for epoch in range(1, 50):
    train(epoch)
    if print_examples:
        test(epoch)

ERROR:
RuntimeError                              Traceback (most recent call last)
<ipython-input-53-475f5b63fa8b> in <module>()
      1 print_examples = False #Change to true if you want to see some examples at each step!
      2 for epoch in range(1, 50):
----> 3     train(epoch)
      4     if print_examples:
      5         test(epoch)

<ipython-input-52-57a6478df61e> in train(epoch, batches_per_epoch, log_interval)
      9         optimizer.zero_grad()
     10         recon_batch, mu, logvar = model(data)
---> 11         loss = model.loss(recon_batch, data, mu, logvar)
     12         loss.backward()
     13         #train_loss += loss.data[0]

<ipython-input-43-3f9327bb329f> in loss(self, reconstruction, x, mu, logvar)
     42         """ELBO assuming entries of x are binary variables, with closed form KLD."""
     43 
---> 44         bce = torch.nn.functional.cross_entropy(reconstruction, x.view(-1, input_size))
     45         KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
     46 

/projects/sysbio/projects/czi/immune/anaconda2/envs/py36/lib/python3.6/site-packages/torch/nn/functional.py in cross_entropy(input, target, weight, size_average, ignore_index, reduce, reduction)
   1968     if size_average is not None or reduce is not None:
   1969         reduction = _Reduction.legacy_get_string(size_average, reduce)
-> 1970     return nll_loss(log_softmax(input, 1), target, weight, None, ignore_index, None, reduction)
   1971 
   1972 

/projects/sysbio/projects/czi/immune/anaconda2/envs/py36/lib/python3.6/site-packages/torch/nn/functional.py in nll_loss(input, target, weight, size_average, ignore_index, reduce, reduction)
   1788                          .format(input.size(0), target.size(0)))
   1789     if dim == 2:
-> 1790         ret = torch._C._nn.nll_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index)
   1791     elif dim == 4:
   1792         ret = torch._C._nn.nll_loss2d(input, target, weight, _Reduction.get_enum(reduction), ignore_index)

RuntimeError: Expected object of scalar type Long but got scalar type Float for argument #2 'target'