My neural network does not appear to learn DQN - deep-learning

Question

Good morning,
I'm trying to implement a DQN with Bellman's Equations, however I don't know why but every prediction seems random. Just below here is my code.
The neural network :
class simpleAgent(nn.Module) :
def __init__(self,taille_entree, taille_sortie):
super(simpleAgent, self).__init__()
self.fc1 = nn.Linear(taille_entree, 32)
self.fc2 = nn.Linear(32, taille_sortie)
self.beta = 0.999
self.epsilon = 0.99
def forward(self, x):
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
def selectAction(self, pos):
if random.uniform(0,1) < self.epsilon:
self.epsilon = self.epsilon * self.beta
action = random.randint(0,1)
return action
else:
return torch.argmax(self(pos)).item()
The training code :
def optimize_model():
global model, targetNetwork
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)
if len(buffer_circ) < BATCH_SIZE:
return
transitions = buffer_circ.sample(BATCH_SIZE)
batch = Transition(*zip(*transitions))
state = torch.stack(batch.state)
action = torch.stack(batch.action)
reward = torch.stack(batch.reward)
continu = torch.stack(batch.terminated)
next_state = torch.stack(batch.next_state)
q_value = torch.flatten(model(state).gather(1, action))
q_value_next = torch.max(targetNetwork(next_state), 1).values
cible = reward + torch.mul(discount_factor,torch.mul(continu, q_value_next))
loss = criterion(q_value, cible)
optimizer.zero_grad()
loss.backward(retain_graph=True)
optimizer.step()
def train():
global model, targetNetwork
env = gym.make('CartPole-v1', render_mode="rgb_array", disable_env_checker=True)
env.action_space.seed(42)
tab = []
for i in range(5000):
observation, info = env.reset()
rewards=[]
cumule = 0
update_target = 1
terminated = False
truncated = False
while not terminated :
old_observation = observation
action = model.selectAction(torch.from_numpy(observation))
observation, reward, terminated, truncated, info= env.step(action)
cumule += reward
reward = torch.tensor(reward)
terminated = terminated or truncated
state = torch.from_numpy(old_observation)
next_state = torch.from_numpy(observation)
if terminated:
print(i,cumule)
tab.append(cumule)
rewards.append(cumule)
break
buffer_circ.push(state, torch.tensor([action]), next_state, reward, torch.tensor(not terminated))
optimize_model()
if update_target % TARGET_UPDATE == 0:
targetNetwork.load_state_dict(model.state_dict())
update_target = 0
update_target += 1
print('Complete')
env.render()
env.close()
I'm using a target network that is updated every TARGET_UPDATE, and model is the neural network that I train and Target network a copy of it. Yet, I have the loss decreasing and I also implemented the greedy-exploration with selectAction. If you could tell what's wrong in my code, it would be nice.
Thank you in advance