引言

前面說到了強化學習中的蒙特卡洛方法(MC)以及時序差分(TD)的方法，這些方法針對的基本是離散的資料，而一些連續的狀態則很難表示，對於這種情況，通常在強化學習裡有2中方法，一種是針對value function的方法，也就是本文中提到的值近似(value approximation)；另一種則是後面要講到的policy gradient。

值近似的方法

值近似的方法根本上是使用一個值函式來近似表示該狀態的返回值，對於狀態S$S$，在一個序列中間，我們使用一個引數函式vˆ(S,w)$\hat{v}(S,w)$來近似表示觀測到的真實值vπ(S)$v_{\pi }(S)$，學習使用普通的梯度下降的方式進行，對於一個觀察序列的每一個step均可以作為一個訓練的過程。當然這個值函式可以加上動作

示例

問題描述：一個汽車從谷底向上開，但是汽車的馬力不足以支撐其到終點，因此最好的策略是需要先開到谷底的左邊然後再加速，利用一部分慣性到達終點。

1. 這裡面的狀態可以描述為：(橫向位置xt),(速度xt^)$(橫向位置x_t),(速度\widehat{x_t})$
2. 動作空間為3個，−1,0,1$-1,0,1$，分別表示全力向左，不動和全力向右
3. 狀態序列更新的方式為：
   xt+1=bound[xt+xt+1^]$$x_{t+1}=bound[x_t+\widehat{x_{t+1}}]$$
   xt+1^=bound[xt^+0.001A−0.0025cos(3xt)]$$\widehat{x_{t+1}}=bound[\widehat{x_t}+0.001A$$
   −0.0025cos(3xt)]

這裡bound表示其約束範圍，橫軸座標xt$x_t$的範圍是−1.5≤xt≤0.5$-1.5\le x_t\le 0.5$，速度的範圍是−0.07≤xt^≤0.07$-0.07\le \widehat{x_t}\le 0.07$，當xt$x_t$行到最座標的時候，將會被置零。

在本示例中，將使用Q-learning的值近似方法，採用的線性函式來表示Q函式。

實驗環境

實驗將基於openAI所提供的gym包的mountaincar-v0這一個環境，openAI提供了很多的遊戲環境，都可以進行相關的強化學習實驗。
openAI目前支援mac OS 和Linux環境，可以直接使用pip install gym的方式安裝其最新的版本的gym，但是對於python2.7來說，安裝最新的版本0.9.6，可能會出現cannot import name spaces

關鍵程式碼

class Estimator(object):
    def __init__(self):
        self.models=[]
        for _ in range(env.action_space.n):
            model = SGDRegressor(learning_rate="constant")
            model.partial_fit([self.feature_state(env.reset())],[0])
            self.models.append(model)

    def predict(self,s,a=None):
        s=self.feature_state(s)
        if a:
            return self.models[a].predict([s])[0]
        else:
            return [self.models[m].predict([s])[0] for m in range(env.action_space.n)]

    def update(self,s,a,target):
        s=self.feature_state(s)
        self.models[a].partial_fit([s],[target])

    def feature_state(self,s):

        return featurizer.transform(scaler.transform([s]))[0]

def make_epsilon_greedy_policy(estimator,nA,epsilon):

    def epsilon_greedy_policy(observation):

        best_action = np.argmax(estimator.predict(observation))
        A =np.ones(nA,dtype=np.float32)*epsilon/nA
        A[best_action] += 1-epsilon
        return A

    return epsilon_greedy_policy


def Q_learning_with_value_approximation(env,estimator,epoch_num
                                        ,discount_factor=1.0, epsilon=0.1, epsilon_decay=1.0):

    # stats = plotting.EpisodeStats(
    #     episode_lengths=np.zeros(epoch_num),
    #     episode_rewards=np.zeros(epoch_num))
    for i_epoch_num in range(epoch_num):

        policy = make_epsilon_greedy_policy\
            (estimator,env.action_space.n,epsilon*epsilon_decay**i_epoch_num)
        state = env.reset()

        for it in itertools.count():

            action_probs = policy(state)
            action = np.random.choice(np.arange(len(action_probs)), p=action_probs)

            next_state,reward,done,_=env.step(action)
            q_values_next = estimator.predict(next_state)
            td_target = reward + discount_factor * np.max(q_values_next)
            estimator.update(state, action, td_target)

            # stats.episode_rewards[i_epoch_num] += reward
            # stats.episode_lengths[i_epoch_num] = it
            print("\rStep {} @ Episode {}/{}".format(it, i_epoch_num + 1, epoch_num))

            if done:
                print it
                break
            state = next_state

其中，將兩個狀態引數使用RBF核函式進行轉換為一維長度為400的特徵向量，使用的普通的SGDRegressor。

結果

執行100代後的函式cost值為

程式碼連結