如何在keras.models Jupyter Python中使用model.fit()方法进行深度Q学习寻宝游戏

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_dim=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 epsilon_greedy_policy(state, epsilon):
    if np.random.rand() <= epsilon:
        return random.randrange(action_size)
    else:
        q_values = model.predict(state)
        return np.argmax(q_values[0])

def train_model():
    for episode in range(num_episodes):
        state = env.reset()
        state = np.reshape(state, [1, state_size])
        done = False
        time = 0
        
        while not done:
            action = epsilon_greedy_policy(state, epsilon)
            next_state, reward, done, _ = env.step(action)
            next_state = np.reshape(next_state, [1, state_size])
            experience = (state, action, reward, next_state, done)
            replay_buffer.add(experience)
            state = next_state
            time += 1
            
            if time > start_learning_time:
                minibatch = replay_buffer.sample(batch_size)
                states = np.array([experience[0] for experience in minibatch])
                actions = np.array([experience[1] for experience in minibatch])
                rewards = np.array([experience[2] for experience in minibatch])
                next_states = np.array([experience[3] for experience in minibatch])
                dones = np.array([experience[4] for experience in minibatch])
                
                q_values = model.predict(states)
                next_q_values = model.predict(next_states)
                max_next_q_values = np.max(next_q_values, axis=1)
                target_q_values = rewards + gamma * (1 - dones) * max_next_q_values
                
                q_values[np.arange(batch_size), actions] = target_q_values
                model.fit(states, q_values, epochs=1, verbose=0)