DQNアルゴリズムの確認をお願いします (Open AI Gym_CartPoleのコードあり ※Keras使用)

Question

質問内容

Deep Q-Networkのアルゴリズムを用いて、Open AI GymのCartPoleで強化学習を実施しました。以下にコード全文を載せていますので、アルゴリズムが正しいのか確認をお願いします。
また、実はこのコードではうまくPoleを立たせることができません。500試行ほど動かしても10step程度ですぐに倒れてしまいます。
アルゴリズムに問題がなければ、以下の各パラメータ値に問題があると考えられます。

• 学習係数
• epsilonの値
• 隠れ層の数
• ニューロン (ノード) の数
• batch_size

正直各パラメータの値の決め方は勉強不足な面があるため、もう少し調べてみようとも考えています。もし、アドバイスが御座いましたらお教えいただけると幸いです。
以下にソースコードを載せます。コメントについても間違っていたら指摘していただけると幸いです。
よろしくお願いします。

ソースコード全文 (Keras使用)

#必要なライブラリのインポート
import gym
import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import Adam
from collections import deque
from keras import backend as K
import tensorflow as tf


#損失関数の定義（KerasにはHuber関数は入っていないので自分で定義、またδ==1とする）
def huberloss(y_true, y_pred):
    err = y_true - y_pred  #誤差を算出
    cond = K.abs(err) < 1.0  #誤差が±1以内をcondに代入
    L2 = 0.5 * K.square(err)  #二乗誤差を表す（squareは二乗を表す）
    L1 = (K.abs(err) - 0.5)  #huber関数を表す（0.5についてはhuber関数の定義から）
    #tf.where(条件, x, y) 条件に対してTrueならxから、Falseならyから要素の値を抽出
    #今回の場合、誤差が±1以内が条件
    loss = tf.where(cond, L2, L1)  #Kerasはwhere関数を持っていない
    return K.mean(loss)
    
#Q関数として使用するディープニューラルネットワークをクラスとして定義
class QNetwork:
    def __init__(self, learning_rate=0.01, state_size=4, action_size=2, hidden_size=10):
        self.model = Sequential()  #前のノードと次のノード全てが繋がっているモデルを使用するという宣言
        #hidden_sizeはその層のニューロン数、activationは活性化関数（伝達関数（今回はランプ関数を使用））、input_dimは入力層のノードの数
        self.model.add(Dense(hidden_size, activation="relu", input_dim=state_size))
        self.model.add(Dense(hidden_size, activation="relu"))
        self.model.add(Dense(action_size, activation="linear"))
        self.optimizer = Adam(lr=learning_rate)  # 誤差を減らす学習方法（最適化アルゴリズム）はAdam
        self.model.compile(loss=huberloss, optimizer=self.optimizer)  #学習モデルの設定
        
    #重みの学習
    def replay(self, memory, batch_size, gammma, targetQN):
        inputs = np.zeros((batch_size, 4))
        targets = np.zeros((batch_size, 2))
        mini_batch = memory.sample(batch_size)  #取得したデータを任意の数でランダムに抜き出す
        
        for i, (state_b, action_b, reward_b, next_state_b) in enumerate(mini_batch):
            inputs[i] = state_b
            target = reward_b
            #今の状態で予測されるQ値を代入する
            targets[i] = self.model.predict(state_b)  #[i]は行を表す
            #価値計算
            mainQs = self.model.predict(next_state_b)[0]  #pridictでQ値を予測し取得（最後の[0]は要素として抜き出すことを意味する）
            next_action = np.argmax(mainQs)  #最大の報酬を返す行動を選択する
            
            #next_state_bの列方向がすべて値を持っていれば（stepが終了した後の状態でなければ）、以下の処理を実行
            if not (next_state_b == np.zeros(state_b.shape)).all(axis=1):
                #次の状態において予測されるQ値をtargetQNを使って見積もる（違うモデルでも出力されるQ値の順番は同じ？）
                target = reward_b + gamma * targetQN.model.predict(next_state_b)[0][next_action]  #gammaは時間割引率を成している？
                #教師データを代入する
                targets[i][next_action] = target   
#             else:
#                 #next_state_bが0のとき、targetには教師データとしてreward_bの値をそのまま代入する（この処理は良いのだろうか...）
#                 targets[i][next_action] = target  #教師信号を代入する

        #1ステップごとに重みをコピー
        targetQN.model.set_weights(self.model.get_weights())
        
        #今の状態で予測されたQ値が、次の状態で予測される値（r(t)＋γ・max[Q(s_{t+1},a_{t+1})]）に近づくように重みを学習し更新する
        self.model.fit(inputs, targets, epochs=1, verbose=0)  #epochsは訓練データの反復回数、verbose=0は表示なしの設定
            
#学習する内容を保存しておく記憶クラス
class Memory:
    def __init__(self, max_size=1000):
        self.buffer = deque(maxlen=max_size)
 
    def add(self, experience):
        self.buffer.append(experience)
 
    #取得したデータと同じ要素数のリストnp.arange(len(self.buffer))を用意し、
    #ランダムにその要素を抜き出し、それを取得したデータのindexとして使うことで、
    #取得したデータの要素をランダムに抜き出せる
    def sample(self, batch_size):
        idx = np.random.choice(np.arange(len(self.buffer)), size=batch_size, replace=False)
        return [self.buffer[ii] for ii in idx]
 
    def len(self):
        return len(self.buffer)
    
#カートの状態に応じて、行動を決定するクラス
class Actor:
    def get_action(self, state, episode, mainQN):  #行動を返す
        #徐々に最適行動のみをとる、ε-greedy法
        epsilon = 0.005 * ( 1/(episode+1) )
 
        if epsilon <= np.random.uniform(0, 1):
            Q_values = mainQN.model.predict(state)[0]  #pridictでQ値を予測し取得（最後の[0]は要素として抜き出すことを意味する）
            #最大の報酬を返す行動（インデックス（今回は行動は右か左なので0か1を返す））を選択する
            action = np.argmax(Q_values)
 
        else:
            action = np.random.choice([0, 1])  #ランダムに行動する
 
        return action


#初期設定
LENDER_MODE = 1  #0は学習後も描画なし、1は学習終了後に描画する
 
env = gym.make("CartPole-v0")
num_episodes = 1000  #総試行回数
max_number_of_steps = 200  #1試行のstep数
goal_average_reward = 1  #この報酬を超えると学習終了
num_consecutive_iterations = 10  #学習完了評価の平均計算を行う試行回数
total_reward_vec = np.zeros(num_consecutive_iterations)  #各試行の報酬を格納するための空のリスト
gamma = 0.9  #時間割引係数
islearned = 0  #学習済みフラグ
isrender = 0  #描画フラグ

hidden_size = 16  #Q-networkの隠れ層のニューロンの数
learning_rate = 0.00001  #Q-networkの学習係数
memory_size = 10000  #バッファーメモリの大きさ
batch_size = 32  #Q-networkを更新するときに用いるデータ数


#Qネットワークとメモリ、Actorの生成
mainQN = QNetwork(hidden_size=hidden_size, learning_rate=learning_rate)  #メインのQネットワーク
targetQN = QNetwork(hidden_size=hidden_size, learning_rate=learning_rate)  #価値を計算するQネットワーク
memory = Memory(max_size=memory_size)
actor = Actor()

#メイン
for episode in range(num_episodes):  #試行数分繰り返す
    env.reset()  #CartPoleの環境初期化
    state, reward, done, info = env.step(env.action_space.sample())  #1step目は適当な行動をとる
    state = np.reshape(state, (1, 4))  #list型のstateを、1行4列の行列に変換（model.pridictに対応するため）
    episode_reward = 0
 
    for t in range(max_number_of_steps):  #1試行のループ
        if (islearned == 1) and LENDER_MODE:  #学習終了したらCartPoleを描画する
            env.render()
 
        action = actor.get_action(state, episode, mainQN)  #今の状態に応じて次の行動を決定する
        next_state, reward, done, info = env.step(action)  #行動a_tの実行による、s_{t+1}、R{t}を計算する
        next_state = np.reshape(next_state, (1, 4))  #list型のstateを、1行4列の行列に変換
 
        # 報酬を設定し、与える
        if done:
            next_state = np.zeros(state.shape)  #ステップ終了後、次の状態s_{t+1}はないとして0を代入する
            if t < 200:
                reward = -1  #200ステップ以前に倒れたら罰を与える
            else:
                reward = 1  #立ったまま200step超えて終了した場合は報酬を与える
        else:
            reward = 0  #各ステップで立ってたら報酬は与えない
 
        episode_reward += reward  #合計報酬を更新
 
        memory.add((state, action, reward, next_state))  #メモリにデータを追加
        state = next_state  #状態更新
 
        #Qネットワークの重みを学習・更新する
        if (memory.len() > batch_size) and not islearned:
            mainQN.replay(memory, batch_size, gamma, targetQN)  #targetQNの重みを使ってmainQNの重みを更新    
 
        #1試行終了時の処理
        if done:
            total_reward_vec = np.hstack((total_reward_vec[1:], episode_reward))  #報酬を記録
            print("%d Episode finished after %d time steps / mean %f" % (episode+1, t+1, total_reward_vec.mean()))
            break
 
    #複数試行の平均報酬で終了を判断
    if total_reward_vec.mean() >= goal_average_reward:
        print("Episode %d train agent successfuly!" % episode+1)
        islearned = 1  #学習済みフラグを更新
        isrender = 1  #描画フラグを更新