notebooks/RL_generalized.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import jax.numpy as jnp\n",
    "import jax"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 強化学習を動的計画法で全部書く\n",
    "\n",
    "参考\n",
    "* [A Generalized ReinforcementLearning Model Convergence and Application](https://cs.brown.edu/~mlittman/papers/ml96-generalized.pdf)\n",
    "* [Towards Characterizing Divergence in Deep Q-Learning](https://arxiv.org/abs/1903.08894)\n",
    "\n",
    "Q学習みたいな要素毎の更新則も動的計画法でまとめて書きたいですよね。それを叶える便利なモデルがあります。\n",
    "\n",
    "## データの分布と汎化と作用素\n",
    "\n",
    "参考: [Towards Characterizing Divergence in Deep Q-Learning](https://arxiv.org/abs/1903.08894)\n",
    "\n",
    "一旦Q学習を復習しましょう：\n",
    "\n",
    "**価値反復法**\n",
    "* ベルマン作用素: $TQ = r + \\gamma P\\max Q$\n",
    "* 更新則: $Q_{t+1} \\leftarrow T Q_t$\n",
    "\n",
    "**Q学習**\n",
    "* 近似ベルマン作用素: $\\hat{T}Q(s, a) = r(s, a) + \\gamma \\max_{a'} Q(s', a')$\n",
    "* 更新則: $Q_{t+1}(s_t, a_t) \\leftarrow Q_{t}(s_t, a_t) + \\alpha_t \\left(\\hat{T}Q_t(s_t, a_t) - Q_t(s_t, a_t)\\right)$\n",
    "\n",
    "この２つは次の行列計算で一般化できます\n",
    "\n",
    "* 更新則: $Q_{t+1} \\leftarrow Q_t + \\alpha_t D_t \\left(\\hat{T} Q_t - Q_t\\right)$\n",
    "\n",
    "ここで、$D_t$は$|S||A|\\times |S||A|$の対角行列で、その要素はデータに使用する状態行動$(s, a)$の分布になっています。\n",
    "つまり、Q学習の場合は$D_t = \\text{diag} [0, \\cdots, 1, \\cdots, 0]$です（$(s_t, a_t)$番目の要素だけ１）し、価値反復法の場合は$\\alpha_t = |S||A|$ かつ $D_t = \\text{diag} [1/|S||A|, \\cdots, 1/|S||A|]$。\n",
    "Replay bufferなどを使う場合もこれで表すことができます。\n",
    "\n",
    "関数近似がある場合はどうなるでしょうか？\n",
    "\n",
    "**適合Q学習**\n",
    "* パラメータの更新: $\\theta_{t+1} \\leftarrow \\theta_{t} + \\alpha_t \\mathbb{E}_{(s', a')\\sim D}\\left[\\left(\\hat{T}Q_{\\theta_t}(s', a') - Q_{\\theta_t}(s', a')\\right)\\nabla_{\\theta_t} Q_{\\theta_t}(s', a')\\right]$\n",
    "* 更新則: $Q_{t+1} \\leftarrow Q_{\\theta_{t+1}}$\n",
    "\n",
    "これはテイラー展開すると、\n",
    "* Neural Tangent Kernel: $k_\\theta(s, a, s', a')=\\nabla_{\\theta_t} Q_{\\theta_t}(s, a)^T\\nabla_{\\theta_t} Q_{\\theta_t}(s', a')$\n",
    "* 更新則: $Q_{t+1}(s, a) \\leftarrow Q_{t}(s, a) + \\alpha_t \\mathbb{E}_{(s', a')\\sim D}\\left[k_{\\theta_t}(s, a, s', a')\\left(\\hat{T}Q_{\\theta_t}(s', a') - Q_{\\theta_t}(s', a')\\right)\\right] + \\mathcal{O}(\\|\\theta_{t+1}-\\theta_{t}\\|^2)$\n",
    "\n",
    "これも次の行列計算で一般化できます\n",
    "\n",
    "* 更新則: $Q_{t+1} \\leftarrow Q_t + \\alpha_t K_t D_t \\left(\\hat{T} Q_t - Q_t\\right) + \\mathcal{O}(\\|\\theta_{t+1}-\\theta_{t}\\|^2)$ \n",
    "\n",
    "ここで、$K_t$は$|S||A|\\times |S||A|$の行列で、$K(s, a, s', a') = k(s, a, s', a')$です。線形近似で$Q_\\theta = \\theta^T \\Phi$としている場合、$K = \\Phi \\Phi^T$です。(Linear MDPのことを考えるともっと面白い結果がでるかも？)\n",
    "\n",
    "なんにせよ、この更新則も何らかの作用素$U_i: Q\\mapsto Q$によって更新しています。\n",
    "[論文](https://arxiv.org/abs/1903.08894)では、$U_0, U_1, \\dots$が全て同じfixed-point $\\tilde{Q}$を持ち、$U_i$が$\\beta_i$リプシッツ連続で、$Q_{i+1}\\leftarrow U_iQ_i$で更新され、\n",
    "\n",
    "$$\n",
    "\\|\\tilde{Q} - Q_i\\| \\leq \\left(\\prod_{k=0}^{i-1} \\beta_k\\right)\\|\\tilde{Q} - Q_0\\|\n",
    "$$\n",
    "\n",
    "が任意の$i$で満たされているとき、$Q_i$が$\\tilde{Q}$に収束することが証明されています(確率的にfixed-pointになる場合については言及されていません)。\n",
    "\n",
    "試しに適合Q学習をこの形で書いてみます。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "実験の前に、いくつか便利な関数を導入します。\n",
    "\n",
    "1. ``compute_greedy_policy``: Q関数 ($S \\times A \\to \\mathcal{R}$) の貪欲方策を返します\n",
    "2. ``compute_optimal_Q``: MDPの最適Q関数 $q_* : S \\times A \\to \\mathcal{R}$ を返します。\n",
    "3. ``compute_policy_Q``: 方策 $\\pi$ のQ関数 $q_\\pi : S \\times A \\to \\mathcal{R}$ を返します。\n",
    "4. ``compute_optimality_gap``: 方策 $\\pi$ と最適解との差 $\\|q_* - q_{\\pi}\\|_\\infty$ を返します。この値が小さいほど、$\\pi$ はほぼ全ての状態行動対で最適な方策になっています。\n",
    "5. ``sample_next_state``: $(s, a)$の次の状態をサンプルします。\n",
    "6. ``sample_init_state``: 初期状態をサンプルします。\n",
    "7. ``sample_eps_greedy_act``: 与えられたQ値から、epsilon-greedy方策に従って行動を返します"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from functools import partial\n",
    "from typing import NamedTuple, Optional\n",
    "import jax\n",
    "\n",
    "\n",
    "class MDP(NamedTuple):\n",
    "    S_array: np.array  # 状態空間\n",
    "    A_array: np.array  # 行動空間\n",
    "    gamma: float  # 割引率\n",
    "    horizon: int  # ホライゾン\n",
    "    rew: float  # 報酬関数\n",
    "    P: float  # 遷移確率\n",
    "    phi: Optional[np.array] = None # 特徴行列\n",
    "    optimal_Q: Optional[np.ndarray] = None  # 最適Q値\n",
    "    optimal_Q_idx: Optional[np.ndarray] = None  # 後でplot用に使います\n",
    "\n",
    "    @property\n",
    "    def S(self) -> int:  # 状態空間のサイズ\n",
    "        return len(self.S_array)\n",
    "\n",
    "    @property\n",
    "    def A(self) -> int:  # 行動空間のサイズ\n",
    "        return len(self.A_array)\n",
    "\n",
    "\n",
    "# >>>> 1 >>>>\n",
    "@jax.jit\n",
    "def compute_greedy_policy(Q: np.ndarray):\n",
    "    greedy_policy = jnp.zeros_like(Q)\n",
    "    S, A = Q.shape\n",
    "    greedy_policy = greedy_policy.at[jnp.arange(S), Q.argmax(axis=1)].set(1)\n",
    "    assert greedy_policy.shape == (S, A)\n",
    "    return greedy_policy\n",
    "# <<<< 1 <<<<\n",
    "\n",
    "\n",
    "# >>>> 2 >>>>\n",
    "@partial(jax.jit, static_argnames=(\"S\", \"A\"))\n",
    "def _compute_optimal_Q(mdp: MDP, S: int, A: int):\n",
    "\n",
    "    def backup(optimal_Q):\n",
    "        greedy_policy = compute_greedy_policy(optimal_Q)\n",
    "        max_Q = (greedy_policy * optimal_Q).sum(axis=1)\n",
    "        next_v = mdp.P @ max_Q\n",
    "        assert next_v.shape == (S, A)\n",
    "        return mdp.rew + mdp.gamma * next_v\n",
    "    \n",
    "    optimal_Q = jnp.zeros((S, A))\n",
    "    body_fn = lambda i, Q: backup(Q)\n",
    "    return jax.lax.fori_loop(0, mdp.horizon + 100, body_fn, optimal_Q)\n",
    "\n",
    "compute_optimal_Q = lambda mdp: _compute_optimal_Q(mdp, mdp.S, mdp.A)\n",
    "# <<<< 2 <<<<\n",
    "\n",
    "\n",
    "# >>>> 3 >>>>\n",
    "def compute_policy_Q(mdp: MDP, policy: np.ndarray):\n",
    "    S, A = policy.shape\n",
    "\n",
    "    def backup(policy_Q):\n",
    "        max_Q = (policy * policy_Q).sum(axis=1)\n",
    "        next_v = mdp.P @ max_Q\n",
    "        assert next_v.shape == (S, A)\n",
    "        return mdp.rew + mdp.gamma * next_v\n",
    "    \n",
    "    policy_Q = jnp.zeros((S, A))\n",
    "    body_fn = lambda i, Q: backup(Q)\n",
    "    return jax.lax.fori_loop(0, mdp.horizon + 100, body_fn, policy_Q)\n",
    "# <<<< 3 <<<<\n",
    "\n",
    "# >>>> 4 >>>>\n",
    "@jax.jit\n",
    "def compute_optimality_gap(mdp: MDP, policy: np.ndarray):\n",
    "    policy_Q = compute_policy_Q(mdp, policy)\n",
    "    optimality_gap = jnp.abs(mdp.optimal_Q - policy_Q).max()\n",
    "    return optimality_gap\n",
    "# <<<< 4 <<<<\n",
    "\n",
    "# >>>> 5 >>>>\n",
    "def sample_next_state(mdp: MDP, s: int, a: int):\n",
    "    \"\"\" sample next state according to the transition matrix P\n",
    "    Args:\n",
    "        mdp: MDP\n",
    "        s: int\n",
    "        a: int\n",
    "    Returns:\n",
    "        next_s: int\n",
    "    \"\"\"\n",
    "    probs = np.array(mdp.P[s, a])\n",
    "    return np.random.choice(mdp.S_array, p=probs)\n",
    "# <<<< 5 <<<<\n",
    "\n",
    "\n",
    "# >>>> 6 >>>>\n",
    "def sample_init_state(mdp: MDP):\n",
    "    return random.randint(0, mdp.S-1)\n",
    "# <<<< 6 <<<<\n",
    "\n",
    "\n",
    "# >>>> 7 >>>>\n",
    "def sample_eps_greedy_act(mdp: MDP, q_s: np.array, eps: float):\n",
    "    if random.random() < eps:\n",
    "        return random.randint(0, mdp.A-1)\n",
    "    else:\n",
    "        return q_s.argmax()\n",
    "# <<<< 7 <<<<"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from functools import partial\n",
    "from typing import Optional, NamedTuple\n",
    "import jax.numpy as jnp\n",
    "\n",
    "def create_rew_P(S: int, A: int, b: int):\n",
    "    \"\"\" Garnet MDP (報酬関数, 遷移確率) を作成します\n",
    "\n",
    "    Args:\n",
    "        S (int): 状態空間のサイズ\n",
    "        A (int): 行動空間のサイズ\n",
    "        b (int): branching factor\n",
    "\n",
    "    Returns:\n",
    "        rew (float): 報酬関数\n",
    "        P (float): 遷移確率\n",
    "    \"\"\"\n",
    "    # ランダムな報酬関数を作ります\n",
    "    rew = np.random.rand(S, A)\n",
    "\n",
    "    # ランダムな遷移確率を作ります\n",
    "    P = np.random.rand(S * A, S)\n",
    "\n",
    "    for idx in range(S*A):\n",
    "        unreachable_states = np.random.choice(S, size=S-b, replace=False)\n",
    "        P[idx, unreachable_states] = 0\n",
    "    P = P / np.sum(P, axis=-1, keepdims=True)  # 正規化して確率にします\n",
    "    P = P.reshape(S, A, S)\n",
    "    np.testing.assert_almost_equal(P.sum(axis=-1), 1)\n",
    "    assert np.all(np.count_nonzero(P, axis=-1) == b)\n",
    "    return jnp.array(rew), jnp.array(P)\n",
    "\n",
    "\n",
    "# 適当なGarnet MDPを作ります\n",
    "S = 5\n",
    "A = 2\n",
    "b = 2\n",
    "S_array = np.arange(S)\n",
    "A_array = np.arange(A)\n",
    "gamma = 0.99\n",
    "horizon = int(1 / (1 - gamma))\n",
    "\n",
    "# Garnet MDPを作ります\n",
    "rew, P = create_rew_P(S, A, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fced555b250>"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "@jax.jit\n",
    "def compute_targ_Q(mdp: MDP, Q: np.ndarray):\n",
    "    S, A = Q.shape\n",
    "    greedy_policy = compute_greedy_policy(Q)\n",
    "    max_Q = np.sum(greedy_policy * Q, axis=1).reshape(1, 1, S)\n",
    "    next_v = np.sum(mdp.P * max_Q, axis=-1)\n",
    "    assert next_v.shape == (S, A)\n",
    "    return mdp.rew + mdp.gamma * next_v\n",
    "\n",
    "\n",
    "def do_FQI(mdp: MDP):\n",
    "    suboptimality = []\n",
    "    S, A, d = mdp.S, mdp.A, mdp.phi.shape[-1]\n",
    "    Q = np.zeros(S*A)\n",
    "    Phi = mdp.phi.reshape(S*A, d)\n",
    "    K = Phi @ Phi.T\n",
    "    assert K.shape == (S*A, S*A)\n",
    "    lr = 0.1\n",
    "\n",
    "    for _ in range(1000):\n",
    "        sa_dist = np.random.uniform(0, 1, S*A)\n",
    "        sa_dist = sa_dist / sa_dist.sum()\n",
    "        D = np.diag(sa_dist)\n",
    "        targ_Q = compute_targ_Q(mdp, Q.reshape(S, A)).reshape(S*A)\n",
    "        Q = Q + lr * K @ D @ (targ_Q - Q)\n",
    "        suboptimality.append(np.abs(mdp.optimal_Q - Q).max())\n",
    "    return suboptimality\n",
    "\n",
    "\n",
    "d = S*A\n",
    "random_phi = np.random.randn(S, A, d)  # ランダムな特徴ベクトル\n",
    "mdp = MDP(S_array, A_array, gamma, horizon, rew, P, random_phi)\n",
    "mdp = mdp._replace(optimal_Q=compute_optimal_Q(mdp).reshape(S*A))\n",
    "suboptimality = do_FQI(mdp)\n",
    "plt.plot(suboptimality, label=\"random\")\n",
    "\n",
    "onehot_phi = np.eye(S*A).reshape(S, A, d)  # one-hot 特徴ベクトル\n",
    "mdp = MDP(S_array, A_array, gamma, horizon, rew, P, onehot_phi)\n",
    "mdp = mdp._replace(optimal_Q=compute_optimal_Q(mdp).reshape(S*A))\n",
    "suboptimality = do_FQI(mdp)\n",
    "plt.plot(suboptimality, label=\"onehot\")\n",
    "\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "論文ではKの非対角成分が対角成分よりも十分小さくなるのが収束に必要だと説明しています。\n",
    "今回は適当にランダムなMDPを生成したのでこれが重要でしたが、多分Linear MDPでは違う条件になりそうです。考えてみます。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ベルマン作用素をもっと一般化\n",
    "\n",
    "参考： \n",
    "* [A Generalized ReinforcementLearning Model Convergence and Application](https://cs.brown.edu/~mlittman/papers/ml96-generalized.pdf)\n",
    "* 証明や詳細はこっちのほうが詳しいです：[Generalized Markov Decision Processes: Dynamic-programming and Reinforcement-learning Algorithms](https://www.ualberta.ca/~szepesva/papers/gmdp.ps.pdf)\n",
    "* [An Alternative Softmax Operator for Reinforcement Learning](https://arxiv.org/abs/1612.05628)\n",
    "\n",
    "強化学習の作用素をもっと一般化させてみましょう。\n",
    "まず、Q学習の更新は\n",
    "\n",
    "* 近似ベルマン作用素: $\\hat{T}Q(s, a) = r(s, a) + \\gamma \\max_{a'} Q(s', a')$\n",
    "* 更新則: $Q_{t+1}(s_t, a_t) \\leftarrow Q_{t}(s_t, a_t) + \\alpha_t \\left(\\hat{T}Q_t(s_t, a_t) - Q_t(s_t, a_t)\\right)$\n",
    "\n",
    "でした。このmax作用素を$\\otimes$で一般化させると、\n",
    "* 近似ベルマン作用素: $\\hat{T}Q(s, a) = r(s, a) + \\gamma \\otimes_{a'} Q(s', a')$\n",
    "* 更新則: $Q_{t+1}(s_t, a_t) \\leftarrow Q_{t}(s_t, a_t) + \\alpha_t \\left(\\hat{T}Q_t(s_t, a_t) - Q_t(s_t, a_t)\\right)$\n",
    "\n",
    "とQ学習が一般化できます。例えば$\\otimes$をsoftmax作用素などに変更できます。(遷移行列$P$の部分も一般化できますが、今回はこれだけにします。遷移行列を一般化するとrisk-sensitive MDPを一般化できます。)\n",
    "\n",
    "どのような$\\otimes$が適切でしょうか？$\\otimes$がnon-expansionであるときに作用素${T}Q(s, a) = r(s, a) + \\gamma P(\\otimes Q)$はcontraction mappingになります：\n",
    "\n",
    "* non-expansion: $\\otimes_a f_1(x, a) - \\otimes_a f_2(x, a) \\leq \\max_a |f_1(x, a) - f_2(x, a)|$ \n",
    "* contraction mapping: $\\sup_{x, a} |[TQ_1](x, a) - [TQ_2](x, a)| \\leq \\gamma \\sup_{x, a} |Q_1(x, a) - Q_2(x, a)|$\n",
    "\n",
    "ちなみにSoftmaxはnon-expansionではありません。なので収束が保証できません。\n",
    "[論文](https://arxiv.org/abs/1612.05628)のFigure2を再現してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from typing import Optional, NamedTuple\n",
    "import jax.numpy as jnp\n",
    "\n",
    "S = 2\n",
    "A = 2\n",
    "rew = np.zeros((S, A))\n",
    "rew[0, 0] = 0.122\n",
    "rew[0, 1] = 0.033\n",
    "P = np.zeros((S, A, S))\n",
    "P[0, 0, 0] = 0.66\n",
    "P[0, 0, 1] = 0.34\n",
    "P[0, 1, 0] = 0.99\n",
    "P[0, 1, 1] = 0.01\n",
    "P[1, 0, 0] = 0\n",
    "P[1, 0, 1] = 1\n",
    "P[1, 1, 0] = 0\n",
    "P[1, 1, 1] = 1\n",
    "np.testing.assert_almost_equal(P.sum(axis=-1), 1)\n",
    "rew, P = jnp.array(rew), jnp.array(P)\n",
    "\n",
    "S_array = np.arange(S)\n",
    "A_array = np.arange(A)\n",
    "gamma = 0.98\n",
    "horizon = int(1 / (1 - gamma))\n",
    "mdp = MDP(S_array, A_array, gamma, horizon, rew, P)\n",
    "mdp = mdp._replace(optimal_Q=compute_optimal_Q(mdp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2000/2000 [00:54<00:00, 36.58it/s]\n",
      "100%|██████████| 2000/2000 [00:57<00:00, 34.85it/s]\n"
     ]
    }
   ],
   "source": [
    "# SARSAをします\n",
    "from tqdm import tqdm\n",
    "from scipy import special\n",
    "\n",
    "\n",
    "def do_Q_learning(mdp: MDP, n_episode: int):\n",
    "    S, A = mdp.S, mdp.A\n",
    "    horizon = mdp.horizon\n",
    "\n",
    "    Q_table = np.zeros((S, A))\n",
    "    lr = 0.1\n",
    "    eps0 = 0.5\n",
    "\n",
    "    Q_1_vals = []\n",
    "    Q_2_vals = []\n",
    "    num_samples = []\n",
    "    num_sample = 0\n",
    "\n",
    "    for e in tqdm(range(n_episode)):\n",
    "        s = 0\n",
    "        eps = eps0 * (1 - e / 1000)\n",
    "        for _ in range(horizon):\n",
    "            if s == 1:\n",
    "                break\n",
    "            a = sample_eps_greedy_act(mdp, Q_table[s], eps)\n",
    "            next_s = sample_next_state(mdp, s, a)\n",
    "            greedy_pol = compute_greedy_policy(Q_table)[next_s]\n",
    "            targ_q = mdp.rew[s, a] + mdp.gamma * np.sum(greedy_pol * Q_table[next_s])\n",
    "            Q_table[s, a] = lr * targ_q.item() + (1 - lr) * Q_table[s, a]\n",
    "            s = next_s\n",
    "            num_sample += 1\n",
    "\n",
    "        Q_1_vals.append(Q_table[0, 0])\n",
    "        Q_2_vals.append(Q_table[0, 1])\n",
    "        num_samples.append(num_sample)\n",
    "    return num_samples, Q_1_vals, Q_2_vals\n",
    "\n",
    "\n",
    "def do_SARSA(mdp: MDP, n_episode: int):\n",
    "    S, A = mdp.S, mdp.A\n",
    "    horizon = mdp.horizon\n",
    "\n",
    "    Q_table = np.zeros((S, A))\n",
    "    lr = 0.1\n",
    "    beta = 16.55\n",
    "\n",
    "    Q_1_vals = []\n",
    "    Q_2_vals = []\n",
    "    num_samples = []\n",
    "    num_sample = 0\n",
    "\n",
    "    for _ in tqdm(range(n_episode)):\n",
    "        s = 0\n",
    "        for _ in range(horizon):\n",
    "            if s == 1:\n",
    "                break\n",
    "            softmax_pol = special.softmax(beta * Q_table[s])\n",
    "            a = np.random.choice(A, p=softmax_pol)\n",
    "            next_s = sample_next_state(mdp, s, a)\n",
    "            softmax_pol = special.softmax(beta * Q_table[next_s])\n",
    "            targ_q = mdp.rew[s, a] + mdp.gamma * np.sum(softmax_pol * Q_table[next_s])\n",
    "            Q_table[s, a] = lr * targ_q.item() + (1 - lr) * Q_table[s, a]\n",
    "            s = next_s\n",
    "            num_sample += 1\n",
    "\n",
    "        Q_1_vals.append(Q_table[0, 0])\n",
    "        Q_2_vals.append(Q_table[0, 1])\n",
    "        num_samples.append(num_sample)\n",
    "    return num_samples, Q_1_vals, Q_2_vals\n",
    "\n",
    "n_episode = 2000\n",
    "Q_num_samples, Q_1, Q_2 = do_Q_learning(mdp, n_episode)\n",
    "SARSA_num_samples, SARSA_1, SARSA_2 = do_SARSA(mdp, n_episode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fced5326df0>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(Q_num_samples, Q_1, label=r\"Q-learning: $Q(s_1, a_1)$\")\n",
    "plt.plot(Q_num_samples, Q_2, label=r\"Q-learning: $Q(s_1, a_2)$\")\n",
    "plt.plot(SARSA_num_samples, SARSA_1, label=r\"SARSA: $Q(s_1, a_1)$\")\n",
    "plt.plot(SARSA_num_samples, SARSA_2, label=r\"SARSA: $Q(s_1, a_2)$\")\n",
    "plt.legend()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "うーん、Figure2は「non-expansionではないsoftmaxでは収束しない」ってことが言いたいみたいですが、誤差のせいでnon-expansionなmaxでも収束してないので、あんまり例としては良くない気がしますね。"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "今回のベルマン作用素は$(s, a)$に対して次の状態$(s')$が一つランダムに対応する作用素になっています。つまり、確率的に作用素が変化するわけですね。\n",
    "さらに、Q学習の更新則$Q_{t+1}(s_t, a_t) \\leftarrow Q_{t}(s_t, a_t) + \\alpha_t \\left(\\hat{T}Q_t(s_t, a_t) - Q_t(s_t, a_t)\\right)$のように、ベルマン作用素自体が$Q_t$に依存することもあります。\n",
    "そこで、与えられた価値関数からランダムに作用素を返す作用素$T_t: \\mathbb{B}(XA) \\to (\\mathbb{B}(XA)\\to\\mathbb{B}(XA))$を考え、一般的な更新則：\n",
    "\n",
    "$$Q_{t+1} = [T_t Q_t] Q'$$\n",
    "\n",
    "を考えましょう。例えばQ学習の場合にはベルマン作用素は\n",
    "\n",
    "$$[T_t Q']Q \\leftarrow Q' + \\alpha_t D_t (r + \\gamma P_t (\\otimes Q) - Q')$$\n",
    "\n",
    "と表せます（ここで、$P_t$はランダムにサンプルされた遷移確率です。例えば$(s, a)$を選択して$s'$が出たら、$P_t(s, a, s')=1$かつそれ以外の$y'$に対して$P_t(s, a, y')=0$とすればOK）。FQIなら\n",
    "\n",
    "$$[T_t Q']Q \\leftarrow Q' + \\alpha_t K_t D_t (r + \\gamma P_t (\\otimes Q) - Q') + \\mathcal{O}(\\|\\theta_{t+1}-\\theta_{t}\\|^2)$$\n",
    "\n",
    "になるでしょう。\n",
    "論文のTheorem1は$Q_{t+1}\\leftarrow [T_t Q_t] Q_t$が$Q^*$に収束するために十分な条件を与えています。\n",
    "\n",
    "Pythonでもこの形で適合Q学習を書き直してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fd08edb1160>"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiYAAAGdCAYAAAAmK7htAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABJdUlEQVR4nO3dd3hUVf4G8HdqJpNKegIJCTWEDiEYQKVEEVEXkdVFRFDWXQELoiisvS3IrvxQN4od166LFUVEkColtFACoSUQSCdkJn3a+f0RuGRIAglM5k55P8+Th7nn3sx85wKZN+eec65CCCFARERE5AKUchdAREREdA6DCREREbkMBhMiIiJyGQwmRERE5DIYTIiIiMhlMJgQERGRy2AwISIiIpfBYEJEREQuQy13Aa1ls9mQn5+PgIAAKBQKucshIiKiFhBCoKKiAjExMVAqm+8Xcbtgkp+fj9jYWLnLICIiosuQl5eHDh06NLvf7YJJQEAAgPo3FhgYKHM1RERE1BJGoxGxsbHS53hz3C6YnLt8ExgYyGBCRETkZi41DIODX4mIiMhlMJgQERGRy2AwISIiIpfhNmNM0tPTkZ6eDqvVesljhRCwWCwtOpacQ6VSQa1Wc4o3ERFdlEIIIeQuojWMRiOCgoJgMBiaHPxqMplQUFCA6upqGaqji9Hr9YiOjoZWq5W7FCIicrJLfX6f4zY9Ji1hs9mQk5MDlUqFmJgYaLVa/obuAoQQMJlMKCkpQU5ODrp27XrRxXWIiMh7eVQwMZlMsNlsiI2NhV6vl7scasDX1xcajQbHjx+HyWSCTqeTuyQiInJBHvlrK38bd038eyEiokvhJwURERG5DAYTIiIichkMJl5o6tSpGDdunNxlEBERNcJgQkRERC6DwcRFmUwmuUsgIiIvs+P4GUz5YBsMNWbZavDoYCKEQLXJIstXa9etGz58OB544AHMmjULYWFhGD16NBYtWoTevXvDz88PsbGxmDFjBiorK6XvWbp0KYKDg7Fy5Ur06NED/v7+uOGGG1BQUCAdY7VaMXv2bAQHByM0NBSPP/54o9rq6urw0EMPISIiAjqdDsOGDUNGRoa0f+3atVAoFFi5ciX69+8PX19fjBw5EsXFxVixYgV69OiBwMBA3HnnnVzYjojITaX/fgS3vfUH1h0qwf+tOiRbHR61jsmFasxWJD2zUpbXznphNPTa1p3ejz76CNOnT8emTZsAACtWrMDrr7+OhIQEHDt2DDNmzMDjjz+ON998U/qe6upq/Pvf/8bHH38MpVKJu+66C4899hg+/fRTAMCrr76KpUuX4oMPPkCPHj3w6quv4ttvv8XIkSOl53j88cexbNkyfPTRR+jYsSMWLlyI0aNH48iRIwgJCZGOe+655/Cf//wHer0et99+O26//Xb4+Pjgs88+Q2VlJW699Va88cYbeOKJJ67k1BERkZNtOFyCf63MBgAM6RyKx2/oLlstHh1M3E3Xrl2xcOFCabt79/P/MOLj4/HSSy/h/vvvtwsmZrMZS5YsQefOnQEADzzwAF544QVp/+LFizFv3jyMHz8eALBkyRKsXHk+rFVVVeGtt97C0qVLMWbMGADAu+++i1WrVuH999/HnDlzpGNfeuklDB06FAAwbdo0zJs3D0ePHkWnTp0AABMmTMDvv//OYEJE5EZOnK7GrC92AwDuuioOL/6pl6yrpnt0MPHVqJD1wmjZXru1Bg4caLf922+/Yf78+Th48CCMRiMsFgtqa2tRXV0trWyr1+ulUAIA0dHRKC4uBgAYDAYUFBRg8ODB0n61Wo3k5GTpcs7Ro0dhNpulwAEAGo0GKSkpOHDggF09ffr0kR5HRkZCr9dLoeRc27Zt21r9vomISB61Zivu/SgDp6tMaB/sizmjE2W/lYtHBxOFQtHqyyly8vPzkx7n5ubipptuwvTp0/Hyyy8jJCQEGzduxLRp02AymaRgotFo7J5DoVC0enxLSzV8LYVC0eRr22y2NnltIiJyLLPVhglL/sCR4vqxi69P7I8gX80lvqvtefTgV3e2Y8cO2Gw2vPrqq7jqqqvQrVs35Ofnt+o5goKCEB0dja1bt0ptFosFO3bskLY7d+4MrVYrjWsB6i8PZWRkICkp6crfCBERuaQ3fz+KfaeMAIDZ13XDwI7tZK6onvt0J3iZLl26wGw244033sDNN9+MTZs2YcmSJa1+nocffhgLFixA165dkZiYiEWLFqG8vFza7+fnh+nTp2POnDkICQlBXFwcFi5ciOrqakybNs2B74iIiFyBzSbw1rqj+L/f6mfepPWIwIMju8hc1XnsMXFRffv2xaJFi/DKK6+gV69e+PTTTzF//vxWP8+jjz6KyZMnY8qUKUhNTUVAQABuvfVWu2MWLFiA2267DZMnT8aAAQNw5MgRrFy5Eu3auUZ6JiIix1n82yFpBs5VnUKw6I5+so8raUgh2mpAQhsxGo0ICgqCwWBAYGCg3b7a2lrk5OQgISEBOp1OpgqpOfz7ISKSV1WdBQNfWoVasw2PXtcN04d3hlrlnD6Ki31+N8RLOURERF7gYKERT3+3D7VmGxLC/PDAyC4u1VNyDoMJERGRhzNbbbj/4x3IPV2/Ovdfr05wyVACMJgQERF5vFVZRVIoeWNif9zUJ1rmiprHYEJEROTB/jhSihmf7gQAPDCiC27uGyNzRRfHWTlEREQeqthYi6kf1t+UVaEA7hgUK3NFl8YeEyIiIg9iqDHjl30F2J57Bl/vOCm1/3tCX8SG6GWsrGUYTIiIiDxEVr4RUz7chpKKOrv2JXcNxA29omSqqnUYTIiIiDzE/BUHpFDi76PGLf1i0DMmEKN7RspcWcsxmHgRhUKBb7/9FuPGjZO7FCIicrAjxRXYcLgUALD8wWFIjApw2uJpjuR+FZOshg8fjlmzZsldBhERXWDF3kIAwKjECPRqH+SWoQRwo2CSnp6OpKQkDBo0SO5SiIiIXEqBoQYfbzkOALi2e7jM1VwZtwkmM2fORFZWFjIyMuQupU3U1dXhoYceQkREBHQ6HYYNGya917Vr10KhUGD16tVITk6GXq/HkCFDkJ2dbfcc33//PQYMGACdTodOnTrh+eefh8VisTumtLQUt956K/R6Pbp27YoffvjBbv+6deuQkpICHx8fREdHY+7cudJzTJ06FevWrcNrr70GhUIBhUKB3NzctjspRER0SWarDfd8mIHiijr4alQY0T1C7pKuiNsEk8siBGCqkuerlfdGfPzxx7Fs2TJ89NFH2LlzJ7p06YLRo0ejrKxMOubJJ5/Eq6++iu3bt0OtVuPee++V9m3YsAF33303Hn74YWRlZeHtt9/G0qVL8fLLL9u9zvPPP4/bb78de/bswY033ohJkyZJr3Hq1CnceOONGDRoEDIzM/HWW2/h/fffx0svvQQAeO2115Camor77rsPBQUFKCgoQGys68+JJyLyZCv2FeJgYQWCfDVYNn2IW0wJvhjPvruwqQr4p0wr3P0jH9D6tejQqqoqtGvXDkuXLsWdd94JADCbzYiPj8esWbMwaNAgjBgxAr/99htGjRoFAPj5558xduxY1NTUQKfTIS0tDaNGjcK8efOk5/3kk0/w+OOPIz8/H0D94NennnoKL774ovS6/v7+WLFiBW644QY8+eSTWLZsGQ4cOCDdQ+HNN9/EE088AYPBAKVSieHDh6Nfv35YvHhxq08J7y5MROQ4FqsNADD1wwxsPFKKh0Z1xezruslcVfN4d2E3cvToUZjNZgwdOlRq02g0SElJwYEDB6RxNX369JH2R0fX3+eguLgYcXFxyMzMxKZNm+x6SKxWK2pra1FdXQ29Xt/oOfz8/BAYGIji4mIAwIEDB5Cammp3Y6ehQ4eisrISJ0+eRFxcXBu8eyIiaon88hpEB+lQVmXCXe9vw4ECo91+d5oSfDGeHUw0+vqeC7le29FPqdFIj8+FB5utPjFXVlbi+eefx/jx4xt9X8PeiYbPce55zj0HERG5ptdXH8aiVYcQrNcgUKfBibJqu/2dw/3QI6r5Xgh34tnBRKFo8eUUOXXu3BlarRabNm1Cx44dAdRfysnIyGjx1NwBAwYgOzsbXbp0uew6evTogWXLlkEIIQWfTZs2ISAgAB06dAAAaLVaWK3Wy34NIiJqnQUrDmLJuqMAgPJqM8qrzQCACQM74N6hCQjQqRHip4VSqbjY07gNzw4mbsLPzw/Tp0/HnDlzEBISgri4OCxcuBDV1dWYNm0aMjMzL/kczzzzDG666SbExcVhwoQJUCqVyMzMxL59+6TBq5cyY8YMLF68GA8++CAeeOABZGdn49lnn8Xs2bOhVNaPk46Pj8fWrVuRm5sLf39/hISESPuIiMhx9ucbMPb1jdJ253A/DO0SBh+1EhNT4tAp3F/G6toOg4mLWLBgAWw2GyZPnoyKigokJydj5cqVaNeuXYu+f/To0Vi+fDleeOEFvPLKK9BoNEhMTMRf//rXFtfQvn17/Pzzz5gzZw769u2LkJAQTJs2DU899ZR0zGOPPYYpU6YgKSkJNTU1yMnJQXx8fGvfLhERXUSdxYpHv7L/pfTr+4cgxE8rU0XO49mzcsil8O+HiKhlXv4pC+9uyAEAhPhpsWz6ECSEuf7QhIvhrBwiIiI3dPJMNT76o34V10W398X4AR1krsi5ODiAiIjIhSzfUwCT1YbBCSG4tX97uctxOgYTIiIiF7Ll2GkAQFqPSLt1pbwFgwkREZGLyMwrx9rsEgBAaudQmauRB4MJERGRi3h/Y/2A11v6xqBX+yCZq5GHRwYTN5to5DX490JE1LzDRRX4cU/9auV/u6aTzNXIx6OCybnl1qurqy9xJMnh3N/LhcviExERsGTdMQhRf88bb+0tATxsurBKpUJwcLB0Uzq9Xu+VA4dcjRAC1dXVKC4uRnBwMFQqldwlERG5hD+OluK5H/ZDqVDgYGEFAO/uLQE8LJgAQFRUFABI4YRcR3BwsPT3Q0Tk7b7bdQqzvtxt15YSH4IBcS1b8dtTeVwwUSgUiI6ORkREBMxms9zl0FkajYY9JUREDby+5rD0uFO4H1LiQ/DcLT29vqff44LJOSqVih+ERETkkpbvycexkiqolAqsf3wE2gf7yl2Sy/Cowa9ERESubt2hEjzw2S4AwNQh8QwlF2AwISIicqLXfjskPfb2ga5NYTAhIiJqQ7VmK7YeOw1DjRmLVh3CzhPlAOpDSWQg77R+IY8dY0JERCSnnNIq/OObvdh89t43DV3dNQxzb0iUoSrXx2BCRETkYB9uysHzP2Y1avf3UWNEYgQW3tYHSqV3z75pDoMJERGRA+04XmYXSnQaJVbOugallSYkRgXAz4cfvRfDs0NEROQAeWXVePmnA/hlfyEAYET3cDx7c090DK1fhbxjqJ/MFboHBhMiIqIrVGysxZ+XbEahsRYA4KdV4ZHruiE+jGGktRhMiIiIrkBpZR3+/HZ9KNGoFJiV1g1/v6YT1CpOfL0cDCZERESX6UyVCY98uRvHT1cjIsAHX9+fyks2V4jBhIiI6DIYasxIW7QOp6tMUCkVeHvyQIYSB2AwISIiaiEhBJbtPIWMnDJ8uT0PABCoU+O1if3R38vvCuwoDCZEREQttOFwKR77OtOubd6NPTCie4RMFXkeBhMiIqIWqDFZsWjVIbu2d+9OxnVJkTJV5JkYTIiIiC4hI7cMT/xvD46VViFQp8art/eDEIKhpA0wmBAREV1EbmkVJr27FSarDUpFfS/J4E6hcpflsRhMiIiILuKnvQUwWW0ID/DBO5MHcpBrG+PqL0RERM0oqajDv1ZmAwCmX9uZocQJGEyIiIiaUFlnwYOf75S2RyRy5o0zMJgQERE14dnv92PLsTLotSp88berkMD73jgFgwkREVEDdRYr5nydiWU7TwIA3puSjKs42NVpOPiViIjoLEONGSP+vRZlVSYAwH1XJ2BI5zCZq/IuTu8xKS8vR3JyMvr164devXrh3XffdXYJREREdoQQyCurxt8/3i6FkmdvTsKTY5Nkrsz7OL3HJCAgAOvXr4der0dVVRV69eqF8ePHIzSU3WRERNT2LFYbPtlyHD9k5mPniXJ0DveD1SaQe7paOuZP/WJw5+A4Gav0Xk4PJiqVCnq9HgBQV1cHIQSEEM4ug4iIvNQrvxzEuxtypO2jJVV2++eOScT913Z2dll0Vqsv5axfvx4333wzYmJioFAo8N133zU6Jj09HfHx8dDpdBg8eDC2bdtmt7+8vBx9+/ZFhw4dMGfOHISF8fodERG1jVqzFdOWZqDH07/gT+mb8P7G+lDip1Uh1E8LAOgXG4znb+mJVY9cw1Ais1b3mFRVVaFv37649957MX78+Eb7v/zyS8yePRtLlizB4MGDsXjxYowePRrZ2dmIiKifAx4cHIzMzEwUFRVh/PjxmDBhAiIjeb8BIiJyrIpaM+7773ZsOVYGAMjMKwcAjEqMwHtTkqFQKGSsjpqiEFdwHUWhUODbb7/FuHHjpLbBgwdj0KBB+M9//gMAsNlsiI2NxYMPPoi5c+c2eo4ZM2Zg5MiRmDBhQpOvUVdXh7q6OmnbaDQiNjYWBoMBgYGBl1s6ERF5uK3HTuOOd7ZI22H+Wgzs2A63J8diePcIqJQMJc5kNBoRFBR0yc9vh87KMZlM2LFjB9LS0s6/gFKJtLQ0bN68GQBQVFSEiooKAIDBYMD69evRvXv3Zp9z/vz5CAoKkr5iY2MdWTIREXkgq01gxqfnV22dNyYR25+6Dm9PTsaoHpEMJS7MocGktLQUVqu10WWZyMhIFBYWAgCOHz+Oq6++Gn379sXVV1+NBx98EL179272OefNmweDwSB95eXlObJkIiLyQLvzynH67LTf65MiMW1YgswVUUs5fVZOSkoKdu/e3eLjfXx84OPj03YFERGRx/n9YDEAYGyfaKTfOUDmaqg1HNpjEhYWBpVKhaKiIrv2oqIiREVFOfKliIiImmSoMeOLjPre9ZHdeeM9d+PQYKLVajFw4ECsXr1aarPZbFi9ejVSU1Md+VJERERNWr4nH6WVdegYqsfYPtFyl0Ot1OpLOZWVlThy5Ii0nZOTg927dyMkJARxcXGYPXs2pkyZguTkZKSkpGDx4sWoqqrCPffc49DCiYiILiSEwJdne0smpsRBp1HJXBG1VquDyfbt2zFixAhpe/bs2QCAKVOmYOnSpbjjjjtQUlKCZ555BoWFhejXrx9++eUXrlNCRERtbv3hUuw5aYBOo8TtyZzF6Y6uaB0TObR0HjQREXmXWrMVVy/8HSUVdZg6JB7P3dJT7pKoAVnWMWlL6enpSEpKwqBBg+QuhYiIXMCR4krc/cE2PPv9PhRX1OIf3+xFSUUdooN0mH19N7nLo8vEHhMiInI7NSYrejzzS5P7/jWhD/7Myzgux+N6TIiIiM7ZfKy0yfa7UzsylLg5py+wRkREdKWW7ykAALQP9sVTY3vgi4w83NArCncwlLg9BhMiInIrr/6ajW92ngIAvD6xHwZ2DMGY3lyvxFPwUg4REbmNJeuO4o019WtpRQXqMCCuncwVkaMxmBARkVs4UGDEghUHpe2FE/pAoeBdgj0NL+UQEZHLs9oExry2AQCQGBWAFQ9fzVDiodymx4TrmBARea8PN+VIjycM7MBQ4sG4jgkREbm0+T8fwNvrjwEA+sUG43/3p0Ktcpvfq+msln5+81IOERG5pMo6C+75cBsycs8AAK5LisQbE/szlHg4BhMiInIpv+wrwDc7T+HXrCKpbXz/9lh0Rz/5iiKnYTAhIiKXYLLYcKKsGg99vhsmq01qn3xVR7zwJ96Qz1swmBARkexOV9ZhzGsbUFxRJ7Vd1SkEfWOD8eh13TnY1YswmBARkSyEEFiVVYT3N+bgSHElTleZpH2Lbu+L8QM6yFgdyYXBhIiIZPGPb/fi8215dm0p8SEY3SsK4/q1l6kqkhuDCREROd323LJGocTfR433piYjUKeRqSpyBQwmRETkNIeKKnCmyiTd76ZrhD8evb4bwgN08NWoGErIfYJJeno60tPTYbVa5S6FiIguw9JNOXjuxyy7tjcnDUDXyACZKiJXxJVfiYiozQkh0O+FVTDUmKW2jqF6rH1sOGfceAmu/EpERC4jq8AohZKv/p4Ks9WGTuF+DCXUCIMJERG1CSEETpRVY8PhUiz85SCA+lk3KQkhMldGrozBhIiIHO5wUQUmvrsVpZXnF0wL8/fBs7ckyVgVuQMGEyIiuiImiw3vrD+KyjorJqbEYvPR05j7zV4AgFalRGJ0APrHBmNWWje089PKXC25OgYTIiK6bHll1bh64e/S9pJ1R+32v333QIzoHuHsssiNMZgQEdFlEULgpZ+ymtyXEh+C2wa2x/Bu4U6uitwdgwkREbVaWZUJ1yz8HZV1FgDAXVfFYVy/9jhYWIG0HpGICtLJXCG5KwYTIiJqFZtNYMCLq6TtB0Z0wWOjuwMAkuM544aujFLuAoiIyL1kF1VIj4N8NXjkum4yVkOexm2CSXp6OpKSkjBo0CC5SyEi8mprDhZLj1c/ei1USi6SRo7DJemJiKjFdp04g3uWZqC82owF43vjLylxcpdEboJL0hMRkUMdP12Fu97biiqTFe2DfTG2T7TcJZEHcptLOUREJJ/iilpMfGcLqkxWJEUH4psZQxCg08hdFnkg9pgQEdFFbcspw+1vbwYARAXqkD5pACIDOR2Y2gZ7TIiI6KIaLqL2yV8HIyHMT8ZqyNMxmBARUbMy88qx56QBALBy1jXoEuEvc0Xk6RhMiIioSUIIPPj5LgDAiO7h6B4VIHNF5A04xoSIiOzsOVmO1QeK8dPeApwoq4ZWpcTzt/SSuyzyEgwmREQEAPh1fyHmfrMXZVUmu/aHRnVBXKhepqrI2zCYEBF5ufJqE8a+vhGnymvs2q/pFo77r+mEIV3CZKqMvBGDCRGRl3theZZdKOnVPhBL70lBmL+PjFWRt3KbYJKeno709HRYrVa5SyEi8hhfbDuBb3aekrY//etgDGUPCcmI98ohIvJSQgiMXrweh4oqcUvfGLw+sb/cJZEHa+nnN6cLExF5qRX7CnGoqBI+aiVeupWzbsg1uM2lHCIicowDBUb4alR49of9AIBx/dojkPe9IRfBYEJE5EW+3XUSj3yZKW0H+Kjx9M1JMlZEZI+XcoiIvER2YQVe+DHLru3eYQnw9+HvqOQ6+K+RiMgLlFWZcPvbm2GoMUttncP9MH14ZxmrImqMwYSIyAss/SNXCiXLpqciIkCHQF8NdBqVzJUR2WMwISLycPtOGZD++xEAwL//3BcDO4bIXBFR8zjGhIjIg1msNjz9/T5YbQJDOofiT/1i5C6J6KLYY0JE5IFqTFZ8vCUXxhoLdp0oR4BOjYUT+kCj4u+j5NoYTIiIPNDSP3Lxyi8Hpe0Zw7ugQzveIZhcH6MzEZGHOX66Cp9sOS5t92ofiHuHxctXEFErsMeEiMiDLP7tEBb/dhgA4KNW4oU/9cRNfWLgo+bsG3IPDCZERB7gUFEF7npvK4or6qS2Hx8chm6RATJWRdR6DCZERG6uqs6C6/9vvV3bx9NSGErILblNMElPT0d6ejqsVqvcpRARuZRvdp6UHus0Smx4fCTCA3xkrIjo8imEEELuIlrDaDQiKCgIBoMBgYGBcpdDRORUWflG/HagCGN6ReFgYQW255bho831A11nX9cND47sAoVCIXOVRI219PPbbXpMiIi8WWWdBZPe24rMvHIAwKJVh+z2B/ioMW1YAkMJuT0GEyIiF5eVb8SNr29odr9SATx9UxL8eJdg8gD8V0xE5MI2HSnFpPe22rWl9YjEgtt6o51eC5VSgVqzlTfjI4/BYEJE5KIe/SoTyxoMbB3RPRzzbuyBLuH+UCrPX7JhKCFPwmBCRORiMvPK8af0TXZty6YPwcCO7WSqiMh5uCQ9EZGL+dfKbLvthbf1YSghr8EeEyIiF2G1CTz57V5sPFIKAHjs+m6YnBqPIF+NzJUROQ+DCRGRi/jv5lx8kZEHAGgf7IsHRnaVuSIi5+OlHCIiF/HRH7nS45fG9ZKvECIZsceEiEhmdRYr1maXIPd0NQAg89nrefmGvBaDCRGRzJ743x58tzsfANAp3I+hhLwaL+UQEcmowFAjhRIAmH5tZxmrIZIfe0yIiGS0+kAxACApOhBL7hqIuFC9zBURyYs9JkREMtmdV47Fv9XfjO+WfjEMJURgjwkRkSx2nTiD2976AzYBBOjUuCM5Vu6SiFwCgwkRkRMVGGpQUWvBjE93wibq1yt5664BaOenlbs0IpfAYEJE5CSfbDmOp77bZ9f20rhe6NMhWJ6CiFwQx5gQETlBZZ2lUSiZOiQew7uHy1QRkWtijwkRURsz1pox/s0/pO3Hru+GOwbFITzAR8aqiFyT2wST9PR0pKenw2q1yl0KEVGrfLb1BI4UVwIAnrkpCfcOS5C5IiLXpRBCCLmLaA2j0YigoCAYDAYEBgbKXQ4R0SXd+NoGZBUYMW9MIv7OBdTIS7X085tjTIiI2tCxkkpkFRihVipwO6cEE10SgwkRURv5ZMtxjHx1HQDgqk6hnBJM1AJuM8aEiMidPP/jfny4KVfa5uwbopZhMCEicqD034/gXyuzG7VPGtxRhmqI3A8v5RAROYih2txkKPnPnf3hq1XJUBGR+2GPCRGRAwghcPcHW6XtjqF6PHZ9d4xIjIC/D3/UErUU/7cQETnAj3sKkHnSAAC47+oEPDk2SeaKiNwTgwkR0RUQQqCkog5PfrNXapsyJF6+gojcHIMJEVErGarN2JZbhvWHSvDxluNSe7Begz/mjoReyx+tRJeL/3uIiFpBCIFb39yEY6VVjfbNHN6FoYToCvF/EBFRC5VVmXD9/61HaWWdXfsjad2gVStxz9B4eQoj8iAMJkREl1BRa8bh4kq7OwSnxIfguVt6okd0ABQKhYzVEXkWBhMioouoNllww+INOFVeI7VdlxSJZ25KQmyIXsbKiDwTgwkRUTOEEHj5pwN2oQSoXzDNR80F04jaAld+JSJqghACLyzPwqdbT0ChAOaM7o7ukQGYMbwzQwlRG2KPCRFRE37NKpJuwvfK+D64fVAsZo7oIm9RRF6APSZERBcQQuD11YcBAPdf2xm3D4qVuSIi78FgQkR0gTUHi7E/3wi9VoW/XdNJ7nKIvAqDCRF5rQMFRhQaahu1f7U9DwBw11UdEeKndXZZRF6NwYSIvNI3O09izGsbMPSVNVixt0Bq33XiDFbuLwIA3NArSq7yiLwWgwkReZ0jxZWYe/ame1abwK9Z9UHEbLXh483n733Tu32QLPUReTPOyiEir/PJluMwWWzS9pHiSry34Rhe+umA1LZwQh9oVPzdjcjZGEyIyGvsOF6Gz7fl4X87TgIA7k7tiP9uPo69pwzYe8ogHadWKpDWI1KuMom8GoMJEXm8Q0UVeP7H/dh05LTUFhHgg3H92+O/DS7dAEB8qB7vTRnEQa9EMmEwISKPtj23DH9+ezOEON/WJcIfL9zSE5GBOrtj1z42HLEheqiUvCkfkVwYTIjIYwkh8MSyPRACCPXT4r0pyegf107aX2u2QqtWwmSxoWdMIOLD/GSslogANwom6enpSE9Ph9VqlbsUInITv2cX42hJFQDgu5lDG90NWKdR4cOpg7D+UAmmDo2XoUIiupBCiIYdnK7PaDQiKCgIBoMBgYGBcpdDRC6qzmLF+Df/wP58I/5+TSfMu7GH3CURebWWfn5zLhwReZy8smrc9d5WaVn5+7isPJHbcJtLOUREl1JWZYKxxow7392C/LNLzT99UxLC/H1kroyIWorBhIjcns0mcLSkEuPf/AMVdRapPTEqALf2by9jZUTUWgwmROTWio21+PPbm3H8dLXUFqhT48VxvXBL3xgoFJz6S+ROGEyIyG19vDkXT3+/367tjYn9Mbx7OAJ0GpmqIqIrwWBCRG6pvNpkF0pC/LT42zWdcFOfaPaSELkxBhMicktvrDkiPe7QzhffzhiK8AAOciVydwwmROSWMnLLAACL7+iHcRzgSuQxGEyIyC18v/sUXv31EDQqBYQAjpXWr+jaPy5Y3sKIyKEYTIjIZdls9QtTK5UKvLvhGE6UVdvt79DOF7Ht9E19KxG5KQYTInJJu/PKcf/HO2Cy2jA4IQT7ThkBAMF6DXzUSoT6+eC9KclQ8k7ARB6FwYSIXNKzP+xHobF+9dYV+woBAAE+aux46jqoGEaIPBaDCRG5nKx8IzLzygEAD43qCq1KgQJDLUYmRjCUEHk4BhMicjlL1h0FANzYOwqzr+smczVE5Ey8uzARuZRCQy1+yMwHAExMiZO5GiJyNgYTInIZNpvApPe2SNu9YoJkrIaI5MBLOUQkOyEEftxTgP/+kYujJfXrk6R2CkU7P63MlRGRszGYEJHsth8/g4c+3yVtj+gejg/vSZGxIiKSC4MJEckuu7BCenxj7yg8MKKrjNUQkZwYTIhIdnln6ld0nTokHs/d0lPmaohIThz8SkSyO1lWA6B+iXki8m4MJkQku4OF9cvNdw73l7kSIpIbgwkRycpYa5Zm4vTpwOnBRN6OwYSIZPXj2cXUOoX7IdTfR+ZqiEhuDCZEJJvVB4rwwo9ZAICJg7jKKxExmBCRTGrNVjz2dSbqLDaMTIzAlCHxcpdERC6A04WJSBbvrD+GM9VmRAfp8PbkgdCo+HsSETGYEJGTfZWRh6e+3weTxQYA+MugOIYSIpLwpwEROU2t2YoXlmdJoWR8//aYPryzzFURkSthjwkROYXNJnDjaxtQWWcBAHx232AM6Rwmc1VE5GrYY0JETrEl5zSOldavVxIVqGMoIaImsceEiNqUxWrDextz8NEfuVLbtd3C5SuIiFwagwkRtan/bj6OBSsOSttXdw3DP8b2kLEiInJlDCZE1GY+3XocLyzPkrYnDOyAf/+5r4wVEZGrYzAhojZxqrwGT3+3T9pe/uAw9IwJlLEiInIHDCZE5DB5ZdV45ZeDuKZbOIw1ZthEffvOp69DiJ9W3uKIyC0wmBCRwzz9/T6szS7B8j0FUttDI7swlBBRi3G6MBE5hNlqw9ZjZY3a70jhzfmIqOUYTIjIIfadMqDGbIVWrURiVAAAYOk9g9A+2FfmyojInfBSDhE5REZufW/Jtd3C8cbE/rDYBPx9+COGiFqHPzWIyCG25dQHk5T4EOg0KpmrISJ3xUs5RHTFbDaBjNwzAICUhBCZqyEid+b0YJKXl4fhw4cjKSkJffr0wddff+3sEojIwXblnYGhxowAHzXXKiGiK+L0SzlqtRqLFy9Gv379UFhYiIEDB+LGG2+En5+fs0shIgdZtvMUAGBUjwioVeyIJaLL5/RgEh0djejoaABAVFQUwsLCUFZWxmBC5KZeX30Yn209AQC4fVCszNUQkbtr9a8269evx80334yYmBgoFAp89913jY5JT09HfHw8dDodBg8ejG3btjX5XDt27IDVakVsLH+YEbmj0so6vLb6MADgjuRYpHYKlbkiInJ3rQ4mVVVV6Nu3L9LT05vc/+WXX2L27Nl49tlnsXPnTvTt2xejR49GcXGx3XFlZWW4++678c4771xe5UQku+WZ+bDaBJKiA/HKhD5QKBRyl0REbq7Vl3LGjBmDMWPGNLt/0aJFuO+++3DPPfcAAJYsWYKffvoJH3zwAebOnQsAqKurw7hx4zB37lwMGTLkoq9XV1eHuro6adtoNLa2ZCJqI9/uzgcA/Dm5g8yVEJGncOgoNZPJhB07diAtLe38CyiVSEtLw+bNmwEAQghMnToVI0eOxOTJky/5nPPnz0dQUJD0xcs+RPITQuDzbSeQmVcOlVKBm/rEyF0SEXkIhwaT0tJSWK1WREZG2rVHRkaisLAQALBp0yZ8+eWX+O6779CvXz/069cPe/fubfY5582bB4PBIH3l5eU5smQiugwfbMrFvG/q/9+O6RWF8AAfmSsiIk/h9Fk5w4YNg81ma/HxPj4+8PHhDz0iV2Gy2LD4t0MAgAkDO+DZm5NkroiIPIlDg0lYWBhUKhWKiors2ouKihAVFeXIlyIimRwtqURFrQUBPmosvK0PlEoOeCUix3HopRytVouBAwdi9erVUpvNZsPq1auRmprqyJciIhmsP1SCMa9tAAAkRgcwlBCRw7W6x6SyshJHjhyRtnNycrB7926EhIQgLi4Os2fPxpQpU5CcnIyUlBQsXrwYVVVV0iwdInJPO0+cwd0fnF+TqGdMkIzVEJGnanUw2b59O0aMGCFtz549GwAwZcoULF26FHfccQdKSkrwzDPPoLCwEP369cMvv/zSaEAsEbmPilozxr/5h7R9U59ozErrKmNFROSpFEIIIXcRLZGeno709HRYrVYcOnQIBoMBgYG8WRhRW9p3yoDpn+5AdKAvtuWWAQBeHNcLk6/qKHNlRORujEYjgoKCLvn57TbB5JyWvjEiujLFxlqk/HN1o/b9z4+Gn4/TJ/QRkZtr6ec3bwNKRE165vv9dttqpQIZT6YxlBBRm+JPGCJqZH++Ab/sL5S2h3YJxV8GxXEhNSJqcwwmRNTI+xtzpMfLpqdiYMcQGashIm/CYEJEkv+sOYx//3pI2v76foYSInIujjEhIgBArdmKV1cdsmsbENdOpmqIyFsxmBARACCntAoN5+gtf3AYVFzZlYiczG0u5TRcx4SIHO9YSRUAoH9cML6dMVTmaojIW7lNj8nMmTORlZWFjIwMuUsh8jgVtWbM/GwnAKBbRIDM1RCRN3ObYEJEbeeHzHzpcWrnUBkrISJvx2BC5OWEEMjMK5e2R/WIkK8YIvJ6DCZEXu6NNUfw1faTAIDFd/RDgE4jc0VE5M0YTIi83LKd9aFErVTg+p68CzgRyYvBhMiLnThdjeOnqwEAO566Dnqt20zUIyIPxWBC5MVW7CsAAAzpHIogPS/hEJH8GEyIvNieUwYAwLXdwmWuhIioHvttm1BnsUIIwEethELBlS/Jcx0/Xb+oWqdwf5krISKq5zbBpK1Xft2WPg29Sn6EGRqYhRImqGEWaijUGqjUPqixKlBjU0Gn08HXRweFWovgAD30vr5QKDWASguoNGe/tIBSfbZNC6jOPlZqGh+jVJ39U31+W6G64Hmae3z2NZUaQMnOL2qdZ77fh32njACA+FC9zNUQEdVzm2Ayc+ZMzJw5E0ajEUFBQQ5/foW5GnrUAagDznWSKADYAJgaHFhz9gsASh1exuVTqM4Hl3Mh51xoUZ0LPRc+1pwNRpqmv0+pauax+uzzNPV9Fz7WnD+22WOaq1UDKJQAe60cqqzKhKEL1qDGXB/ywwN8EMdgQkQuwm2CSVuLv/NV5BqehNVsQjudAgqbGfmnjaisrsbJ00aE6RTwUVpRUFaBUmMlis5UoLK6BhpYoIEVGljgo7ShW5gWEX4qROqV0CgsUNgsCNIK6FUCsJrqv2yW83/arGf/tJzftprPPjbXPz73ZWvw54WEFbBaAWud809eW2tRcFJfEIAuNzhdLERd8JrNhbxLBrBzryFPL9fK/YVSKAGAz+8bDB+1SpZaiIgupBCi4f1EXd+5HhODwYDAwEBZazHUmJGZV45fswrx6/4iFFc0Hwo0KgVu6dseKQntEBuih16rhhACfToEt/4OrkKcDTfmxkFHCjVNPTY3CD5n91kbBKBmv+/cMZZmHl/ma174+sLbbtCouESwaqKX65LhqWHv04XbatQJFV5ZeQRmqGCBCnPG9EJIgN8FQa6ZsHbhPtWFNZwNZ+zhIqImtPTzm8HEgTJyy/DbgSLsP2XEyTPVOFVegw7t9MgprWr2e7QqJaYOjUdq51CYLTZEBOoQqFOjY6if991yvmHgumQwOht4GvYi2QWgi4WhJp6/xa/T3Gs2UW/DGoRN7rPrPC0KMRcPUK0LRc30kjX3/C0+9mydDFpEDsFg4gJMFhu0aiX25xuQXViBPScN2HniDPadMsB2ibPup1VhVI9I9G4fhJv7xiAqSOecoqlt2GwNLtddJPxcstfLgkY9Uk2Frgv3Wc04edqIrUeLoIEVgVoFru0SDEWT33PBdsOAZdfD1sQlRU+kbC7ENDdW6xIBSqmCNMhdGvCubLCv4fdr7Z+r4SD4c8dJA+svCHHKC8edNbjUKL0uQxc5D4OJCzPWmqFSKFBlsuB/O05i14lyHC2phK9GhbIqE05XmmCy2v+GPbRLKG7uE4NQfx/kllZhbJ9oRAbqvK9XhS7bTW9swL5TRigU9au8hvhpr+wJhbigB6mZwNTktvUi+xqGoiYuN7YoQDUf0C5aJ9zqx+GVU6hgNzPQLiCpG+y/YPZgk71bTQW3VvSYNfUczfaaXTA+rMkxYBoGLxfDYOLGas1WbMspw9rsEqzYV4ACQ22TxwXq1Jg4OA5pPSIxIK4dQwo1q7iiFikvr3ZcKPFUjcKNtWWhqKkxV00ea6kfS2U793Xh9oVhzNT08zV8XavpgsdNDKr3uvFbZ104W9GRoampWY1NDapvdvZhawPduedx36UhGEw8yOGiCvzfb4eQW1qNQ0UVsDRxHSjIVwOFAugXG4z7ru6EIF8NukT4Q6fhbAsCfssqwl//ux1dI/yxava1cpdDzmaznQ1ADS8JngtC1mbCkuX8JUjRIOg02YPV8BLlJXqmmr3k2NzztvA5vGUcl0J56cDjiNCUOBZoP8Chpbf081vt0FelNtE1MgBvThoobVttAqcr6/Dz3gKsyS7BruNnYKipv96/NrsEa7NLAAB6rQo39IpC57Oreob5azEoPoSrfHqZOosVMz7bCQDoHxcsbzEkD6USgLL+w0fjK3c1bUMax+Ws0NTM5cNmx2010/t2sdmRTfV0CRtgrUObLw0RHOfwYNJSDCZuSKVUICJQh6lDEzB1aAIMNWZ8se0EMk+WA6gPJ9UmK6pNVnyz81Sj7x+ZGIF+scHoGKrH8O4RCPLVOPkdkDMt23EKJkv9b5Pj+rWXuRqiNqJUAkotAA+6TNkobDU1Nqup4HWxMVcXhrJmQlNEkmxv222CSVsvSe/Ognw1+Pu1ne3aqk0WrD5QjKMllVhzsBh7ThqkfWsOFmPNwWK74xff0Q9jekdBpVBArVLCUG2GTQi041gEt7f+UH0PWqdwP6R2DpW5GiJqMU8MWy3AMSZeQgiB46erseP4GTz53V7Umpu/HhuoU6OizgIhgDmju2PKkHj4+7hNhqUGrDaB/i/8CmOtBd/MGIIBce3kLomIvBTHmJAdhUKB+DA/xIf54epuYSirMiE60BeLVx/CukMlqKqzoMhYf83SWGuRvu9fK7PxzvpjuLZbOGaldeX4FDezP98AY60FATo1+rR3/D2miIgcjcHEC0UE6BARUL9g27M39wRQ/5v11pzTqK6zotBYCwFgeWY+tuaUwVBjxg+Z+fghMx/r5gxHx1A/Gaun1th7qv4SXr/YYKhV7jvNkIi8B4MJAagfUDukc5hd2+SrOsJitWHZzpN4YtleAMDNb2xEv7h2OHWmGpV1Fowf0AG1ZisSwvxgtgpMGhzHKcou5GBBBQAgKZqXPYnIPTCY0EWpVUrcMSgOwXotHv0qE8ZaizSYEgDeWnvU7vjNR0uRGBWIrAIjEqMCYLUJVNZZcHXXcFyfFAklF4Fzqs3HTgMAevEyDhG5CQ5+pRYz1prx054CqBQKCAi8vzEH+eW1qKyzwE+rQpXp4jOmru0WjnfuHggfNXtUnCG3tArD/70WGpUCO56+DoE6TgsnIvlw8Cs5XKBOg4kpcdL2HYPqH9tsAkqlAr9lFeGN348gM6+8ye9fd6gE3Z/6Be/enYxhXcLgq2VAaUtbc+p7S/rHtWMoISK3wWBCV+zc5Zm0pEikJUVCCAGrTaCqzoogvQZCCCz+7TBeW30YAHDff7cDAMb2ica8MYloH+yLOouNY1McbOfxcgBAckdOESYi98FgQg6nUCigVikQpFdK249c1w0nz9Rg2c6T0nE/7SnAxsOl6NMhCDuPn8GY3tHoGROIqUPioeBdQa/YkZJKAEAiB74SkRvhGBNymhqTFTmlVRAQeGf9MXy/O/+ixw9OCMErt/WBxWZD53B/hpUWMltt0KiU6P/CrzhTbcZPDw1DzxgOfiUiefHuwuTyDhQY8Zd3tkg3ILyY52/piSlD4mGx2rgex0WsOViEBz/bhWC9FqfKa6BUAPufv4HjeYhIdhz8Si6vR3Qglj84DCv3F2JkYgRC/LRY+kcuPtyU2yisvL76MLpFBuDuD7Zi5ogumJXWTaaqXdu/Vx5ClcmKKlMNgPqZUAwlRORO3KbHpOFN/A4dOsQeEw9WXm3CwcIK/HH0NF4/O2D2QuvmDEdsOz3XRWmgxmRFr+dWwmoTCNCp4aNWYuk9KVzDhIhcAi/lkEcorqjFW2uP4sNNuU3uv//aznjihu4cf4L6uwjf/cE2RAT4YPO8UbAJAQ0vexGRi2jp5zd/apFLiwjQ4amxSdg0dyRu6BnVaP+SdUexfE+BDJW5ni8z8gAA1/eMhEqpYCghIrfEn1zk8lRKBdoH+2LJ5IHIXTAWM0d0ttv/1fY82Gxu1fHncN/uOomf9tYHtNsGdJC5GiKiy8fBr+R25oxOxH1Xd8JV81ej1mzDhsOleGvdUVzbLRwTlvyBrhEB6B4VgJggHR65rptXXOZZnlkfSnQaJfrFBstbDBHRFWCPCbmlYL0WB164Af4+9dn6483HcdMbG1FrtmHvKQP+t+MkXl9zBKsPFMtcqXPsPWUAAHwybbBXBDEi8lwMJuS2FAoFtvxjFJQKoNBY2+Qxf/3vduw4XiZtFxlrsXJ/IawedOmnpKIOxRV1UCiApBgOCCci98ZgQm7N30eNu1PjpW2tWokldw3E2seGS21bjpXBZhOoNVsxYckf+PvHO7Dwl4POL7aNHCw0AgASQv2g1/LqLBG5N/4UI7f39E1JuL5nJGLb6REbopfa707tiP9uPo5/rczGD7vzkV1UIe17e/0xXN01HMO6hslRskNlF9a/r+5RATJXQkR05dhjQm5PpVRgSOcwu1ACAAMb3FW3YSg55673t+LHzIvfr8fVGWrMeOmnAwCAxChexiEi98dgQh5rUHxIo7bO4X7oHnm+Z+HBz3chK9/ozLIc6uPNudLj7lH+8hVCROQgvJRDHism2BdZL4xGdmEFlqw7iokpcbiqUyjqLDY8/8N+fLPrFADgxz35bjdo1GSx4f9+O4S31h6V2vrHtbvIdxARuQcuSU9e68NNOXj+xywAwK392+Olcb3g5+P6Wd1itWH4v9fi5JkaqW3qkHg8d0tPGasiIro4LklPdAldIs5f+vh21ylc+6+1bjGNOO9MjV0oAYDRTSzXT0TkjhhMyGtdOIultLIOvx0okqmalitusGaLTqPEtd3CkZLQeDwNEZE7YjAhrxURoMOzNyfZtf394x34dX+hTBW1TFFFHQBgcEIIdj9zPZbeMwgqJVd7JSLP4DbBJD09HUlJSRg0aJDcpZAHuWdoAnIXjMX88b2ltr99vAM3vbEBeWXVMlbWNJtNYO6yPQCAyEAddBoVl6AnIo/iNsFk5syZyMrKQkZGhtylkAeamBKHuWMSpe19p4z4z5ojMlbUtB8y81FtsgIAOrTzlbkaIiLHc5tgQtTW7ru6ExIbjDtZk12MZTtOIvml37DuUImMlZ23/nB9HT5qJe4dliBzNUREjsdgQnSWSqnAp38djKdvSoJaqUBJRR0e/ToTpZV1SHeB3hMhBLbnngEALLlrIML8fWSuiIjI8RhMiBoI9ffBtGEJGNe/vV37ttwylJwddCqXt9YdxYmyaviolUiO52JqROSZGEyImtAtsvHy7rO/2u38Qhr4dmf9SrWD4kMQoNPIWgsRUVthMCFqwnVJjRcs23C4FFuOnZahmnqFhvr1Sy6c4kxE5EkYTIiakBDmh9wFY3H45TEIDzg/luOvH22HxWpzej0VtWZU1FkA1N8DiIjIUzGYEF2ERqXE139PlbYr6yzYcLjU6XUUnV3tNUCndov7+RARXS4GE6JLiA/zw/IHhyElvn7Z95UyrAx77t44MUHsLSEiz8ZgQtQCvdoH4fqekQCALzLyMPn9rVj0a7bTXv9YSRWA+ktMRESejMGEqIUaTiHecLgUr685AqtNwFBthhBte1fiY6WVAICEcAYTIvJsDCZELRTm74N+scF2bd/tOoV+L/6Kxb8dbtPXzi6sAAB0CW88jZmIyJMwmBC1QsMZOgDw6NeZEAJ4bXXbBZOc0ipknF3xtX9ccJu9DhGRK2AwIWqFiIDml4G32trmcs65mwmG+mk5xoSIPB6DCVErxIbom9234XDb3Ohvx/EyAMDs67tBoVC0yWsQEbkKLohA1Ap3Do5DndmGsAAtakxWvPTTAWnfir3104g3Hi7FE2MSoVFdee43VJuRe7oaAHBT75grfj4iIlfHYELUCoE6DR5O6wqg/m6/a7NLsPFI/YJr+/IN+HJ7HgAgLlSPu1Pjr/j1zs3GiQz0QZCe98chIs/HSzlEl0mhUOD9qclY/uAwAMD+fKO0b+9JA8wOWLo+p5TrlxCRd2EwIboCPmoVekQHNmr/esdJ9H5uJTZe4fL154MJpwkTkXdwm2CSnp6OpKQkDBo0SO5SiOyolAo8NLJLo/Zas+2Kl68/djaYdGKPCRF5CbcJJjNnzkRWVhYyMjLkLoWokYfTumHO6O6N2ksr667oeXO4FD0ReRm3CSZErkylVGDmiC54c9IAu/ZzdwW+HNUmC46WcCl6IvIuDCZEDnRj72j8+sg1aB9cfxfgIuPl95isOViMOosNcSF6XsohIq/BYELkYN0iA/DV/akAgOKK2su+wd+5gbOje0ZyYTUi8hoMJkRtINy/ful6s1XgTLW51d9faKjFN7tOAQCu6hTq0NqIiFwZgwlRG9CqlQj10wIADhVV4PH/ZSL99yMt7j3ZeKQUJosNMUE6XNMtvC1LJSJyKVz5laiNRATqcLrKhL+8s0VqG9UjAolRjdc9udCpMzUAgGu6hTtkaXsiInfBn3hEbSQysPGdiOd9sxeVdZZLfu/JM/X3x+nQztfhdRERuTIGE6I20rGJOxHvOlGOF3/MuuT3niqv7zFpz2BCRF6GwYSojUQE6pps/2pHnt12ebUJt/xnI95Zf1RqK6mon2YcGdD0cxAReSoGE6I2ckvfGCjPzvJtuHLrheNfP9iUiz0nDfjnzwelttNVJgBAqH/jy0FERJ6Mg1+J2khsiB6b542CXqvC8dPVuOmNjU0eV15tstu2WG04c7Yt5OzMHiIib8FgQtSGIs9ezokKsr8kU15tgkalhJ+PGrYGXSjVJguq6qwQAlAogHZ6jVPrJSKSGy/lEDlBmL8P/josQdp+5vv96P3cSry19igqas/P0impqMPpqvrxJe30Wqg5VZiIvAx7TIic5KmbklBttuKzrSfwQ2Y+AOCVXw5iQFywdMynW09IS9FHNTN4lojIkzGYEDlRREDjwaw7T5RLj99Zf0x63DnC3xklERG5FPYTEzlRZCt6QTqH847CROR9GEyInMhH3fR/ubQeEXbb4QE+uC4p0hklERG5FF7KIXKiUYmRUCkVsNrOz8RJiQ/Bu3cnQ6FQyFgZEZFrYDAhcqIgvQZH/3kjAGDTkVJU1FpwQ68omasiInIdDCZEMhnaJUzuEoiIXA7HmBAREZHLYDAhIiIil8FgQkRERC6DwYSIiIhcBoMJERERuQwGEyIiInIZDCZERETkMtwmmKSnpyMpKQmDBg2SuxQiIiJqIwohhLj0Ya7DaDQiKCgIBoMBgYGBcpdDRERELdDSz2+36TEhIiIiz8dgQkRERC6DwYSIiIhcBoMJERERuQy3u7vwubG6RqNR5kqIiIiopc59bl9qzo3bBZOKigoAQGxsrMyVEBERUWtVVFQgKCio2f1uN13YZrMhPz8fAQEBUCgUDnteo9GI2NhY5OXlcRpyG+O5dg6eZ+fgeXYenmvnaKvzLIRARUUFYmJioFQ2P5LE7XpMlEolOnTo0GbPHxgYyH/wTsJz7Rw8z87B8+w8PNfO0Rbn+WI9Jedw8CsRERG5DAYTIiIichkMJmf5+Pjg2WefhY+Pj9yleDyea+fgeXYOnmfn4bl2DrnPs9sNfiUiIiLPxR4TIiIichkMJkREROQyGEyIiIjIZTCYEBERkctgMDkrPT0d8fHx0Ol0GDx4MLZt2yZ3SW5l/vz5GDRoEAICAhAREYFx48YhOzvb7pja2lrMnDkToaGh8Pf3x2233YaioiK7Y06cOIGxY8dCr9cjIiICc+bMgcViceZbcSsLFiyAQqHArFmzpDaeZ8c4deoU7rrrLoSGhsLX1xe9e/fG9u3bpf1CCDzzzDOIjo6Gr68v0tLScPjwYbvnKCsrw6RJkxAYGIjg4GBMmzYNlZWVzn4rLstqteLpp59GQkICfH190blzZ7z44ot291Lheb4869evx80334yYmBgoFAp89913dvsddV737NmDq6++GjqdDrGxsVi4cOGVFy9IfPHFF0Kr1YoPPvhA7N+/X9x3330iODhYFBUVyV2a2xg9erT48MMPxb59+8Tu3bvFjTfeKOLi4kRlZaV0zP333y9iY2PF6tWrxfbt28VVV10lhgwZIu23WCyiV69eIi0tTezatUv8/PPPIiwsTMybN0+Ot+Tytm3bJuLj40WfPn3Eww8/LLXzPF+5srIy0bFjRzF16lSxdetWcezYMbFy5Upx5MgR6ZgFCxaIoKAg8d1334nMzExxyy23iISEBFFTUyMdc8MNN4i+ffuKLVu2iA0bNoguXbqIiRMnyvGWXNLLL78sQkNDxfLly0VOTo74+uuvhb+/v3jttdekY3ieL8/PP/8snnzySfHNN98IAOLbb7+12++I82owGERkZKSYNGmS2Ldvn/j888+Fr6+vePvtt6+odgYTIURKSoqYOXOmtG21WkVMTIyYP3++jFW5t+LiYgFArFu3TgghRHl5udBoNOLrr7+Wjjlw4IAAIDZv3iyEqP+PpFQqRWFhoXTMW2+9JQIDA0VdXZ1z34CLq6ioEF27dhWrVq0S1157rRRMeJ4d44knnhDDhg1rdr/NZhNRUVHiX//6l9RWXl4ufHx8xOeffy6EECIrK0sAEBkZGdIxK1asEAqFQpw6dartincjY8eOFffee69d2/jx48WkSZOEEDzPjnJhMHHUeX3zzTdFu3bt7H5uPPHEE6J79+5XVK/XX8oxmUzYsWMH0tLSpDalUom0tDRs3rxZxsrcm8FgAACEhIQAAHbs2AGz2Wx3nhMTExEXFyed582bN6N3796IjIyUjhk9ejSMRiP279/vxOpd38yZMzF27Fi78wnwPDvKDz/8gOTkZPz5z39GREQE+vfvj3fffVfan5OTg8LCQrvzHBQUhMGDB9ud5+DgYCQnJ0vHpKWlQalUYuvWrc57My5syJAhWL16NQ4dOgQAyMzMxMaNGzFmzBgAPM9txVHndfPmzbjmmmug1WqlY0aPHo3s7GycOXPmsutzu5v4OVppaSmsVqvdD2kAiIyMxMGDB2Wqyr3ZbDbMmjULQ4cORa9evQAAhYWF0Gq1CA4Otjs2MjIShYWF0jFN/T2c20f1vvjiC+zcuRMZGRmN9vE8O8axY8fw1ltvYfbs2fjHP/6BjIwMPPTQQ9BqtZgyZYp0npo6jw3Pc0REhN1+tVqNkJAQnuez5s6dC6PRiMTERKhUKlitVrz88suYNGkSAPA8txFHndfCwkIkJCQ0eo5z+9q1a3dZ9Xl9MCHHmzlzJvbt24eNGzfKXYrHycvLw8MPP4xVq1ZBp9PJXY7HstlsSE5Oxj//+U8AQP/+/bFv3z4sWbIEU6ZMkbk6z/HVV1/h008/xWeffYaePXti9+7dmDVrFmJiYnievZjXX8oJCwuDSqVqNGuhqKgIUVFRMlXlvh544AEsX74cv//+Ozp06CC1R0VFwWQyoby83O74huc5Kiqqyb+Hc/uo/lJNcXExBgwYALVaDbVajXXr1uH111+HWq1GZGQkz7MDREdHIykpya6tR48eOHHiBIDz5+liPzeioqJQXFxst99isaCsrIzn+aw5c+Zg7ty5+Mtf/oLevXtj8uTJeOSRRzB//nwAPM9txVHnta1+lnh9MNFqtRg4cCBWr14ttdlsNqxevRqpqakyVuZehBB44IEH8O2332LNmjWNuvcGDhwIjUZjd56zs7Nx4sQJ6TynpqZi7969dv8ZVq1ahcDAwEYfEt5q1KhR2Lt3L3bv3i19JScnY9KkSdJjnucrN3To0EbT3Q8dOoSOHTsCABISEhAVFWV3no1GI7Zu3Wp3nsvLy7Fjxw7pmDVr1sBms2Hw4MFOeBeur7q6Gkql/ceQSqWCzWYDwPPcVhx1XlNTU7F+/XqYzWbpmFWrVqF79+6XfRkHAKcLC1E/XdjHx0csXbpUZGVlib/97W8iODjYbtYCXdz06dNFUFCQWLt2rSgoKJC+qqurpWPuv/9+ERcXJ9asWSO2b98uUlNTRWpqqrT/3DTW66+/XuzevVv88ssvIjw8nNNYL6HhrBwheJ4dYdu2bUKtVouXX35ZHD58WHz66adCr9eLTz75RDpmwYIFIjg4WHz//fdiz5494k9/+lOT0y379+8vtm7dKjZu3Ci6du3q9dNYG5oyZYpo3769NF34m2++EWFhYeLxxx+XjuF5vjwVFRVi165dYteuXQKAWLRokdi1a5c4fvy4EMIx57W8vFxERkaKyZMni3379okvvvhC6PV6Thd2lDfeeEPExcUJrVYrUlJSxJYtW+Quya0AaPLrww8/lI6pqakRM2bMEO3atRN6vV7ceuutoqCgwO55cnNzxZgxY4Svr68ICwsTjz76qDCbzU5+N+7lwmDC8+wYP/74o+jVq5fw8fERiYmJ4p133rHbb7PZxNNPPy0iIyOFj4+PGDVqlMjOzrY75vTp02LixInC399fBAYGinvuuUdUVFQ48224NKPRKB5++GERFxcndDqd6NSpk3jyySftpp/yPF+e33//vcmfyVOmTBFCOO68ZmZmimHDhgkfHx/Rvn17sWDBgiuuXSFEgyX2iIiIiGTk9WNMiIiIyHUwmBAREZHLYDAhIiIil8FgQkRERC6DwYSIiIhcBoMJERERuQwGEyIiInIZDCZERETkMhhMiIiIyGUwmBAREZHLYDAhIiIil8FgQkRERC7j/wHGUUpI3vR4FAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import jax\n",
    "import chex\n",
    "from functools import partial\n",
    "\n",
    "n_step = 10000\n",
    "\n",
    "\n",
    "def make_generalized_operator(mdp: MDP, otimes):  # T_tです\n",
    "    # K_tを生成します。今回は一定です。\n",
    "    S, A = mdp.S, mdp.A\n",
    "    Phi = mdp.phi.reshape(S*A, -1)\n",
    "    K_t = Phi @ Phi.T\n",
    "    chex.assert_shape(K_t, (S*A, S*A))\n",
    "    S, A = mdp.S, mdp.A\n",
    "    P = mdp.P.reshape(S*A, S)\n",
    "    P_choice = partial(jax.random.choice, a=mdp.S_array, shape=(1,), replace=True, axis=0)\n",
    "    P_choice = jax.vmap(P_choice)\n",
    "    rew = mdp.rew.reshape(S*A)\n",
    "    gamma = mdp.gamma\n",
    "\n",
    "    @jax.jit\n",
    "    def generalized_operator(key: jax.random.PRNGKey, t: int, Q: np.ndarray):\n",
    "        Q = Q.reshape(S*A)\n",
    "\n",
    "        # alpha_tを設定します。今回は0.1で固定してみます。\n",
    "        alpha_t = 0.1  # 1 - t / n_step\n",
    "\n",
    "        # D_tを生成します。今回は一様分布からサンプルします。\n",
    "        key, new_key = jax.random.split(key)\n",
    "        sa_dist = jax.random.uniform(new_key, shape=(S*A,), minval=0, maxval=1)\n",
    "        sa_dist = sa_dist / sa_dist.sum()\n",
    "        D_t = jnp.diag(sa_dist)\n",
    "        chex.assert_shape(D_t, (S*A, S*A))\n",
    "\n",
    "        # P_tを生成します。今回はQ学習と同じように一点だけ1にします。\n",
    "        key, *new_key = jax.random.split(key, num=(S*A + 1))\n",
    "        new_key = jnp.array(new_key)\n",
    "        P_t = jnp.zeros((S*A, S))\n",
    "        nS = P_choice(key=new_key, p=P).reshape(S*A)\n",
    "        chex.assert_shape(nS, (S*A,))\n",
    "        P_t = P_t.at[np.arange(S*A), nS].add(1)\n",
    "        # assert jnp.all(P_t.sum(axis=1) == 1.0)\n",
    "        chex.assert_shape(P_t, (S*A, S))\n",
    "\n",
    "        V = otimes(Q.reshape(S, A))\n",
    "        chex.assert_shape(V, (S,))\n",
    "        next_v = P_t @ V\n",
    "        chex.assert_shape(next_v, (S*A,))\n",
    "\n",
    "        result = Q + alpha_t * K_t @ D_t @ (rew + gamma * next_v - Q)\n",
    "        chex.assert_shape(result, (S*A,))\n",
    "        return key, result\n",
    "\n",
    "    return generalized_operator\n",
    "\n",
    "\n",
    "def do_generalized_RL(mdp: MDP, operator):\n",
    "    suboptimality = []\n",
    "    S, A = mdp.S, mdp.A\n",
    "    Q = np.zeros(S*A)\n",
    "    key = jax.random.PRNGKey(0)\n",
    "\n",
    "    for t in range(1000):\n",
    "        key, Q = operator(key, t, Q)\n",
    "        suboptimality.append(np.abs(mdp.optimal_Q - Q).max())\n",
    "    return suboptimality\n",
    "\n",
    "max_operator = partial(jnp.max, axis=1)\n",
    "\n",
    "S = 5\n",
    "A = 2\n",
    "d = S*A\n",
    "random_phi = np.random.randn(S, A, d)  # ランダムな特徴ベクトル\n",
    "mdp = MDP(S_array, A_array, gamma, horizon, rew, P, random_phi)\n",
    "mdp = mdp._replace(optimal_Q=compute_optimal_Q(mdp).reshape(S*A))\n",
    "operator = make_generalized_operator(mdp, max_operator)\n",
    "suboptimality = do_generalized_RL(mdp, operator)\n",
    "plt.plot(suboptimality, label=\"random\")\n",
    "\n",
    "onehot_phi = np.eye(S*A).reshape(S, A, d)  # one-hot 特徴ベクトル\n",
    "mdp = MDP(S_array, A_array, gamma, horizon, rew, P, onehot_phi)\n",
    "mdp = mdp._replace(optimal_Q=compute_optimal_Q(mdp).reshape(S*A))\n",
    "operator = make_generalized_operator(mdp, max_operator)\n",
    "suboptimality = do_generalized_RL(mdp, operator)\n",
    "plt.plot(suboptimality, label=\"onehot\")\n",
    "\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "これで行列形式でQ学習の実験もできますね。素晴らしい。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('shumi-VTLwuKSy-py3.9')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "d6b7cac5e0d2ff733f340da4d53ae5ecfef7f7ad39623f5982b029a09306b36b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}