After removing the load method (as the checkpoint was undefined), the model seems to train, since I get a False output:
class NeuralNetwork(torch.nn.Module):

    def crutch(self):
        after = []
        for param in self.net.parameters():
            after.append(param.clone().cpu())
        for i in range(len(self.before)):
            print(torch.equal(self.before[i], after[i]))
        print(" ")
        self.before = after

    def save(self):
        torch.save(self.net, "data/" + self.name)

    def init_weights(self, m):
        if type(m) == torch.nn.Linear:
            m.weight.data.uniform_(-0.5, 0.5)
            m.bias.data.fill_(0.0)

    def overallWeight(self):
        result = 0.0
        def passLayer(m):
            if type(m) == torch.nn.Linear:
                nonlocal result
                result += torch.sum(m.weight.data).item()
        self.net.apply(passLayer)
        return result



    def __init__(self, dimensions, name):
        super(NeuralNetwork, self).__init__()
        self.name = name
        for part in dimensions:
            self.name += "_"
            self.name += str(part)

        
        self.dimensions = dimensions

        layers = OrderedDict([])
        for i in range(len(dimensions)):
            if i == 0:
                continue
            layers.update({str(i): torch.nn.Linear(dimensions[i-1], dimensions[i], True).cuda()})
            layers.update({str(i)+'_func': torch.nn.Sigmoid()})
        self.net = torch.nn.Sequential(layers)
        print(self.net)
        self.net.apply(self.init_weights)
        self.optimizer = torch.optim.SGD(self.net.parameters(), lr=0.9, momentum=0.9)
        self.optimizerCriterion = torch.nn.MSELoss(reduction='none')
        self.before = []
        for param in self.net.parameters():
            self.before.append(param.clone().cpu())
 
    def forward(self, X):
        return self.net(X)
    
    def backward(self, y, o):
        self.optimizer.zero_grad()
        loss = self.optimizerCriterion(o, y)
        loss.backward()
        self.optimizer.step()
        
    def train(self, X, y):
        o = self.forward(X.cuda())
        self.backward(y.cuda(), o)
        return o


model = NeuralNetwork([1, 1, 1], '')
model.train(torch.randn(1, 1).cuda(), torch.randn(1, 1).cuda())
model.crutch()