Machine learning 稀疏张量没有跨步

使用以下来源的代码：

我试图用稀疏张量训练一个简单的模型。这是一个简单的例子，我的目标是测试使用稀疏张量进行训练是否会增加训练时间

这里，我将训练数据x转换为稀疏张量：

x = to_sparse(torch.tensor([x1,x2,x3,x4]).float())

培训此模型后，我收到错误信息：

~/anaconda3/envs/pytorch/lib/python3.7/site-packages/torch/utils/data/dataset.py in <genexpr>(.0)
     38 
     39     def __getitem__(self, index):
---> 40         return tuple(tensor[index] for tensor in self.tensors)
     41 
     42     def __len__(self):

RuntimeError: sparse tensors do not have strides

~/anaconda3/envs/pytorch/lib/python3.7/site-packages/torch/utils/data/dataset.py in <genexpr>(.0)
     38 
     39     def __getitem__(self, index):
---> 40         return tuple(tensor[index] for tensor in self.tensors)
     41 
     42     def __len__(self):

RuntimeError: sparse tensors do not have strides

%reset -f

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt
import torch.utils.data as data_utils
import torch.nn as nn
import torch.nn.functional as F

num_epochs = 20

x1 = np.array([0,0])
x2 = np.array([0,1])
x3 = np.array([1,0])
x4 = np.array([1,1])

num_epochs = 500

def to_sparse(x):
    """ converts dense tensor x to sparse format """
    x_typename = torch.typename(x).split('.')[-1]
    sparse_tensortype = getattr(torch.sparse, x_typename)

    indices = torch.nonzero(x)
    if len(indices.shape) == 0:  # if all elements are zeros
        return sparse_tensortype(*x.shape)
    indices = indices.t()
    values = x[tuple(indices[i] for i in range(indices.shape[0]))]
    return sparse_tensortype(indices, values, x.size())

x = to_sparse(torch.tensor([x1,x2,x3,x4]).float())

y = torch.tensor([0,1,1,0]).long()

train = data_utils.TensorDataset(x,y)
train_loader = data_utils.DataLoader(train , batch_size=2 , shuffle=True)

device = 'cpu'

input_size = 2
hidden_size = 100 
num_classes = 2

learning_rate = .0001

torch.manual_seed(24)

def weights_init(m):
    m.weight.data.normal_(0.0, 1)

class NeuralNet(nn.Module) : 
    def __init__(self, input_size, hidden_size, num_classes) : 
        super(NeuralNet, self).__init__()
        self.fc1 = nn.Linear(input_size , hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size , num_classes)

    def forward(self, x) : 
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

model = NeuralNet(input_size, hidden_size, num_classes).to(device)
# model.apply(weights_init)

criterionCE = nn.CrossEntropyLoss()
criterionNLL = nn.NLLLoss()

optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

for i in range(0 , 1) :

        total_step = len(train_loader)
        for epoch in range(num_epochs) : 
            for i,(images , labels) in enumerate(train_loader) : 
                images = images.to(device)
                labels = labels.to(device)

                outputs = model(images)
                loss = criterionCE(outputs , labels)

                optimizer.zero_grad()
                loss.backward()
                optimizer.step()

        outputs = model(x)

        print(outputs.data.max(1)[1])