PyTorch Optimizer Doesn’t update Weights

i'm newbie in PyTorch. Can someone help? I am trying teach Neural Network to play in tetris, but can't understand why weights doesn't cange.

Neural Network:

class CNN(Module):
# define model elements

def __init__(self, n_channels):
    super(CNN, self).__init__()
    self.number_of_actions = 5
    self.gamma = 0.01
    self.final_epsilon = 0.0001
    self.initial_epsilon = 0.1
    self.number_of_iterations = 2000000
    self.replay_memory_size = 10000
    self.minibatch_size = 32
    # input to first hidden layer
    #self.hidden1 = Linear(n_channels, 50)
    self.hidden1 = Conv2d(1, 1, (22, 10))
    kaiming_uniform_(self.hidden1.weight, nonlinearity='relu')
    #self.act1 = ReLU()
    self.pool1 = MaxPool2d(2, 2)
    # second hidden layer
    self.hidden2 = Linear(1, 30)
    kaiming_uniform_(self.hidden2.weight, nonlinearity='relu')
    self.act2 = ReLU()
    # fully connected layer
    self.hidden3 = Linear(30, 10)
    kaiming_uniform_(self.hidden3.weight, nonlinearity='relu')
    self.act3 = ReLU()
    # output layer
    self.hidden4 = Linear(10, 1)
    xavier_uniform_(self.hidden4.weight)
    self.act4 = Softmax(dim=1)

# forward propagate input
def forward(self, X):
    # input to first hidden layer
    X = self.hidden1(X)
    X = self.pool1(X)
    # second hidden layer
    X = self.hidden2(X)
    X = self.act2(X)
    # third hidden layer
    X = self.hidden3(X)
    X = self.act3(X)
    # output layer
    X = self.hidden4(X)
    X = self.act4(X)
    return X

Learning loop:

        reward = torch.tensor([[0.]], requires_grad=True)

        inputs = torch.tensor([[self.BoardMatrix]])
        outputs = model(inputs)
        # compute the model output
        state_action_values = model(inputs)
        replay_memory.append(self.BoardMatrix)
        if len(replay_memory) > model.replay_memory_size:
            replay_memory.pop(0)

        if self.isWaitingAfterLine:
            self.isWaitingAfterLine = False
            self.newPiece()
        else:
            # learning

            if (state_action_values[0][0][0][0] > 0.6):
                self.action("left")
                action_batch = 0.8
            elif (state_action_values[0][0][0][0] > 0.2):
                self.action("right")
                action_batch = 0.6
            elif (state_action_values[0][0][0][0] > -0.2):
                self.action("down")
                action_batch = 0.4
            elif (state_action_values[0][0][0][0] > -0.6):
                self.action("up")
                action_batch = 0.2
            elif (state_action_values[0][0][0][0] > -1):
                self.action("space")
                action_batch = 0
            self.oneLineDown()

        minibatch = random.sample(replay_memory, min(len(replay_memory), model.minibatch_size))
        criterion: MSELoss = nn.MSELoss()
        reward_batch = reward
        y_batch = torch.cat(tuple(reward_batch if minibatch[i][4]
                                  else reward_batch + model.gamma * torch.max(state_action_values[i])
                                  for i in range(len(minibatch))))
        y_batch = y_batch.detach()
        q_value = torch.sum(outputs * action_batch, dim=1)
        optimizer.zero_grad()
        loss = criterion(q_value, y_batch[0])
        # credit assignment
        loss.backward()
        optimizer.step()
        print(model.hidden1.weight)
    else:
        super(Board, self).timerEvent(event)

NN, optimizer initialization:

model = CNN(boardSize)
criterion = CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-6)

I working by this tutorial "https://www.toptal.com/deep-learning/pytorch-reinforcement-learning-tutorial", but try change it for tetris.

P.S. I also find out y_batch never change but i don't know why