如何在Keras DQN中实现梯度上升

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam

model = Sequential()
model.add(Dense(24, input_shape=(state_size,), activation='relu'))
model.add(Dense(24, activation='relu'))
model.add(Dense(action_size, activation='linear'))

model.compile(loss='mse', optimizer=Adam(lr=learning_rate))

class ReplayBuffer():
    def __init__(self, buffer_size):
        self.buffer = []
        self.buffer_size = buffer_size
    
    def add(self, experience):
        if len(self.buffer) + len(experience) >= self.buffer_size:
            self.buffer[0:(len(experience) + len(self.buffer)) - self.buffer_size] = []
        self.buffer.extend(experience)
    
    def sample(self, batch_size):
        return np.reshape(np.array(random.sample(self.buffer, batch_size)), [batch_size, 5])

def train(model, target_model, buffer):
    minibatch = buffer.sample(batch_size)
    states = minibatch[:, 0]
    actions = minibatch[:, 1]
    rewards = minibatch[:, 2]
    next_states = minibatch[:, 3]
    dones = minibatch[:, 4]
    
    targets = model.predict(states)
    next_q_values = target_model.predict(next_states)
    
    for i in range(batch_size):
        targets[i, actions[i]] = rewards[i] + gamma * np.max(next_q_values[i]) * (1 - dones[i])
    
    model.fit(states, targets, epochs=1, verbose=0)

target_model = Sequential()
target_model.add(Dense(24, input_shape=(state_size,), activation='relu'))
target_model.add(Dense(24, activation='relu'))
target_model.add(Dense(action_size, activation='linear'))
target_model.set_weights(model.get_weights())

for episode in range(num_episodes):
    state = env.reset()
    done = False
    while not done:
        action = choose_action(state)
        next_state, reward, done, _ = env.step(action)
        buffer.add((state, action, reward, next_state, done))
        state = next_state
        if len(buffer.buffer) > batch_size:
            train(model, target_model, buffer)
        if episode % update_target_freq == 0:
            target_model.set_weights(model.get_weights())