notebooks/RL_Exercise_DP.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# はじめに\n",
        "\n",
        "参考文献：\n",
        "* マルコフ決定過程やベルマン方程式の話：https://www.amazon.co.jp/dp/4065155916\n",
        "* マルチステップ方策評価：https://www.jstor.org/stable/2630487\n",
        "* マルチステップ方策更新：https://arxiv.org/abs/1802.03654\n",
        "\n",
        "このノートブックでは，テーブルマルコフ決定過程の実装と，そこでのアルゴリズムについて詳しく学びます．\n",
        "\n",
        "多くの逐次意思決定問題の目標は，その問題における最適な意思決定のルール（方策）を獲得することです．\n",
        "例えばゲームではプロプレイヤー並みの性能が欲しかったり，将棋では人類の誰よりも強い将棋ソフトが欲しくなったりします．\n",
        "\n",
        "最適方策はどうやってもとめれば良いでしょうか？\n",
        "一般の逐次意思決定問題を考えると非常に難しいため，基本的には，**マルコフ決定過程**に問題設定を限定することで簡単なアルゴリズムを導出することが多いです．\n",
        "\n",
        "まずはマルコフ決定過程を実装してみましょう．特に，最も簡単なマルコフ決定過程である**テーブルマルコフ決定過程**を実装します．\n"
      ],
      "metadata": {
        "id": "ajI_sxZi3LGX"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WXTfSrtiy7f6"
      },
      "source": [
        "# テーブルマルコフ決定過程を実装しよう\n",
        "まず，授業のスライドに従って，テーブルマルコフ決定過程を実装しましょう．定義を思い出してください．\n",
        "\n",
        "1. 有限状態集合: $S=\\{1, \\dots, |S|\\}$\n",
        "2. 有限行動集合: $A=\\{1, \\dots, |A|\\}$\n",
        "3. 遷移確率行列: $P\\in \\mathcal{R}^{S\\times A\\times S}$\n",
        "4. 報酬行列: $r\\in \\mathcal{R}^{S\\times A}$\n",
        "5. 初期状態: $s_0 \\in S$\n",
        "\n",
        "これを実装してみましょう。報酬行列と遷移確率行列はランダムに生成してみます。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NUL7MMBjy7f7",
        "outputId": "62455f1d-18d2-4f88-fbc5-8dca4d128618"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "報酬関数のshape (3, 2)\n",
            "遷移確率行列のshape (3, 2, 3)\n",
            "初期状態 0\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "from dataclasses import dataclass\n",
        "\n",
        "_S = 3  # 状態集合のサイズ\n",
        "_A = 2   # 行動集合のサイズ\n",
        "_S_set = np.arange(_S)  # 状態集合．初期状態は_S_set[0]とします．\n",
        "_A_set = np.arange(_A)  # 行動集合\n",
        "\n",
        "# 報酬行列を適当に作ります\n",
        "_rew = np.random.rand(_S, _A)\n",
        "assert _rew.shape == (_S, _A)\n",
        "\n",
        "# 遷移確率行列を適当に作ります\n",
        "_P = np.random.rand(_S*_A, _S)\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",
        "\n",
        "\n",
        "# 状態集合, 行動集合, 割引率, 報酬行列, 遷移確率行列が準備できたのでマルコフ決定過程（MDP）のクラスを作ります\n",
        "@dataclass\n",
        "class MDP:\n",
        "    S_set: np.array  # 状態集合\n",
        "    A_set: np.array  # 行動集合\n",
        "    rew: np.array  # 報酬行列\n",
        "    P: np.array  # 遷移確率行列\n",
        "\n",
        "    @property\n",
        "    def S(self) -> int:  # 状態空間のサイズ\n",
        "        return len(self.S_set)\n",
        "\n",
        "    @property\n",
        "    def A(self) -> int:  # 行動空間のサイズ\n",
        "        return len(self.A_set)\n",
        "\n",
        "    @property\n",
        "    def s0(self) -> int:  # 初期状態\n",
        "        return self.S_set[0]\n",
        "\n",
        "\n",
        "mdp = MDP(_S_set, _A_set, _rew, _P)\n",
        "print(\"報酬関数のshape\", mdp.rew.shape)\n",
        "print(\"遷移確率行列のshape\",mdp.P.shape)\n",
        "print(\"初期状態\", mdp.s0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rr_r0ILMy7f8"
      },
      "source": [
        "これでマルコフ決定過程が定義されました！\n",
        "試しに状態遷移確率や報酬関数の値を確認してみましょう．例えば$s, a$の次状態の確率分布：\n",
        "\n",
        "$$P(\\cdot |s, a)$$\n",
        "\n",
        "は``mdp.P[s, a]``を参照すれば得られます。"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jekFpcJwy7f8",
        "outputId": "96c5e30d-e4f2-4206-db95-6fdf2a6a2811"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.45987988 0.25631447 0.28380565]\n",
            "1.0\n"
          ]
        }
      ],
      "source": [
        "s = 2\n",
        "a = 1\n",
        "next_s = 0\n",
        "\n",
        "# \"$P(s'|s, a)$と同じ意味です\n",
        "print(mdp.P[s, a])\n",
        "\n",
        "# Pはちゃんと遷移確率になっています：\"$\\sum_{s' \\in S} P(s'|s, a) = 1$です\n",
        "print(mdp.P[s, a].sum())\n",
        "\n",
        "# チャレンジ：s, aの値を変えて，mdp.P[s, a]が確率分布になっているか確認しましょう．どのs, aでも$\\sum_{s' \\in S} P(s'|s, a) = 1$になっていますか？"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "方策も行列形式で適当に作ってみましょう．定義を思い出してください．\n",
        "\n",
        "* 方策：$\\pi\\in \\mathcal{R}^{S\\times A}$"
      ],
      "metadata": {
        "id": "6yqQy5tX1F_Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "policy = np.random.rand(mdp.S, mdp.A)\n",
        "policy = policy / np.sum(policy, axis=1, keepdims=True)"
      ],
      "metadata": {
        "id": "SttbdwfQ1baV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "これで方策が定義されました！\n",
        "試しに各状態行動の値を確認してみましょう．例えば\n",
        "\n",
        "$$\\pi(a|s)$$\n",
        "\n",
        "の値は``policy[s, a]``を参照すれば得られます。"
      ],
      "metadata": {
        "id": "fDat06QP1uxw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"状態s0での行動の確率分布: \", policy[0])\n",
        "print(\"状態s1での行動の確率分布: \", policy[1])\n",
        "print(\"状態s2での行動の確率分布: \", policy[2])\n",
        "\n",
        "# チャレンジ：方策がどのsでも確率分布になっているか確認しましょう！"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gXlIIpG415jy",
        "outputId": "dc576c63-7f25-4061-86af-704bd9c43e68"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "状態s0での行動の確率分布:  [0.34841676 0.65158324]\n",
            "状態s1での行動の確率分布:  [0.17355317 0.82644683]\n",
            "状態s2での行動の確率分布:  [0.23788637 0.76211363]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "試しにちょっとだけ逐次意思決定してみましょう．"
      ],
      "metadata": {
        "id": "9cQQ43hUZUh9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s = 0 # 適当な初期状態です\n",
        "a = np.random.choice(mdp.A, p=policy[s]) # 状態sで，方策π(⋅∣s)から行動をサンプルします\n",
        "# 状態s, 行動aで，遷移確率P(⋅∣s, a)から次状態をサンプルします\n",
        "next_s = np.random.choice(mdp.S, p=mdp.P[s, a])\n",
        "reward = mdp.rew[s, a] # 報酬を得ます\n",
        "print(f\"状態{s}で行動{a}を選択したら次状態{next_s}に遷移し，報酬{reward}を獲得しました\")\n",
        "# 同じことを繰り返します\n",
        "s = next_s # 次状態を現在の状態とします\n",
        "a = np.random.choice(mdp.A, p=policy[s])\n",
        "next_s = np.random.choice(mdp.S, p=mdp.P[s, a])\n",
        "reward = mdp.rew[s, a]\n",
        "print(f\"状態{s}で行動{a}を選択したら次状態{next_s}に遷移し，報酬{reward}を獲得しました\")\n",
        "s = next_s\n",
        "# ..."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SvE0TtaBZXrF",
        "outputId": "ce3a686f-6a3a-4e68-915a-85216a4a18a5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "状態0で行動0を選択したら次状態2に遷移し，報酬0.1891654408297344を獲得しました\n",
            "状態2で行動1を選択したら次状態1に遷移し，報酬0.5456840367425468を獲得しました\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 有限マルコフ決定過程\n",
        "\n",
        "さっそく作ったマルコフ決定過程と方策で逐次意思決定をしてみましょう．\n",
        "まずは有限時間の逐次意思決定を確認します．つまり，有限マルコフ決定過程です．"
      ],
      "metadata": {
        "id": "YyQXZKuX2Js0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 適当な方策を作ります\n",
        "policy = np.random.rand(mdp.S, mdp.A)\n",
        "policy = policy / np.sum(policy, axis=1, keepdims=True)\n",
        "\n",
        "\n",
        "s = mdp.s0 # 初期状態です\n",
        "H = 10 # ホライゾンです\n",
        "R = 0 # 収益をカウントします\n",
        "for _ in range(H): # 有限マルコフ決定過程です．\n",
        "  a = np.random.choice(mdp.A, p=policy[s])\n",
        "  next_s = np.random.choice(mdp.S, p=mdp.P[s, a])\n",
        "  reward = mdp.rew[s, a]\n",
        "  R += reward\n",
        "  print(f\"状態と行動：s={s}, a={a}\")\n",
        "  s = next_s\n",
        "print(\"このエピソードの収益：\", R)\n",
        "\n",
        "# チャレンジ：s=0以外からスタートして収益を計算してみましょう．"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wx6w_xDr2I4T",
        "outputId": "781bcc99-0ef4-4fb2-e294-bbb41b72d109"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "状態と行動：s=0, a=0\n",
            "状態と行動：s=0, a=1\n",
            "状態と行動：s=0, a=1\n",
            "状態と行動：s=0, a=1\n",
            "状態と行動：s=0, a=1\n",
            "状態と行動：s=0, a=1\n",
            "状態と行動：s=1, a=0\n",
            "状態と行動：s=1, a=1\n",
            "状態と行動：s=2, a=1\n",
            "状態と行動：s=1, a=0\n",
            "このエピソードの収益： 5.488506004380774\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "続いて，有限マルコフ決定過程における期待収益をモンテカルロ近似してみましょう．"
      ],
      "metadata": {
        "id": "VZ2o8bO6tW-k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 適当な方策を作ります\n",
        "policy = np.random.rand(mdp.S, mdp.A)\n",
        "policy = policy / np.sum(policy, axis=1, keepdims=True)\n",
        "\n",
        "\n",
        "H = 10 # ホライゾンです\n",
        "R_sum = 0 # 期待収益の計算用です\n",
        "N = 1000 # モンテカルロ近似で使用するサンプルの数です．\n",
        "\n",
        "for _ in range(N):\n",
        "  s = mdp.s0 # 初期状態です\n",
        "  R = 0 # 収益をカウントします\n",
        "  for _ in range(H):\n",
        "    a = np.random.choice(mdp.A, p=policy[s])\n",
        "    next_s = np.random.choice(mdp.S, p=mdp.P[s, a])\n",
        "    reward = mdp.rew[s, a]\n",
        "    R += reward\n",
        "    s = next_s\n",
        "  R_sum += R\n",
        "print(\"モンテカルロ近似された期待収益:\", R_sum / N)\n",
        "\n",
        "# チャレンジ：Nの値を変えて挙動を観察しましょう．何が言えますか？\n",
        "# チャレンジ：初期状態をs=0以外から始めてみましょう．"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6ZWkiU6Otci2",
        "outputId": "951aa27b-50e7-457c-ace5-8ba4ad5907b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "モンテカルロ近似された期待収益: 5.247276157984284\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 無限マルコフ決定過程\n",
        "\n",
        "続いて無限時間の逐次意思決定を確認してみましょう．割引率が導入されていることに注意してください．（なぜ導入されているか考えてみましょう．スライドでも説明しましたね）"
      ],
      "metadata": {
        "id": "WxVbuoGx33Vk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 適当な方策を作ります\n",
        "policy = np.random.rand(mdp.S, mdp.A)\n",
        "policy = policy / np.sum(policy, axis=1, keepdims=True)\n",
        "\n",
        "\n",
        "s = mdp.s0 # 初期状態です\n",
        "R = 0 # 割引収益をカウントします\n",
        "gamma = 0.7 # 割引率です\n",
        "t = 0 # 経過したステップ数です\n",
        "while True: # 無限マルコフ決定過程です．\n",
        "  a = np.random.choice(mdp.A, p=policy[s])\n",
        "  next_s = np.random.choice(mdp.S, p=mdp.P[s, a])\n",
        "  reward = mdp.rew[s, a]\n",
        "  R += gamma ** t * reward\n",
        "  s = next_s\n",
        "  print(f\"{t}ステップ目までの割引収益：\", R)\n",
        "  t += 1\n",
        "\n",
        "  if t == 30:  # 無限に実行するとプログラム上はキリがないので，適当なところで切り上げます\n",
        "    break\n",
        "\n",
        "# チャレンジ：割引率を変えて挙動を観測してみましょう．また，切り上げるステップはどのくらいが良いでしょうか？"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4j2m1zX4JIW",
        "outputId": "e5a6a560-11e9-496f-ecd9-fb78c2d6959a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0ステップ目までの割引収益： 0.1891654408297344\n",
            "1ステップ目までの割引収益： 0.6199562108460346\n",
            "2ステップ目までの割引収益： 0.7126472768526044\n",
            "3ステップ目までの割引収益： 0.7775310230572033\n",
            "4ステップ目までの割引収益： 0.8229496454004226\n",
            "5ステップ目までの割引収益： 0.8547426810406761\n",
            "6ステップ目までの割引収益： 0.948580175256707\n",
            "7ステップ目までの割引収益： 0.9992622785583547\n",
            "8ステップ目までの割引収益： 1.034739750869508\n",
            "9ステップ目までの割引収益： 1.042373258726733\n",
            "10ステップ目までの割引収益： 1.0614838423190962\n",
            "11ステップ目までの割引収益： 1.0748612508337505\n",
            "12ステップ目までの割引収益： 1.0774795440287785\n",
            "13ステップ目までの割引収益： 1.0793123492652983\n",
            "14ステップ目までの割引収益： 1.08301330430734\n",
            "15ステップ目までの割引収益： 1.0839113788732346\n",
            "16ステップ目までの割引収益： 1.084540031069361\n",
            "17ステップ目までの割引収益： 1.0849800876066493\n",
            "18ステップ目までの割引収益： 1.0858686869122436\n",
            "19ステップ目までの割引収益： 1.0860843146155148\n",
            "20ステップ目までの割引収益： 1.0862352540078046\n",
            "21ステップ目までの割引収益： 1.0865400435696235\n",
            "22ステップ目までの割引収益： 1.0866140038718455\n",
            "23ステップ目までの割引収益： 1.0867633507571366\n",
            "24ステップ目までの割引収益： 1.0867995913052253\n",
            "25ステップ目までの割引収益： 1.0868821227314125\n",
            "26ステップ目までの割引収益： 1.086899880599976\n",
            "27ステップ目までの割引収益： 1.0869522931442663\n",
            "28ステップ目までの割引収益： 1.0869889819252696\n",
            "29ステップ目までの割引収益： 1.0869934938248824\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "続いて，無限マルコフ決定過程での期待収益をモンテカルロ近似してみます．\n",
        "後で便利なので，これは関数にしておきましょう．"
      ],
      "metadata": {
        "id": "coILbEpqxjff"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def MonteCarloExpectedReturn(mdp: MDP, gamma: float, policy: np.ndarray, H: int, N: int):\n",
        "  \"\"\"期待収益をモンテカルロ法で近似します．\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    policy (np.ndarray): 期待収益を近似したい方策です\n",
        "    H (int): ∞ホライゾンを打ち切る長さです\n",
        "    N (int): モンテカルロ近似で使用するサンプルの数です．\n",
        "  \"\"\"\n",
        "  R_sum = 0 # 期待収益の計算用です\n",
        "  for _ in range(N):\n",
        "    R = 0 # 収益をカウントします\n",
        "    s = mdp.s0 # 初期状態です\n",
        "    # 次のステップからは方策に従って動きます\n",
        "    for h in range(H):\n",
        "      a = np.random.choice(mdp.A, p=policy[s])\n",
        "      next_s = np.random.choice(mdp.S, p=mdp.P[s, a])\n",
        "      reward = mdp.rew[s, a]\n",
        "      R += gamma ** h * reward\n",
        "      s = next_s\n",
        "    R_sum += R\n",
        "  return R_sum / N\n",
        "\n",
        "\n",
        "# 適当な方策を作ります\n",
        "policy = np.random.rand(mdp.S, mdp.A)\n",
        "policy = policy / np.sum(policy, axis=1, keepdims=True)\n",
        "\n",
        "gamma = 0.7 # 割引率です\n",
        "H = 30 # 十分な精度が期待できるホライゾンです\n",
        "N = 100 # モンテカルロ近似で使用するサンプルの数です．\n",
        "print(\"モンテカルロ近似された割引期待収益:\", MonteCarloExpectedReturn(mdp, gamma, policy, H, N))\n",
        "\n",
        "# チャレンジ：割引率を変えて挙動を観測してみましょう．また，切り上げるステップはどのくらいが良いでしょうか？"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2rHSkJqUxhRe",
        "outputId": "79947cdf-4464-4031-e348-086d2c1219db"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "モンテカルロ近似された割引期待収益: 1.455028698601835\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 具体的な問題を実装してみよう（じゃんけんゲーム）\n",
        "\n",
        "上ではランダムにマルコフ決定過程を生成し，マルコフ決定過程の「型」を学びました．\n",
        "今回は具体的な問題（講義で紹介したじゃんけんゲーム）を実装してみましょう．\n",
        "\n",
        "まずは自明な問題を実装してみます．\n",
        "\n",
        "\n",
        "### 自明な問題\n",
        "\n",
        "* プレイ回数：１回\n",
        "* ルール：じゃんけんに勝つと+1，それ以外は+0の報酬が発生します．\n",
        "* 情報：A君は(グー，チョキ，パー)=(0.2, 0.5, 0.3)の確率で出してきます．\n",
        "* ゴール：最も報酬が高くなる手を出してください\n",
        "\n",
        "\n",
        "逆に言えば，あなたが\n",
        "* グーを出す：確率0.5で報酬+1，確率0.5で報酬+0\n",
        "* チョキを出す：確率0.3で報酬+1，確率0.7で報酬+0\n",
        "* パーを出す：確率0.2で報酬+1，確率0.8で報酬+0\n",
        "\n",
        "です．これは次のようなマルコフ決定過程を考えることでモデル化できます．（こんな単純なじゃんけんでもちょっと面倒くさいですね）．ちなみに勝率が最も高い手は明らかにグーです．"
      ],
      "metadata": {
        "id": "kKpnN8tZG8nH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "k9_7OtEDTWl3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "つまり，\n",
        "* $A=\\{0, 1, 2\\}$  # グー，チョキ，パー\n",
        "* $(s_0, s_1, s_2, s_3)$  # ゲーム開始時，あなたが勝った状態，あなたが負け or あいこの状態，ゲーム終了時\n",
        "* $r$と$P$：上の図を参照してください．\n",
        "\n",
        "\n",
        "**補足**\n",
        "\n",
        "問題をどのようなマルコフ決定過程でモデル化するか？には正解はありません．\n",
        "実は報酬関数の代わりに確率的に発生する報酬を考えると，上の問題は$H=1$でモデル化できます．上の図では意思決定をするタイミングが2回あるので，$H=2$です．\n",
        "今回の講義では報酬は決定的（つまり，$r(s, a)=実数$でした）としていたので，少し面倒なモデル化をしています．\n",
        "\n",
        "バンディット問題（$H=1$）などでは報酬が確率的に発生するようにモデル化しますが，強化学習問題（$H\\geq 1$）では報酬を決定的にしても，上のように無理やりモデル化できます．これは，報酬の確率的な挙動を遷移の確率的な挙動で表現できるためです．"
      ],
      "metadata": {
        "id": "tAUtKMhFTTp-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 上のじゃんけんゲームをマルコフ決定過程で表現しましょう\n",
        "\n",
        "_S = 4  # 状態集合のサイズ\n",
        "_A = 3   # 行動集合のサイズ\n",
        "_S_set = np.arange(_S)  # 状態集合\n",
        "_A_set = np.arange(_A)  # 行動集合\n",
        "\n",
        "# 報酬行列を作ります\n",
        "_rew = np.zeros((_S, _A))\n",
        "_rew[0] = 0  # 状態０では報酬は発生しません\n",
        "_rew[1] = 1  # 状態１では報酬＋１です\n",
        "_rew[2] = 0  # 状態２では報酬は発生しません\n",
        "_rew[3] = 0  # 状態３では報酬は発生しません\n",
        "assert _rew.shape == (_S, _A)\n",
        "\n",
        "# 遷移確率行列を作ります\n",
        "_P = np.zeros((_S, _A, _S))  # 今の状態，今の行動，次状態\n",
        "_P[:, :, 0] = 0  # ゲーム開始時に戻ることはありません\n",
        "_P[0, 0, 1] = 0.5  # グーを選んで勝つ確率\n",
        "_P[0, 0, 2] = 0.5  # グーを選んで負けorあいこの確率\n",
        "_P[0, 1, 1] = 0.3  # チョキを選んで勝つ確率\n",
        "_P[0, 1, 2] = 0.7  # チョキを選んで負けorあいこの確率\n",
        "_P[0, 2, 1] = 0.2  # パーを選んで勝つ確率\n",
        "_P[0, 2, 2] = 0.8  # パーを選んで負けorあいこの確率\n",
        "_P[1, :, 3] = 1  # ゲーム終了時に移行する確率\n",
        "_P[2, :, 3] = 1  # ゲーム終了時に移行する確率\n",
        "_P[3, :, 3] = 1  # ゲーム終了時に移行する確率\n",
        "np.testing.assert_almost_equal(_P.sum(axis=-1), 1)  # ちゃんと確率行列になっているか確認します\n",
        "\n",
        "trivial_mdp = MDP(_S_set, _A_set, _rew, _P)"
      ],
      "metadata": {
        "id": "d69t7c53G71o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"じゃんけん勝負しましょう．何を出しますか？\")\n",
        "a = int(input(\"グー: 0，チョキ: 1，パー: 2 \"))\n",
        "\n",
        "s = mdp.s0 # 初期状態です\n",
        "H = 2 # ホライゾンです\n",
        "R = 0 # 収益をカウントします\n",
        "for _ in range(H): # 有限マルコフ決定過程です．\n",
        "  next_s = np.random.choice(trivial_mdp.S, p=trivial_mdp.P[s, a])\n",
        "  reward = trivial_mdp.rew[s, a]\n",
        "  R += reward\n",
        "  print(f\"状態と行動と報酬：s={s}, a={a}, r={reward}\")\n",
        "  s = next_s\n",
        "\n",
        "if R == 1:\n",
        "  print(\"あなたの勝ち\")\n",
        "else:\n",
        "  print(\"あなたの負け or あいこ\")"
      ],
      "metadata": {
        "id": "iCA1TN6pZKPD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### バンディット問題\n",
        "\n",
        "* プレイ回数：M回\n",
        "* ルール：じゃんけんに勝つと+1，それ以外は+0の報酬が発生します．\n",
        "* 情報：A君は(グー，チョキ，パー)=(?, ?, ?)の確率で出してきます．\n",
        "* ゴール：Mゲーム以内に，最も報酬が高くなる手を見つけてください\n",
        "\n",
        "上で見た自明な問題と似たような感じですが，今回はA君がどんな手を出してくるかわかりません．なので，A君が何を出しやすいかを当てなければなりません．\n",
        "このように，環境の情報がない場合＆$H=1$の問題をバンディット問題と呼びます（上のモデル化は厳密には$H=2$ですが，今回使っていない確率的な報酬関数を使用すれば$H=1$にできます）．"
      ],
      "metadata": {
        "id": "JEKd3hS4b98u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# バンディット問題を体験しましょう\n",
        "\n",
        "# 状態集合，行動集合，報酬関数は同じです．\n",
        "_S = 4  # 状態集合のサイズ\n",
        "_A = 3   # 行動集合のサイズ\n",
        "_S_set = np.arange(_S)  # 状態集合\n",
        "_A_set = np.arange(_A)  # 行動集合\n",
        "\n",
        "_rew = np.zeros((_S, _A))\n",
        "_rew[0] = 0  # 状態０では報酬は発生しません\n",
        "_rew[1] = 1  # 状態１では報酬＋１です\n",
        "_rew[2] = 0  # 状態２では報酬は発生しません\n",
        "_rew[3] = 0  # 状態３では報酬は発生しません\n",
        "assert _rew.shape == (_S, _A)\n",
        "\n",
        "\n",
        "# 遷移確率行列を生成します．我々はA君がどの手を出してくるか知りません．\n",
        "_P = np.zeros((_S, _A, _S))  # 今の状態，今の行動，次状態\n",
        "gu_choki_pa = np.random.rand(_A)  # A君が出してくる確率です\n",
        "gu_choki_pa = gu_choki_pa / gu_choki_pa.sum()\n",
        "_P[0, 0, 1] = gu_choki_pa[1]  # グーを選んで勝つ確率\n",
        "_P[0, 0, 2] = 1 - gu_choki_pa[1]  # グーを選んで負けorあいこの確率\n",
        "_P[0, 1, 1] = gu_choki_pa[2]  # チョキを選んで勝つ確率\n",
        "_P[0, 1, 2] = 1 - gu_choki_pa[2]  # チョキを選んで負けorあいこの確率\n",
        "_P[0, 2, 1] = gu_choki_pa[0]  # パーを選んで勝つ確率\n",
        "_P[0, 2, 2] = 1 - gu_choki_pa[0]  # パーを選んで負けorあいこの確率\n",
        "_P[1, :, 3] = 1  # ゲーム終了時に移行する確率\n",
        "_P[2, :, 3] = 1  # ゲーム終了時に移行する確率\n",
        "_P[3, :, 3] = 1  # ゲーム終了時に移行する確率\n",
        "np.testing.assert_almost_equal(_P.sum(axis=-1), 1)  # ちゃんと確率行列になっているか確認します\n",
        "\n",
        "bandit_mdp = MDP(_S_set, _A_set, _rew, _P)"
      ],
      "metadata": {
        "id": "KkNZ1bzZd0B1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "M = 4  # ゲームのプレイ回数\n",
        "\n",
        "print(f\"全部でゲームを{M}プレイします\")\n",
        "for m in range(M):\n",
        "  print(f\"{m}プレイ目\")\n",
        "  print(\"じゃんけん勝負しましょう．何を出しますか？\")\n",
        "  a = int(input(\"グー: 0，チョキ: 1，パー: 2 \"))\n",
        "\n",
        "  s = mdp.s0 # 初期状態です\n",
        "  H = 2 # ホライゾンです\n",
        "  R = 0 # 収益をカウントします\n",
        "  for _ in range(H): # 有限マルコフ決定過程です．\n",
        "    next_s = np.random.choice(bandit_mdp.S, p=bandit_mdp.P[s, a])\n",
        "    reward = bandit_mdp.rew[s, a]\n",
        "    R += reward\n",
        "    print(f\"状態と行動と報酬：s={s}, a={a}, r={reward}\")\n",
        "    s = next_s\n",
        "\n",
        "  if R == 1:\n",
        "    print(\"あなたの勝ち\")\n",
        "  else:\n",
        "    print(\"あなたの負け or あいこ\")\n",
        "\n",
        "\n",
        "print(f\"A君の出す確率は実は{bandit_mdp.P[0, 2, 1]}, {bandit_mdp.P[0, 0, 1]}, {bandit_mdp.P[0, 1, 1]} でした．当たりましたか？\")"
      ],
      "metadata": {
        "id": "fHoyKxg0ZNft"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### 無限ホライゾンプランニング問題\n",
        "\n",
        "プレイ回数：1回\n",
        "* ルール： 無限回じゃんけんをします．パーで勝つと+1，それ以外は0の報酬が発生します．\n",
        "* 情報：A君は最初必ずグーを出します．次以降，A君は直前に出された手以外を高い確率で出すとします．例えば， (あなた，A君)=(グー，チョキ)なら，次は (0.1, 0.1, 0.8)．また，例えば(あなた，A君)=(グー，グー)なら，次は(0.1, 0.45, 0.45)で手を出します．\n",
        "* ゴール：適当な$\\gamma \\in (0, 1)$ に対して，割引累積報酬和が最も高くなる方策を出してください\n",
        "\n",
        "この場合，A君がどの手を出すか？，の情報は分かっています．\n",
        "しかし自明な問題と異なり，今回は数ステップ先のことまで考えて，A君なるべくがグーを出すように誘導しないといけません．\n",
        "\n",
        "ゴールのことはいったんわすれて，このゲームをマルコフ決定過程でモデル化してみましょう．図で表すのは厄介ですが，あり得る状況を整理すれば，簡単にモデル化できます．\n",
        "\n",
        "* $A=\\{0, 1, 2\\}$  # グー，チョキ，パー\n",
        "* $S=(ゲーム開始時, (グ, グ) , (グ, チ), (グ, パ), (チ, グ) , (チ, チ), (チ, パ), (パ, グ) , (パ, チ), (パ, パ))$  # ゲーム開始時と，あなたとA君の手の全列挙です．今回は全部で10個の状態を考えるだけで充分です．順番に$s_0$, $s_1$, ...とします\n",
        "\n",
        "$P$と$r$は下のコードで確認してください．"
      ],
      "metadata": {
        "id": "fjp6Ow9mhri9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# プランニング問題を体験しましょう\n",
        "\n",
        "_S = 10  # 状態集合のサイズ\n",
        "_A = 3   # 行動集合のサイズ\n",
        "_S_set = np.arange(_S)  # 状態集合\n",
        "_A_set = np.arange(_A)  # 行動集合\n",
        "\n",
        "# 報酬行列を作ります\n",
        "_rew = np.zeros((_S, _A))\n",
        "_rew[7] = 1  # 状態7では直前に（パ，グ）が出て勝利しているので，報酬を＋１します．\n",
        "assert _rew.shape == (_S, _A)\n",
        "\n",
        "# 遷移確率行列を作ります（全部で10x3x10マスあります！）\n",
        "_P = np.zeros((_S, _A, _S))  # 今の状態，今の行動，次状態\n",
        "_P[:, :, 0] = 0  # ゲーム開始時に戻ることはありません\n",
        "\n",
        "# 初期状態ではA君は必ずグーを出します．\n",
        "_P[0, 0, 1] = 1  # 初期状態 → あなたがグーを出す場合．（グ，グ）に遷移します．\n",
        "_P[0, 1, 4] = 1  # 初期状態 → あなたがチョキを出す場合．（チ，グ）に遷移します．\n",
        "_P[0, 2, 7] = 1  # 初期状態 → あなたがパーを出す場合．（パ，グ）に遷移します．\n",
        "\n",
        "# それ以外のとき\n",
        "## グーであいこのとき\n",
        "_P[1, 0, 1] = _P[1, 1, 4] = _P[1, 2, 7]  = 0.1  # A君がグーを出す\n",
        "_P[1, 0, 2] = _P[1, 1, 5] = _P[1, 2, 8]  = 0.45  # A君がチョキを出す\n",
        "_P[1, 0, 3] = _P[1, 1, 6] = _P[1, 2, 9]  = 0.45  # A君がパーを出す\n",
        "\n",
        "## チョキであいこのとき\n",
        "_P[5, 0, 1] = _P[5, 1, 4] = _P[5, 2, 7]  = 0.45  # A君がグーを出す\n",
        "_P[5, 0, 2] = _P[5, 1, 5] = _P[5, 2, 8]  = 0.1  # A君がチョキを出す\n",
        "_P[5, 0, 3] = _P[5, 1, 6] = _P[5, 2, 9]  = 0.45  # A君がパーを出す\n",
        "\n",
        "## パーであいこのとき\n",
        "_P[9, 0, 1] = _P[9, 1, 4] = _P[9, 2, 7]  = 0.45  # A君がグーを出す\n",
        "_P[9, 0, 2] = _P[9, 1, 5] = _P[9, 2, 8]  = 0.45  # A君がチョキを出す\n",
        "_P[9, 0, 3] = _P[9, 1, 6] = _P[9, 2, 9]  = 0.1  # A君がパーを出す\n",
        "\n",
        "## (グ, チ)もしくは(チ, グ)のとき\n",
        "_P[2, 0, 1] = _P[2, 1, 4] = _P[2, 2, 7] = _P[4, 0, 1] = _P[4, 1, 4] = _P[4, 2, 7] = 0.1  # A君がグーを出す\n",
        "_P[2, 0, 2] = _P[2, 1, 5] = _P[2, 2, 8] = _P[4, 0, 2] = _P[4, 1, 5] = _P[4, 2, 8] = 0.1  # A君がチョキを出す\n",
        "_P[2, 0, 3] = _P[2, 1, 6] = _P[2, 2, 9] = _P[4, 0, 3] = _P[4, 1, 6] = _P[4, 2, 9] = 0.8  # A君がパーを出す\n",
        "\n",
        "## (グ, パ)もしくは(パ, グ)のとき\n",
        "_P[3, 0, 1] = _P[3, 1, 4] = _P[3, 2, 7] = _P[7, 0, 1] = _P[7, 1, 4] = _P[7, 2, 7] = 0.1  # A君がグーを出す\n",
        "_P[3, 0, 2] = _P[3, 1, 5] = _P[3, 2, 8] = _P[7, 0, 2] = _P[7, 1, 5] = _P[7, 2, 8] = 0.8  # A君がチョキを出す\n",
        "_P[3, 0, 3] = _P[3, 1, 6] = _P[3, 2, 9] = _P[7, 0, 3] = _P[7, 1, 6] = _P[7, 2, 9] = 0.1  # A君がパーを出す\n",
        "\n",
        "## (チ, パ)もしくは(パ, チ)のとき\n",
        "_P[6, 0, 1] = _P[6, 1, 4] = _P[6, 2, 7] = _P[8, 0, 1] = _P[8, 1, 4] = _P[8, 2, 7] = 0.8  # A君がグーを出す\n",
        "_P[6, 0, 2] = _P[6, 1, 5] = _P[6, 2, 8] = _P[8, 0, 2] = _P[8, 1, 5] = _P[8, 2, 8] = 0.1  # A君がチョキを出す\n",
        "_P[6, 0, 3] = _P[6, 1, 6] = _P[6, 2, 9] = _P[8, 0, 3] = _P[8, 1, 6] = _P[8, 2, 9] = 0.1  # A君がパーを出す\n",
        "\n",
        "np.testing.assert_almost_equal(_P.sum(axis=-1), 1)  # ちゃんと確率行列になっているか確認します\n",
        "\n",
        "planning_mdp = MDP(_S_set, _A_set, _rew, _P)"
      ],
      "metadata": {
        "id": "ewkoziB_ttqP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"無限回じゃんけん勝負しましょう．パーで勝つときだけあなたに得点が入ります．得点は次のターンで入ります．\")\n",
        "\n",
        "h = 0\n",
        "s = mdp.s0  # 初期状態です\n",
        "R = 0  # 収益をカウントします\n",
        "gamma = 0.9  # 割引率です\n",
        "\n",
        "while True:\n",
        "  print(\"\")\n",
        "  print(\"=======何を出しますか？======\")\n",
        "  a = int(input(\"グー: 0，チョキ: 1，パー: 2 , やめる: 3 \"))\n",
        "  if a == 3:\n",
        "    break\n",
        "\n",
        "  next_s = np.random.choice(planning_mdp.S, p=planning_mdp.P[s, a])\n",
        "  reward = planning_mdp.rew[s, a]\n",
        "  R += gamma ** h * reward\n",
        "\n",
        "  if next_s in (1, 4, 7):\n",
        "    Akun = \"グー\"\n",
        "  elif next_s in (2, 5, 8):\n",
        "    Akun = \"チョキ\"\n",
        "  elif next_s in (3, 6, 9):\n",
        "    Akun = \"パー\"\n",
        "\n",
        "  you = {0: \"グー\", 1: \"チョキ\", 2: \"パー\"}[a]\n",
        "  print(f\"あなたの手＝{you}, A君の手＝{Akun}\")\n",
        "  print(f\"状態と行動と報酬：s={s}, a={a}, r={reward}\")\n",
        "  print(f\"{h}ステップ目の割引収益: {R}\")\n",
        "\n",
        "  h += 1\n",
        "  s = next_s"
      ],
      "metadata": {
        "id": "K_N3f1sZZRn3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "### 無限ホライゾン強化学習問題\n",
        "\n",
        "* プレイ回数：1回\n",
        "* プレイ回数：1回（無限ホライゾンなので）\n",
        "* ルール：無限回じゃんけんをします．パーで勝つと+1，それ以外は0の報酬が発生します．\n",
        "* 情報：A君がどのような条件で何を出すか，一切不明です．\n",
        "* ゴール：割引累積報酬和が最も高くなる方策を，なるべく少ないじゃんけん数で出してください\n",
        "\n",
        "今回はとっても難しいです．今回は数ステップ先のことまで考えて手を出さねばならず，しかも，A君が何をいつ出してくるかもわかりません．\n",
        "これが強化学習問題です．"
      ],
      "metadata": {
        "id": "l0QPNiXK_SOL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 強化学習問題を体験しましょう\n",
        "\n",
        "_S = 10  # 状態集合のサイズ\n",
        "_A = 3   # 行動集合のサイズ\n",
        "_S_set = np.arange(_S)  # 状態集合\n",
        "_A_set = np.arange(_A)  # 行動集合\n",
        "\n",
        "# 報酬行列を作ります\n",
        "_rew = np.zeros((_S, _A))\n",
        "_rew[7] = 1  # 状態7では直前に（パ，グ）が出て勝利しているので，報酬を＋１します．\n",
        "assert _rew.shape == (_S, _A)\n",
        "\n",
        "# 遷移確率行列を作ります．我々はA君がいつ，どんな手を出してくるか知りません\n",
        "_P = np.zeros((_S, _A, _S))  # 今の状態，今の行動，次状態\n",
        "_P = np.random.rand(_S*_A, _S)\n",
        "_P[:, 0] = 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",
        "\n",
        "RL_mdp = MDP(_S_set, _A_set, _rew, _P)"
      ],
      "metadata": {
        "id": "Cl7_YnNY_Rhb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"無限回じゃんけん勝負しましょう．パーで勝つときだけあなたに得点が入ります．得点は次のターンで入ります．\")\n",
        "h = 0\n",
        "s = mdp.s0  # 初期状態です\n",
        "R = 0  # 収益をカウントします\n",
        "gamma = 0.9  # 割引率です\n",
        "\n",
        "while True:\n",
        "  print(\"=======何を出しますか？======\")\n",
        "  a = int(input(\"グー: 0，チョキ: 1，パー: 2 , やめる: 3 \"))\n",
        "  if a == 3:\n",
        "    break\n",
        "\n",
        "  next_s = np.random.choice(RL_mdp.S, p=RL_mdp.P[s, a])\n",
        "  reward = RL_mdp.rew[s, a]\n",
        "  R += gamma ** h * reward\n",
        "\n",
        "  if next_s in (1, 4, 7):\n",
        "    Akun = \"グー\"\n",
        "  elif next_s in (2, 5, 8):\n",
        "    Akun = \"チョキ\"\n",
        "  elif next_s in (3, 6, 9):\n",
        "    Akun = \"パー\"\n",
        "\n",
        "  you = {0: \"グー\", 1: \"チョキ\", 2: \"パー\"}[a]\n",
        "  print(f\"あなたの手＝{you}, A君の手＝{Akun}\")\n",
        "  print(f\"状態と行動と報酬：s={s}, a={a}, r={reward}\")\n",
        "  print(f\"{h}ステップ目の割引収益: {R}\")\n",
        "\n",
        "  h += 1\n",
        "  s = next_s"
      ],
      "metadata": {
        "id": "YriZeX0qZVTZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 動的計画法\n",
        "\n",
        "## ベルマン方程式とベルマン作用素を確認しよう\n",
        "\n",
        "**注意：以降は無限マルコフ決定過程についてだけ扱います．**\n",
        "\n",
        "表記はスライドを参照してください．\n",
        "マルコフ決定過程で成立する重要な性質がベルマン方程式です．\n",
        "* ベルマン期待方程式：$Q^\\pi = r + \\gamma P \\langle\\pi, Q^\\pi\\rangle$\n",
        "* ベルマン最適方程式：$Q^{\\pi^*} = r + \\gamma P \\max_a Q^{\\pi^*}$\n",
        "\n",
        "また，次のベルマン作用素は$Q^\\pi$と$Q^{\\pi^*}$を見つけるのに便利，ということを学びました．\n",
        "* ベルマン期待作用素 $B^\\pi: \\mathbb{R}^{S\\times A}\\to \\mathbb{R}^{S\\times A}$：$B^\\pi(Q) = r + \\gamma P \\langle \\pi, Q\\rangle $\n",
        "* ベルマン最適作用素 $B: \\mathbb{R}^{S\\times A}\\to \\mathbb{R}^{S\\times A}$：$B(Q) = r + \\gamma P \\max_a Q$\n",
        "\n",
        "ベルマン作用素を使うと，\n",
        "* ベルマン期待方程式：$Q^\\pi = B^\\pi(Q^\\pi)$\n",
        "* ベルマン最適方程式：$Q^{\\pi^*} = B(Q^{\\pi^*})$\n",
        "\n",
        "と書くこともできます．\n",
        "\n",
        "以下ではベルマン方程式がちゃんと成り立つか実験するわけですが，先に便利な関数を実装しておきます．\n",
        "\n",
        "* MonteCarloQ: モンテカルロ近似を使って$Q^\\pi$を近似する関数（$Q^\\pi(s, a) = \\mathbb{E}^\\pi[R\\mid s_0=s, a_0=a]$であることを思い出しましょう．）\n",
        "* Bellman_expected_operator: ベルマン期待作用素\n",
        "* Bellman_optimal_operator: ベルマン最適作用素\n",
        "\n",
        "の三つを実装してみます．"
      ],
      "metadata": {
        "id": "emgzUqIG6WJY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def MonteCarloQ(mdp: MDP, gamma: float, s0: int, a0: int, policy: np.ndarray, H: int, N: int):\n",
        "  \"\"\"モンテカルロ法でQ\\pi(s0, a0)を近似します．\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    s0 (int): 期待収益を近似したい初期状態です\n",
        "    a0 (int): 期待収益を近似したい初期行動です\n",
        "    policy (np.ndarray): 期待収益を近似したい方策です\n",
        "    H (int): ∞ホライゾンを打ち切る長さです\n",
        "    N (int): モンテカルロ近似で使用するサンプルの数です．\n",
        "  \"\"\"\n",
        "  R_sum = 0 # 期待収益の計算用です\n",
        "  for _ in range(N):\n",
        "    R = 0 # 収益をカウントします\n",
        "\n",
        "    # 最初のステップは初期状態と初期行動で固定されてます\n",
        "    s = s0  # 初期状態です\n",
        "    a = a0  # 初期行動です\n",
        "    next_s = np.random.choice(mdp.S, p=mdp.P[s, a])\n",
        "    reward = mdp.rew[s, a]\n",
        "    R += reward\n",
        "    s = next_s\n",
        "\n",
        "    # 次のステップからは方策に従って動きます\n",
        "    for h in range(1, H):\n",
        "      a = np.random.choice(mdp.A, p=policy[s])\n",
        "      next_s = np.random.choice(mdp.S, p=mdp.P[s, a])\n",
        "      reward = mdp.rew[s, a]\n",
        "      R += gamma ** h * reward\n",
        "      s = next_s\n",
        "    R_sum += R\n",
        "  return R_sum / N\n",
        "\n",
        "\n",
        "def Bellman_expected_operator(mdp: MDP, gamma: float, Q: np.ndarray, policy: np.ndarray):\n",
        "  \"\"\"\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    Q (np.ndarray): ベルマン期待作用素に入力するQ関数です\n",
        "    policy (np.ndarray): ベルマン期待作用素で使う方策です\n",
        "  \"\"\"\n",
        "  S, A = mdp.S, mdp.A\n",
        "  # 方策とQ関数はSxAの行列です\n",
        "  assert Q.shape == (S, A)\n",
        "  assert policy.shape == (S, A)\n",
        "  policy_Q = (policy * Q).sum(axis=1) # πQです\n",
        "  P_policy_Q = mdp.P @ policy_Q  # P(πQ)です\n",
        "  B_policy_Q = mdp.rew + gamma * P_policy_Q # ベルマン期待作用素の結果です\n",
        "  return B_policy_Q\n",
        "\n",
        "\n",
        "def Bellman_optimal_operator(mdp: MDP, gamma: float, Q: np.ndarray):\n",
        "  \"\"\"\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    Q (np.ndarray): ベルマン期待作用素に入力するQ関数です\n",
        "  \"\"\"\n",
        "  # Q関数はSxAの行列です\n",
        "  assert Q.shape == (mdp.S, mdp.A)\n",
        "  max_Q = Q.max(axis=1) # maxQです\n",
        "  P_max_Q = mdp.P @ max_Q # P(maxQ)です\n",
        "  BQ = mdp.rew + gamma * P_max_Q # ベルマン最適作用素の結果です\n",
        "  return BQ"
      ],
      "metadata": {
        "id": "d-QZ9dz4ZlwT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uVX-cFBEy7f8"
      },
      "source": [
        "今実装した$Q^\\pi(s, a)$をモンテカルロ近似関数とベルマン期待作用素を使って，本当にベルマン期待方程式が成り立つか見てみましょう．\n",
        "方策$\\pi$についてモンテカルロ近似したQ値を$\\hat{Q}^\\pi$とします．$\\hat{Q}^\\pi$の精度が高ければ，期待される挙動としては，適当なほかの$Q \\in \\mathbb{R}^{S\\times A}$について，\n",
        "$$\n",
        "\\|\\hat{Q}^\\pi-B^\\pi(\\hat{Q}^\\pi)\\|_\\infty \\leq \\|Q-B^{\\pi}(Q)\\|_\\infty\n",
        "$$\n",
        "が成り立ちそうです．（$\\|{Q}-B^\\pi({Q})\\|_\\infty=0$を満たす$Q$は$Q^\\pi$だけなので）"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "VFsJDHq6y7f8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df95e11c-7bc3-445d-aba9-b067ed137ef9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Q^\\pi(0, 0)のモンテカルロ近似： 1.2612563188805967\n",
            "Q^\\pi(0, 1)のモンテカルロ近似： 1.7351060628686787\n",
            "Q^\\pi(1, 0)のモンテカルロ近似： 1.6057335247884523\n",
            "Q^\\pi(1, 1)のモンテカルロ近似： 1.2844684240843838\n",
            "Q^\\pi(2, 0)のモンテカルロ近似： 1.754093206121211\n",
            "Q^\\pi(2, 1)のモンテカルロ近似： 1.597628085492309\n",
            "==========\n",
            "|Q^\\piの近似 - B(Q^\\piの近似)|の最大値 0.007178392718010462\n",
            "|Q - B(Q)|の最大値 0.7561108341171424\n"
          ]
        }
      ],
      "source": [
        "gamma = 0.7\n",
        "H = 50\n",
        "N = 1000\n",
        "\n",
        "# 適当な方策を作ります\n",
        "policy = np.random.rand(mdp.S, mdp.A)\n",
        "policy = policy / np.sum(policy, axis=1, keepdims=True)\n",
        "\n",
        "# 各状態行動のQ値のモンテカルロ近似を確認してみましょう\n",
        "estimated_Q = np.zeros((mdp.S, mdp.A))\n",
        "for s in range(mdp.S):\n",
        "  for a in range(mdp.A):\n",
        "    estimated_Q[s, a] = MonteCarloQ(mdp, gamma, s, a, policy, H, N)\n",
        "    print(f\"Q^\\pi({s}, {a})のモンテカルロ近似：\", estimated_Q[s, a])\n",
        "\n",
        "print(\"==========\")\n",
        "BQ = Bellman_expected_operator(mdp, gamma, estimated_Q, policy)\n",
        "print(\"|Q^\\piの近似 - B(Q^\\piの近似)|の最大値\", np.abs(estimated_Q - BQ).max())\n",
        "\n",
        "# 適当な別のQ関数を生成して，|Q-B(Q)|∞を比較してみます．\n",
        "tekitou_Q = np.random.rand(mdp.S, mdp.A)\n",
        "print(\"|Q - B(Q)|の最大値\", np.abs(tekitou_Q - Bellman_expected_operator(mdp, gamma, tekitou_Q, policy)).max())\n",
        "\n",
        "\n",
        "# チャレンジ：NとHを変えて挙動を確認してみましょう．何が言えるでしょうか？"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "ちゃんと期待していた挙動が確認できたでしょうか？\n",
        "続いて，期待ベルマン作用素と最適ベルマン作用素の収束性を確認してみましょう．\n",
        "授業でやったように，\n",
        "* $Q_{k+1}=B^\\pi (Q_k)$によって$Q_0, Q_1, …, Q_k, Q_{k+1}, \\dots$と更新し続けると，$\\lim_{k\\to\\infty} Q_k=Q^\\pi$ に収束します．つまり，$\\|Q_{k+1}-B^\\pi (Q_k)\\|_\\infty$はだんだん小さくなるはずです．\n",
        "* $Q_{k+1}=B (Q_k)$によって$Q_0, Q_1, …, Q_k, Q_{k+1}, \\dots$と更新し続けると，$\\lim_{k\\to\\infty} Q_k=Q^{\\pi^*}$ に収束します．つまり，$\\|Q_{k+1}-B (Q_k)\\|_\\infty$はだんだん小さくなるはずです．"
      ],
      "metadata": {
        "id": "Ch5MgW8q5wxL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f9murOmQy7f9",
        "outputId": "f01fa01b-d1ca-4959-bf98-cde1c8b05c6a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 526
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "最初の誤差: 0.6408053099168388\n",
            "最終的な誤差： 4.440892098500626e-16\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'iteration')"
            ]
          },
          "metadata": {},
          "execution_count": 16
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# 適当な方策を作ります\n",
        "policy = np.random.rand(mdp.S, mdp.A)\n",
        "policy = policy / np.sum(policy, axis=1, keepdims=True)\n",
        "\n",
        "Q = np.random.rand(mdp.S, mdp.A)  # Q関数の初期値です\n",
        "errors = []\n",
        "# ベルマン期待作用素を繰り返し適用して、収束するか確認してみます\n",
        "for i in range(100):\n",
        "    BQ = Bellman_expected_operator(mdp, gamma, Q, policy)\n",
        "    errors.append(np.abs(Q - BQ).max())\n",
        "    Q = BQ\n",
        "\n",
        "print(\"最初の誤差:\", errors[0])\n",
        "print(\"最終的な誤差：\", errors[-1])\n",
        "plt.plot(errors)\n",
        "plt.title(\"Bellman Expected Operator\")\n",
        "plt.ylabel(\"Bellman Error: \" + r\"$\\|Q_k - B^\\pi(Q_{k})\\|_\\infty$\")\n",
        "plt.xlabel(\"iteration\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "Q = np.random.rand(mdp.S, mdp.A)  # Q関数の初期値です\n",
        "errors = []\n",
        "# ベルマン最適作用素を繰り返し適用して、収束するか確認してみます\n",
        "for i in range(100):\n",
        "    BQ = Bellman_optimal_operator(mdp, gamma, Q)\n",
        "    errors.append(np.abs(Q - BQ).max())\n",
        "    Q = BQ\n",
        "\n",
        "print(\"最初の誤差:\", errors[0])\n",
        "print(\"最終的な誤差：\", errors[-1])\n",
        "plt.plot(errors)\n",
        "plt.title(\"Bellman Optimal Operator\")\n",
        "plt.ylabel(\"Bellman Error: \" + r\"$\\|Q_k - B(Q_{k})\\|_\\infty$\")\n",
        "plt.xlabel(\"iteration\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 526
        },
        "id": "_wdpmrdL_gJL",
        "outputId": "9e9d9523-e21e-4e9e-e699-80edc4f49032"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "最初の誤差: 1.3227388937656097\n",
            "最終的な誤差： 4.440892098500626e-16\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'iteration')"
            ]
          },
          "metadata": {},
          "execution_count": 17
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "最後に，後で便利なので，ベルマン期待作用素を使って方策の期待収益を計算する関数を作ります．これはモンテカルロ近似よりも精度が良いです．\n",
        "\n",
        "授業の内容を思い出すと，期待収益とQ値には次の関係が成立します：\n",
        "\n",
        "$$\n",
        "\\mathbb{E}^\\pi[R] = \\sum_{a\\in A}\\pi(a \\mid s_0) Q^\\pi(s_0, a)\n",
        "$$"
      ],
      "metadata": {
        "id": "fnDOyWOlxwmR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def ExpectedReturnBellman(mdp: MDP, gamma: float, policy: np.ndarray):\n",
        "  \"\"\"期待収益をベルマン期待作用素で近似します．\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    policy (np.ndarray): 期待収益を近似したい方策です\n",
        "  \"\"\"\n",
        "  Q = np.random.rand(mdp.S, mdp.A)  # Q関数の初期値です\n",
        "  # 収束するまでベルマン期待作用素を繰り返し適用します\n",
        "  while True:\n",
        "      BQ = Bellman_expected_operator(mdp, gamma, Q, policy)\n",
        "      if np.abs(Q - BQ).max() <= 1e-4:\n",
        "        break  #  収束したら抜けます\n",
        "      Q = BQ\n",
        "  expected_return = (policy * Q).sum(axis=-1)[mdp.s0]  # Q値から収益に直します\n",
        "  return expected_return\n",
        "\n",
        "\n",
        "# テストです\n",
        "policy = np.random.rand(mdp.S, mdp.A)\n",
        "policy = policy / policy.sum(axis=-1, keepdims=True)\n",
        "print(\"適当な方策の期待収益：\", ExpectedReturnBellman(mdp, gamma, policy))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BIBC-41qxvyp",
        "outputId": "fc6fd2af-586e-4e31-d8f6-54205acb6dba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "適当な方策の期待収益： 1.493573421326876\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 価値反復法と方策反復法\n",
        "\n",
        "ベルマン期待作用素もベルマン最適作用素も，ベルマン誤差が収束していく様子が確認できました．これを利用するのが**価値反復法**と**方策反復法**です．実装してみましょう．\n",
        "価値反復法は次を繰り返します．（ここで$\\operatorname{Gr}(Q)$は$Q\\in \\mathbb{R}^{S\\times A}$ に対する貪欲方策です）\n",
        "\n",
        "* 方策更新：$\\pi_{k+1} = \\operatorname{Gr}(Q_k)$\n",
        "* 方策評価：$Q_{k+1} = B^{\\pi_{k+1}}(Q_k)$\n",
        "\n",
        "授業でやったように，これはベルマン最適作用素$Q_{k+1} = B(Q_k)$による更新と等価です．\n",
        "\n",
        "せっかくなので，ちょっと難しめのマルコフ決定過程を作ってみます（遷移と報酬がスパースです．実装をみて考えてみましょう．）"
      ],
      "metadata": {
        "id": "NPgrvQsq_upp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from dataclasses import dataclass\n",
        "\n",
        "# 大きめのマルコフ決定過程で実験してみます．サイズを変えて遊んでみてください．\n",
        "_S = 40  # 状態集合のサイズ\n",
        "_A = 10   # 行動集合のサイズ\n",
        "_S_set = np.arange(_S)  # 状態集合．初期状態は_S_set[0]とします．\n",
        "_A_set = np.arange(_A)  # 行動集合\n",
        "\n",
        "# 報酬行列を適当に作ります．どこか一つの状態行動だけが正解な，スパースな報酬を作ります．\n",
        "_rew = np.zeros((_S * _A))\n",
        "_rew[np.random.choice(_S*_A)] = 1.0\n",
        "_rew = _rew.reshape(_S, _A)\n",
        "assert _rew.shape == (_S, _A)\n",
        "\n",
        "# 遷移確率行列を適当に作ります．遷移先がスパースになるように作ります．\n",
        "_P = np.random.dirichlet(alpha=[0.01] * _S, size=(_S*_A))\n",
        "_P = _P.reshape(_S, _A, _S)\n",
        "np.testing.assert_almost_equal(_P.sum(axis=-1), 1)  # ちゃんと確率行列になっているか確認します\n",
        "\n",
        "\n",
        "mdp = MDP(_S_set, _A_set, _rew, _P)\n",
        "print(\"報酬関数のshape\", mdp.rew.shape)\n",
        "print(\"遷移確率行列のshape\",mdp.P.shape)\n",
        "print(\"初期状態\", mdp.s0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xjgck39Y3UdV",
        "outputId": "ceed1748-84f5-4569-ddb8-6066f98dc834"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "報酬関数のshape (40, 10)\n",
            "遷移確率行列のshape (40, 10, 40)\n",
            "初期状態 0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QrDhaPpsy7f9"
      },
      "outputs": [],
      "source": [
        "def compute_greedy_policy(Q: np.ndarray):\n",
        "  \"\"\"与えられたQ関数に対して貪欲方策を計算します\n",
        "  Args:\n",
        "    Q (np.ndarray): SxAの行列\n",
        "  \"\"\"\n",
        "  S, A = Q.shape\n",
        "  policy = np.zeros((S, A))\n",
        "  policy[np.arange(S), Q.argmax(axis=1)] = 1.0 # 貪欲方策を計算します\n",
        "  return policy\n",
        "\n",
        "\n",
        "def ValueIteration(mdp: MDP, gamma: float, iteration: int):\n",
        "  \"\"\"価値反復法アルゴリズムです．\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    iteration (int): イテレーションの回数です\n",
        "  \"\"\"\n",
        "  Q = np.zeros((mdp.S, mdp.A)) # 適当なQの初期値を生成します\n",
        "  for _ in range(iteration): # ベルマン最適作用素を繰り返し適用します\n",
        "    Q = Bellman_optimal_operator(mdp, gamma, Q)\n",
        "  return compute_greedy_policy(Q)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aea5MWGJy7f9"
      },
      "source": [
        "価値反復法が実装できました！\n",
        "価値反復法のイテレーションに応じて，得られる収益がどれくらいになるか見てみましょう．"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "gamma = 0.99\n",
        "returns = []\n",
        "for iteration in range(50):\n",
        "  policy_VI = ValueIteration(mdp, gamma, iteration)\n",
        "  return_VI = ExpectedReturnBellman(mdp, gamma, policy_VI)\n",
        "  returns.append(return_VI)\n",
        "\n",
        "\n",
        "print(\"最初の収益:\", returns[0])\n",
        "print(\"収束後の収益：\", returns[-1])\n",
        "plt.plot(returns)\n",
        "plt.title(\"Value Iteration\")\n",
        "plt.ylabel(\"Return\")\n",
        "plt.xlabel(\"iteration\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 526
        },
        "id": "o_IXWYQaBlsZ",
        "outputId": "443f3259-9626-42c5-eeee-5c83f0f621c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "最初の収益: 0.009928302593112382\n",
            "収束後の収益： 22.24752259408514\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'iteration')"
            ]
          },
          "metadata": {},
          "execution_count": 34
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHHCAYAAACle7JuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7Z0lEQVR4nO3deXxU9b3/8fdkmcm+QchC2EFQhHiNQJEqCFyBh1dqpVYt9YJWsRZaEb1WbgsK9iG2taBcEXt7LahXRNGCv2orVxGjKFoFWa2IGPZNluz7zPf3RzIDY0KSmcxyJryej8c8TM6ZOefDCW3efFebMcYIAAAgAkWFuwAAAAB/EWQAAEDEIsgAAICIRZABAAARiyADAAAiFkEGAABELIIMAACIWAQZAAAQsQgyAAAgYhFkALRo7969stlsWr58ebhLiQjLly+XzWbT3r17w10KcF4gyAAdyMSJE5WQkKCysrJzvmfy5Mmy2+06efJkCCvzz0MPPSSbzaYTJ054jq1YsUKPP/54+Ipq9Mgjj2jNmjXhLgM47xFkgA5k8uTJqqqq0urVq5s9X1lZqddee03jx49Xp06dQlxdYFg9yNxyyy2qqqpSjx49Ql8UcB4iyAAdyMSJE5WcnKwVK1Y0e/61115TRUWFJk+eHOLKrM3lcqm6ujog14qOjlZcXJxsNltArgegZQQZoAOJj4/X9ddfr3Xr1un48eNNzq9YsULJycmaOHGiTp06pfvuu0+DBg1SUlKSUlJSNGHCBG3durXV+4waNUqjRo1qcnzq1Knq2bOn1zGXy6XHH39cAwcOVFxcnLKysnTnnXfq9OnTPv/5Ro0apTfeeEP79u2TzWaTzWbzul9NTY0efPBB9e3bVw6HQ926ddP999+vmpoar+vYbDbNmDFDL7zwggYOHCiHw6E333xTkvTYY4/p8ssvV6dOnRQfH6+CggK98sorTT5fUVGhZ5991lPH1KlTJZ17jMxTTz3luVdubq6mT5+u4uLiJn++iy++WJ9//rmuuuoqJSQkqGvXrvrd737n87MCzhcx4S4AQGBNnjxZzz77rF5++WXNmDHDc/zUqVNau3atbr75ZsXHx2vnzp1as2aNbrjhBvXq1UvHjh3TH//4R40cOVKff/65cnNzA1LPnXfeqeXLl+vWW2/VL37xCxUVFenJJ5/UZ599pg8++ECxsbFtvtavfvUrlZSU6ODBg1q0aJEkKSkpSVJDYJo4caI2bNigadOm6cILL9T27du1aNEiffnll026gd555x3PM+rcubMnED3xxBOaOHGiJk+erNraWq1cuVI33HCDXn/9dV1zzTWSpOeff1633367hg4dqmnTpkmS+vTpc866H3roIc2bN09jx47VXXfdpV27dmnp0qX65JNPmjyD06dPa/z48br++uv1wx/+UK+88op++ctfatCgQZowYUKbnxVw3jAAOpT6+nqTk5Njhg8f7nX86aefNpLM2rVrjTHGVFdXG6fT6fWeoqIi43A4zPz5872OSTLLli3zHBs5cqQZOXJkk3tPmTLF9OjRw/P9+++/bySZF154wet9b775ZrPHv+3BBx80ksw333zjOXbNNdd43cPt+eefN1FRUeb9999v9s/9wQcfeI5JMlFRUWbnzp1NrlNZWen1fW1trbn44ovN6NGjvY4nJiaaKVOmNPn8smXLjCRTVFRkjDHm+PHjxm63m6uvvtrreT/55JNGkvnzn//sOTZy5EgjyTz33HOeYzU1NSY7O9tMmjSpyb0AGEPXEtDBREdH66abbtLGjRu9ujdWrFihrKwsjRkzRpLkcDgUFdXwfwFOp1MnT55UUlKS+vfvr82bNwekllWrVik1NVX/+q//qhMnTnheBQUFSkpK0vr16wNyH/e9LrzwQg0YMMDrXqNHj5akJvcaOXKkLrrooibXiY+P93x9+vRplZSU6IorrvD7mbz99tuqra3VzJkzPc9bku644w6lpKTojTfe8Hp/UlKSfvzjH3u+t9vtGjp0qL7++mu/7g90dAQZoANyD+Z1D/o9ePCg3n//fd10002Kjo6W1NAVs2jRIvXr108Oh0OdO3dWZmamtm3bppKSkoDUsXv3bpWUlKhLly7KzMz0epWXlzc7jqc999q5c2eT+1xwwQWS1ORevXr1avY6r7/+ur7zne8oLi5OGRkZyszM1NKlS/1+Jvv27ZMk9e/f3+u43W5X7969Pefd8vLymgwUTk9P92tMEXA+YIwM0AEVFBRowIABevHFF/Wf//mfevHFF2WM8Zqt9Mgjj2jOnDm67bbb9PDDDysjI0NRUVGaOXOmXC5Xi9e32WwyxjQ57nQ6vb53uVzq0qWLXnjhhWavk5mZ6cefrnkul0uDBg3SwoULmz3frVs3r+/Pbnlxe//99zVx4kRdeeWVeuqpp5STk6PY2FgtW7bsnDPBAs0dNL+tuecNgCADdFiTJ0/WnDlztG3bNq1YsUL9+vXTkCFDPOdfeeUVXXXVVXrmmWe8PldcXKzOnTu3eO309PRmuzq+3brQp08fvf322xoxYkSzwcEf55rW3KdPH23dulVjxozxe+rzq6++qri4OK1du1YOh8NzfNmyZW2u49vc68ns2rVLvXv39hyvra1VUVGRxo4d61etABrQtQR0UO7Wl7lz52rLli1N1o6Jjo5u8q/8VatW6dChQ61eu0+fPvriiy/0zTffeI5t3bpVH3zwgdf7fvjDH8rpdOrhhx9uco36+vom04/bIjExsdlunh/+8Ic6dOiQ/vSnPzU5V1VVpYqKilavHR0dLZvN5tWytHfv3mYXvktMTGxT/WPHjpXdbtfixYu9nvczzzyjkpISz0woAP6hRQbooHr16qXLL79cr732miQ1CTL/9m//pvnz5+vWW2/V5Zdfru3bt+uFF17wajU4l9tuu00LFy7UuHHj9JOf/ETHjx/X008/rYEDB6q0tNTzvpEjR+rOO+/UggULtGXLFl199dWKjY3V7t27tWrVKj3xxBP6wQ9+4NOfq6CgQC+99JJmzZqlIUOGKCkpSddee61uueUWvfzyy/rpT3+q9evXa8SIEXI6nfriiy/08ssva+3atbrssstavPY111yjhQsXavz48frRj36k48ePa8mSJerbt6+2bdvWpI63335bCxcuVG5urnr16qVhw4Y1uWZmZqZmz56tefPmafz48Zo4caJ27dqlp556SkOGDPEa2AvAD2GdMwUgqJYsWWIkmaFDhzY5V11dbe69916Tk5Nj4uPjzYgRI8zGjRubTK1ubvq1Mcb87//+r+ndu7ex2+3mkksuMWvXrm0y/drtv//7v01BQYGJj483ycnJZtCgQeb+++83hw8fbrH+5qZfl5eXmx/96EcmLS3NSPK6X21trfntb39rBg4caBwOh0lPTzcFBQVm3rx5pqSkxPM+SWb69OnN3vOZZ54x/fr1Mw6HwwwYMMAsW7bMU8fZvvjiC3PllVea+Ph4I8kzFfvb06/dnnzySTNgwAATGxtrsrKyzF133WVOnz7t9Z6RI0eagQMHNqnpXM8VgDE2YxhBBgAAIhNjZAAAQMQiyAAAgIhFkAEAABGLIAMAACIWQQYAAEQsggwAAIhYHX5BPJfLpcOHDys5OdnvZcsBAEBoGWNUVlam3Nxcr53jv63DB5nDhw832SwOAABEhgMHDigvL++c5zt8kElOTpbU8CBSUlLCXA0AAGiL0tJSdevWzfN7/Fw6fJBxdyelpKQQZAAAiDCtDQthsC8AAIhYBBkAABCxCDIAACBiEWQAAEDEIsgAAICIRZABAAARiyADAAAiFkEGAABELIIMAACIWAQZAAAQsQgyAAAgYhFkAABAxOrwm0YivGrqnYqy2RQbHfzM7HQZVdU55YiJatf9autdKq2uU029K4DVtcwYE7J7nQ9a22QO1vw7x88tMAL9s23LzyUtPlaJjvBECoIM/LZ251HtPFSi0up6lVTVeV6lZ31dU++SPTpKF+amKD8vVYPz0nRJt1T17pykqKiW/8dRU+/U3hOV2n28TF8dL9e+k5Uqr6lXZW29KmqcqqytV2WtU5W1TlXU1HsFj7jYKCXHxSrZEaPkuBglxcUo2RHb8N+4GNU7jUqrG2otra5v/G9DzdV1oQswANARPPL9QfrRsO5huTdBBn7ZfaxMdz6/qU3vrXW6tPVAsbYeKJa0T5KU5IjRxV1TlN8tTfl5acpNi1fRiXLtPlaur443vPadqpTT5d+/LKrrXKquq9E3ZTV+fV6S7DFR4t+HANC6EDS6nxNBBn7ZtO+0JKl7RoKuzc9RanysUuJilRrf8Eo567/FlbXaerBEWw8Ua9vBYu04VKrymnp99PUpffT1qRbvk+yIUd+sJPXNTFLvzCSlxscq0RGtBHuMEu3RirdHK9ERowR7tBLtMYqLjVZNvVNl1fUqq65XeU29yqrrGr4/6+vYKJtSGutLiYtVSnyMp/6UuIaWm+hWWowAAOFHkIFfth0qkSRNGJSt/xg3oMX3psbHqkenRE3Mz5Uk1Ttd+uqb8oZWmoMl2nawWMdLa9Src6L6dklSvy5J6tslWf2yktQl2eFzv3m8PVppCXb//mAAgIhCkIFfth0sliTl56X5/NmY6CgNyE7RgOwU3TgksHUBAM4vTL+Gz6rrnNp1tEySNKhrapirAQCczwgy8NkXR8tU5zRKT4hVXnp8uMsBAJzHCDIdyBdHS/X8xr1BXx9ie2O30uC8NNZ9AACEFWNkOpC7X9yiXcfK1C0jQaP6dwnafbYebBjoOziPbiUAQHjRItNBHDxdqV3HGsatfP1NRVDvtd0TZNKCeh8AAFpDkOkg3vvyhOfrQ8VVQbtPZW29dh9vCEy0yAAAwo0g00G8u+u45+tDp4MXZHYeLpXLSFkpDmWlxAXtPgAAtAVBpgOorXfpwz0nPd8Hs0WmYZsBaVDXtKDdAwCAtiLIdACb959WeU293CvqBzPIbG9c0TefbiUAgAUQZDqAd3d9I0m6qnGm0qmKWlXW1gflXtsaB/oOIsgAACyAINMBFH7ZEGSuzc9VkqNhRv3hILTKlFTVqehEw4woZiwBAKyAIBPhjpVW659HSmWzSVf066yuaQ0r7R4MwoDfHY3dSnnp8cpIZFNGAED4EWQi3HuNrTGDu6aqU5JDXRu3DAjGOBl3t5I/G0UCABAMBJkI925jkBl5QaYkeVpkgjEF273jNeNjAABWQZCJYPVOlzbsblgIb2TjQN9QtMiwEB4AwCoIMhFs68ESlVTVKTU+1jMdOlgtMifLazzh6OKuBBkAgDUQZCJYYeNqvt/t11kx0Q0/yrwgtchsaxzo2zszUSlxsQG9NgAA/iLIRLDCb42Pkc50LR0rrVad0xWwe3k2iqQ1BgBgIQSZCHWyvMbTSjLqrCDTOdEhe0yUXEY6WlIdsPu5B/qyfgwAwEoIMhFqw1cnZIx0YU6Kupy1eWNUlC0oa8kw0BcAYEUEmQjl3pbg7G4lN8+A3wCNkzlaUq3jZTWKskkDcwkyAADrIMhEIJfLeBbCazHIBKhFxt2tdEFWsuLt0QG5JgAAgUCQiUA7D5fqZEWtkhwxKuiR3uT8mbVkKgNyP7qVAABWRZCJQIVfNky7vrxPJ9ljmv4IA9215B5UPIiBvgAAiyHIRCDP+Jj+TbuVpLNaZALQtWSMOTNjianXAACLIchEmJLKOm3ef1pS8+NjpDMtMoeLq+VymXbd7+DpKhVX1ik22qYBOcntuhYAAIEW1iCzYMECDRkyRMnJyerSpYuuu+467dq1y+s91dXVmj59ujp16qSkpCRNmjRJx44dC1PF4ffBnhNyGalvlyTlpSc0+57s1DhF2aRap0vflNe0635bG1tjBmSnyBHDQF8AgLWENcgUFhZq+vTp+uijj/TWW2+prq5OV199tSoqKjzvueeee/TXv/5Vq1atUmFhoQ4fPqzrr78+jFWH17uN2xKcqzVGkmKjo5TduLZMe9eS2c5AXwCAhcWE8+Zvvvmm1/fLly9Xly5dtGnTJl155ZUqKSnRM888oxUrVmj06NGSpGXLlunCCy/URx99pO985zvhKDtsjDHNbkvQnK7p8TpcUq1DxVXNzmxqq62eFX0JMgAA67HUGJmSkoZ//WdkZEiSNm3apLq6Oo0dO9bzngEDBqh79+7auHFjs9eoqalRaWmp16uj2HWsTMdKaxQXG6WhvTJafG8g1pJxuYx2HGp4fmxNAACwIssEGZfLpZkzZ2rEiBG6+OKLJUlHjx6V3W5XWlqa13uzsrJ09OjRZq+zYMECpaamel7dunULdukhU9g4W2l4706Ki215vEog1pL5+kSFymvqFRcbpX5dkvy+DgAAwWKZIDN9+nTt2LFDK1eubNd1Zs+erZKSEs/rwIEDAaow/FraluDbuqY1DARuT4vM9kPFkhq2JYiJtsxfFQAAPMI6RsZtxowZev311/Xee+8pLy/Pczw7O1u1tbUqLi72apU5duyYsrOzm72Ww+GQw+EIdskhV15Tr0/3nZIkjezfpdX3n2mR8T/IbD3QuBAe68cAACwqrP/MNsZoxowZWr16td555x316tXL63xBQYFiY2O1bt06z7Fdu3Zp//79Gj58eKjLDauNe06qzmnUo1OCenVObPX9Z4+RMca/tWS2N67om9+NIAMAsKawtshMnz5dK1as0Guvvabk5GTPuJfU1FTFx8crNTVVP/nJTzRr1ixlZGQoJSVFP//5zzV8+PDzbsaSe1uCtnQrSWeCTEWtUyVVdUpLsPt0v3qnSzsPu1tk0nz6LAAAoRLWILN06VJJ0qhRo7yOL1u2TFOnTpUkLVq0SFFRUZo0aZJqamo0btw4PfXUUyGuNPzaOu3aLd4erc5Jdp0or9XB01U+B5ndx8tVXedSkiNGvdvQAgQAQDiENci0pcsjLi5OS5Ys0ZIlS0JQkTU5XUYHTjWMdcnvltbmz3VNi9eJ8lodKq7SxT6Oc3EvhHdx1xRFRdl8+iwAAKHCVJQIUF3n9Hyd5Gh79mzP5pHuhfDyWT8GAGBhBJkIUFnbEGRsNskR0/YfmWfArx8zl9wDfQexoi8AwMIIMhGgqjHIxMdGy2ZrezePv6v71tQ79c8jDSv60iIDALAygkwEqKo7E2R80bVxd2xfW2R2HS1TndMoPSFWeY3dUwAAWBFBJgJU1tZLapiJ5At/u5a2HCiWJA3KS/OpBQgAgFAjyEQAd4tMgq9BprE15VRFrScMtcXHRQ0rCA9px67ZAACEAkEmApw9RsYXqfGxSm6c5XS4ja0yxhh9/HVDkGlth20AAMKNIBMB3LOWfO1aks60yhxs44DfohMVOlFeI3tMlE9r1gAAEA4EmQjg72BfyfdxMv9o7Fa6pFua4vy4HwAAoUSQiQDurqUEu+8LMfu6KJ47yAyjWwkAEAEIMhHA3SLjTwuJry0y7oG+jI8BAEQCgkwEqKz1b9aS5FuLzMHTlTpUXKXoKJsu7c6MJQCA9RFkIkC1n9OvJd9aZNzdShd3TVWiD3s6AQAQLgSZCOBeA8avrqXGFpljpdWqc7pafK87yHyHbiUAQIQgyESA9nQtdU50yB4TJZeRjpZUt/jefzA+BgAQYQgyEcDdteTPOjJRUTZP91JLa8kcL6vW1ycqZLNJl/UgyAAAIgNBJgJU+rmyr1tbxsm4W2MGZKcoNSHWr/sAABBqBJkI0J51ZKSzgkwLLTKsHwMAiEQEmQjgWdnX7t+PK8+zTUHlOd9DkAEARCKCTAQ407XkZ4tMestdS8WVtfriaJkkaQhBBgAQQQgyEaCqHZtGSq2PkXG3xvTJTFTnJIdf9wAAIBwIMhGgqh0L4klnWmSOFFfL5TJNzp+Zdt3JzwoBAAgPgkwEqGrnrKXslDhFR9lU63Tpm/KaJuf/sZfxMQCAyESQsTiXy5w12Ne/IBMTHaXslDhJTdeSKa+p145DJZJYCA8AEHkIMhZXXe/0fO1v15J07nEym/adlstI3TLildv4HgAAIgVBxuLc3UqSFBfTjiBzjl2wP/76pCRpaE/GxwAAIg9BxuLcU6/jYqMUFWXz+zpnWmS815Jh/RgAQCQjyFicZ58lPwf6ujXXIlNd59TWg8WSGB8DAIhMBBmLq2zn9gRuzY2R+Wx/seqcRlkpDvXolNCu6wMAEA4EGYurbOdieG5nt8gY07CWzNnrx9hs/ndbAQAQLgQZiwtY11Jji0xFrVMlVXWSpI+LGgf60q0EAIhQBBmLC1SLTFxstDon2SU1rCVTW+/S5v2nJTHQFwAQudo38AJBVxWgFhmpoVXmRHmtDhVXqabepeo6l9ITYtU3M6nd1wYAIBxokbG4qtp6Se1bDM/t7HEyZ8bHZLRrWjcAAOFEi4zFBaprSfKeufT1N+WS2CgSABDZaJGxuEB3LUnS/lOV+nQv42MAAJGPFhmLq/KsIxOIrqWGtWI++OqEKmudSnLE6MKclHZfFwCAcKFFxuKC0SLj7q66rGe6ohkfAwCIYAQZizszRqb9jWfuwb5uwxgfAwCIcAQZiwtk11JqfKyS484EIhbCAwBEOoKMxQWya0k6070UFxulQV1TA3JNAADChSBjcZWN68gEYvq1JOU1di9d2j1d9hh+/ACAyMZvMourqnNJClyLzMDchlaYq/p3Ccj1AAAIJ6ZfW1wgV/aVpJ+O7KNLe6Tru307B+R6AACEE0HG4tyzluICFGTi7dEaeUFmQK4FAEC40bVkcdV1gZu1BABAR0OQsTh3i0xCLI1nAAB8G0HGwowxnunXcXZ+VAAAfBu/HS2spt4lYxq+TgjAyr4AAHQ0BBkLc6/qKwVu+jUAAB0JQcbCKhu7lewxUWzuCABAMwgyFhboNWQAAOhoCDIWVlUb2FV9AQDoaAgyFhbofZYAAOhoCDIWFuidrwEA6GgIMhbmnrXEGBkAAJpHkLEw96q+8awhAwBAswgyFnama4kfEwAAzeE3pIWd6VqiRQYAgOYQZCzMs88Sg30BAGgWQcbCKhnsCwBAiwgyFuZe2Zfp1wAANI8gY2Gewb60yAAA0CyCjIXRtQQAQMvCGmTee+89XXvttcrNzZXNZtOaNWu8zk+dOlU2m83rNX78+PAUGwbVrOwLAECLwhpkKioqlJ+fryVLlpzzPePHj9eRI0c8rxdffDGEFYbXmQXxCDIAADQnrAuUTJgwQRMmTGjxPQ6HQ9nZ2SGqyFo8QYYWGQAAmmX5MTLvvvuuunTpov79++uuu+7SyZMnW3x/TU2NSktLvV6Ryt21xIJ4AAA0z9JBZvz48Xruuee0bt06/fa3v1VhYaEmTJggp9N5zs8sWLBAqampnle3bt1CWHFg0bUEAEDLLP1P/Ztuusnz9aBBgzR48GD16dNH7777rsaMGdPsZ2bPnq1Zs2Z5vi8tLY3YMFPFYF8AAFpk6RaZb+vdu7c6d+6sr7766pzvcTgcSklJ8XpFqiqmXwMA0KKICjIHDx7UyZMnlZOTE+5Sgs4Yo0r3yr4EGQAAmhXWrqXy8nKv1pWioiJt2bJFGRkZysjI0Lx58zRp0iRlZ2drz549uv/++9W3b1+NGzcujFWHRq3TJZdp+JogAwBA88IaZD799FNdddVVnu/dY1umTJmipUuXatu2bXr22WdVXFys3NxcXX311Xr44YflcDjCVXLIuLuVJMbIAABwLmENMqNGjZIx5pzn165dG8JqrMU90Dc22qbY6IjqAQQAIGT4DWlRLIYHAEDrCDIWVcUaMgAAtIogY1FVrOoLAECrCDIWRdcSAACtI8hYFF1LAAC0jiBjUVV1DYvhsaovAADnRpCxKHfXUhxdSwAAnBNBxqLYZwkAgNYRZCyqisG+AAC0iiBjUe7p1wz2BQDg3AgyFlVJ1xIAAK0iyFgUXUsAALSOIGNRZ7qWWNkXAIBzIchYFCv7AgDQOoKMRVXXMUYGAIDWEGQsqrK2YWVfZi0BAHBuBBmLqqpzSaJrCQCAlhBkLKqqlr2WAABoDUHGothrCQCA1hFkLKqKwb4AALSKIGNRZzaNZB0ZAADOhSBjQXVOl+pdRhKDfQEAaAlBxoLc42Mkpl8DANASgowFubuVoqNsio22hbkaAACsiyBjQZ6BvrHRstkIMgAAnAtBxoLcq/rG0a0EAECLCDIWxD5LAAC0DUHGgtj5GgCAtiHIWJAnyNAiAwBAiwgyFkTXEgAAbUOQsSC6lgAAaBuCjAVVebqW2J4AAICWEGQs6Ox1ZAAAwLn59U/+iooKPfroo1q3bp2OHz8ul8vldf7rr78OSHHnK/c6Mgz2BQCgZX4Fmdtvv12FhYW65ZZblJOTw+qzAVZV2xAMCTIAALTMryDz97//XW+88YZGjBgR6HogqaqusUWGriUAAFrk1xiZ9PR0ZWRkBLoWNHIP9mX6NQAALfMryDz88MOaO3euKisrA10PxIJ4AAC0lV9dS3/4wx+0Z88eZWVlqWfPnoqNjfU6v3nz5oAUd75yz1qiawkAgJb5FWSuu+66AJeBs9G1BABA2/gcZOrr62Wz2XTbbbcpLy8vGDWd99xdS3G0yAAA0CKfx8jExMTo97//verr64NRD3T2Xkus7AsAQEv8Guw7evRoFRYWBroWNGKvJQAA2savf/JPmDBBDzzwgLZv366CggIlJiZ6nZ84cWJAijtfsbIvAABt41eQ+dnPfiZJWrhwYZNzNptNTqezfVWd56rrGlb2ZbAvAAAt8yvIfHtvJQROvdOlWmfjFgV0LQEA0CJ2v7YY9xoyEl1LAAC0xq8Wmfnz57d4fu7cuX4VgzNryNhskiOGnAkAQEv8CjKrV6/2+r6urk5FRUWKiYlRnz59CDLt4J6xlBAbza7iAAC0wq8g89lnnzU5VlpaqqlTp+r73/9+u4s6n3m2J2ANGQAAWhWwvouUlBTNmzdPc+bMCdQlz0tnNoykWwkAgNYE9LdlSUmJSkpKAnnJ845nVd9YWmQAAGiNX78tFy9e7PW9MUZHjhzR888/rwkTJgSksPOVZ58lZiwBANAqv4LMokWLvL6PiopSZmampkyZotmzZweksPNVVd2Zwb4AAKBlfgWZoqKiQNeBRlWN2xOwqi8AAK3za4zMbbfdprKysibHKyoqdNttt7W7qPMZXUsAALSdX0Hm2WefVVVVVZPjVVVVeu6559pd1PmMriUAANrOp66l0tJSGWNkjFFZWZni4uI855xOp/72t7+pS5cuAS/yfFLlmX5NkAEAoDU+BZm0tDTZbDbZbDZdcMEFTc7bbDbNmzcvYMWdjwgyAAC0nU9BZv369TLGaPTo0Xr11VeVkZHhOWe329WjRw/l5uYGvMjzSSXryAAA0GY+/bYcOXKkpIZZS927d2cvoCCoYmVfAADazK/flj169NCGDRv04x//WJdffrkOHTokSXr++ee1YcOGgBZ4vjkTZGiRAQCgNX4FmVdffVXjxo1TfHy8Nm/erJqaGkkNWxQ88sgjAS3wfOPuWopn1hIAAK3yK8j85je/0dNPP60//elPio2N9RwfMWKENm/eHLDizkfVjS0yLIgHAEDr/Aoyu3bt0pVXXtnkeGpqqoqLi9tb03mtsq5hZV9aZAAAaJ1fQSY7O1tfffVVk+MbNmxQ796923yd9957T9dee61yc3Nls9m0Zs0ar/PGGM2dO1c5OTmKj4/X2LFjtXv3bn9KjhiVTL8GAKDN/Aoyd9xxh+6++259/PHHstlsOnz4sF544QXde++9uuuuu9p8nYqKCuXn52vJkiXNnv/d736nxYsX6+mnn9bHH3+sxMREjRs3TtXV1f6UHRHoWgIAoO38mhrzwAMPyOVyacyYMaqsrNSVV14ph8Oh//iP/9Dtt9/e5utMmDBBEyZMaPacMUaPP/64fv3rX+t73/ueJOm5555TVlaW1qxZo5tuusmf0i2Pwb4AALSdXy0yNptNv/rVr3Tq1Cnt2LFDH330kb755hulpqaqV69eASmsqKhIR48e1dixYz3HUlNTNWzYMG3cuPGcn6upqVFpaanXK5Kwsi8AAG3nU5CpqanR7Nmzddlll2nEiBH629/+posuukg7d+5U//799cQTT+iee+4JSGFHjx6VJGVlZXkdz8rK8pxrzoIFC5Samup5devWLSD1hILTZVRT75JEiwwAAG3hU5CZO3euli5dqp49e6qoqEg33HCDpk2bpkWLFukPf/iDioqK9Mtf/jJYtbbJ7NmzVVJS4nkdOHAgrPX4wr3ztSQlsCAeAACt8um35apVq/Tcc89p4sSJ2rFjhwYPHqz6+npt3bo14NsVZGdnS5KOHTumnJwcz/Fjx47pkksuOefnHA6HHA5HQGsJFXe3kiTFxbJFAQAArfHpt+XBgwdVUFAgSbr44ovlcDh0zz33BGXPpV69eik7O1vr1q3zHCstLdXHH3+s4cOHB/x+VuAZHxMbzT5WAAC0gU8tMk6nU3a7/cyHY2KUlJTk983Ly8u91qMpKirSli1blJGRoe7du2vmzJn6zW9+o379+qlXr16aM2eOcnNzdd111/l9Tytzdy0x9RoAgLbxKcgYYzR16lRP1011dbV++tOfKjEx0et9f/nLX9p0vU8//VRXXXWV5/tZs2ZJkqZMmaLly5fr/vvvV0VFhaZNm6bi4mJ997vf1Ztvvqm4uDhfyo4YlbUNq/rGMdAXAIA28SnITJkyxev7H//4x+26+ahRo2SMOed5m82m+fPna/78+e26T6SoYjE8AAB84lOQWbZsWbDqgOhaAgDAV0yNsRD3Pkt0LQEA0DYEGQuhRQYAAN8QZCyE7QkAAPANQcZCKj3ryLCqLwAAbUGQsRB311K8nR8LAABtwW9MC6lqXEeGfZYAAGgbgoyFeFpkmLUEAECbEGQspJLBvgAA+IQgYyGs7AsAgG8IMhbi7lpiQTwAANqGIGMhlbTIAADgE4KMhVSzsi8AAD4hyFgIey0BAOAbgoyFnBnsyzoyAAC0BUHGQlhHBgAA3xBkLKTSs7IvQQYAgLYgyFiEy2VUXeeSxIJ4AAC0FUHGIqrrnZ6v6VoCAKBtCDIW4R7oKxFkAABoK4KMRbinXjtiohQVZQtzNQAARAaCjEVUsRgeAAA+I8hYhLtriW4lAADajiBjEe6uJWYsAQDQdgQZizizzxKr+gIA0FYEGYuopGsJAACfEWQswr2qL11LAAC0HUHGIqrZZwkAAJ8RZCyispbp1wAA+IogYxGena8JMgAAtBlBxiJYRwYAAN8RZCyCriUAAHxHkLEId9dSHEEGAIA2I8hYhLtrKYGuJQAA2owgYxFVrOwLAIDPCDIW4V4Qj64lAADajiBjEXQtAQDgO4KMRbCODAAAviPIWIRn00iCDAAAbUaQsQj2WgIAwHcEGYtgQTwAAHxHkLEAYwxjZAAA8ANBxgJq6l0ypuFrupYAAGg7gowFuLuVJIIMAAC+IMhYgLtbyR4dpZhofiQAALQVvzUtoKpxVV/GxwAA4BuCjAUwYwkAAP8QZCzAvT0B42MAAPANQcYCKpl6DQCAXwgyFlBNiwwAAH4hyFgA+ywBAOAfgowFuKdfM9gXAADfEGQsgMG+AAD4hyBjAWe6lmLCXAkAAJGFIGMBng0jaZEBAMAnBBkLcK/syxgZAAB8Q5CxgCrWkQEAwC8EGQuoZLAvAAB+IchYQBV7LQEA4BeCjAXQtQQAgH8IMhZA1xIAAP4hyFhANS0yAAD4hSBjAZWMkQEAwC8EGQs407XEyr4AAPjC0kHmoYceks1m83oNGDAg3GUFHF1LAAD4x/JNAAMHDtTbb7/t+T4mxvIl+8QYo0pW9gUAwC+WTwUxMTHKzs4OdxlBU+t0yWUavo5j1hIAAD6xdNeSJO3evVu5ubnq3bu3Jk+erP3794e7pIByL4Yn0SIDAICvLN0iM2zYMC1fvlz9+/fXkSNHNG/ePF1xxRXasWOHkpOTm/1MTU2NampqPN+XlpaGqly/uAf6xkbbFBtt+VwJAIClWDrITJgwwfP14MGDNWzYMPXo0UMvv/yyfvKTnzT7mQULFmjevHmhKrHd3Kv60q0EAIDvIqoJIC0tTRdccIG++uqrc75n9uzZKikp8bwOHDgQwgp9V1bdMNA3yWHpTAkAgCVFVJApLy/Xnj17lJOTc873OBwOpaSkeL2sbP+pSklSXnp8mCsBACDyWDrI3HfffSosLNTevXv14Ycf6vvf/76io6N18803h7u0gNl7okKS1LNTYpgrAQAg8li6P+PgwYO6+eabdfLkSWVmZuq73/2uPvroI2VmZoa7tIDZe7IxyHQmyAAA4CtLB5mVK1eGu4Sg23eyoWupR6eEMFcCAEDksXTX0vmAriUAAPxHkAmj0uo6nayolUSLDAAA/iDIhNH+xm6lzkl2JcfFhrkaAAAiD0EmjIroVgIAoF0IMmG0r3HGUg+CDAAAfiHIhNHexq6lnoyPAQDALwSZMPLMWGINGQAA/EKQCaMzLTIEGQAA/EGQCZPymnqdKK+RJPXoTNcSAAD+IMiEibtbqVOiXSlMvQYAwC8EmTBhawIAANqPIBMmns0iGR8DAIDfCDJhwowlAADajyATJnQtAQDQfgSZMKFrCQCA9iPIhEFFTb2OlzVMvSbIAADgP4JMGLi7ldITYpWawNRrAAD8RZAJAzaLBAAgMAgyYcBmkQAABAZBJgyYeg0AQGAQZMKAGUsAAAQGQSYMWEMGAIDAIMiEWFWtU0dLqyVJvehaAgCgXQgyIbbvVEO3Ump8rNIS7GGuBgCAyEaQCbG9J5ixBABAoBBkQswz0JduJQAA2o0gE2IshgcAQOAQZEKMriUAAAKHIBNidC0BABA4BJkQqq5z6khJw9RrFsMDAKD9CDIhtP9UQ7dSclyM0tn1GgCAdiPIhFBR4x5LvTonymazhbkaAAAiH0EmhJixBABAYBFkQmjvSWYsAQAQSASZENp7gl2vAQAIJIJMCLl3ve7ZmRYZAAACgSATItV1Th0uqZLEGBkAAAKFIBMiB05Vyhgp2RGjTonseg0AQCAQZELEPdC3R+cEpl4DABAgBJkQYeo1AACBR5AJEc9ieAQZAAAChiATIu4ZSz1YQwYAgIAhyIQIu14DABB4BJkQqKl36nCxe+o1LTIAAAQKQSYEDpyqkstIifZoZSY5wl0OAAAdBkEmBM6escTUawAAAocgEwLuGUtsTQAAQGARZELAs8cSU68BAAgogkwIeGYsEWQAAAgogkwI7PWMkaFrCQCAQCLIBFltvUuHTjdMve7FGjIAAAQUQSbIDp6ulMtI8bHRykxm6jUAAIFEkAmys7cmYOo1AACBRZAJMs9mkXQrAQAQcASZIDt7MTwAABBYBJkg2+tZQ4YZSwAABBpBJsjY9RoAgOAhyARRndOlg41Tr1kMDwCAwCPIBNGh01VyuoziYqPUhanXAAAEHEEmiPZ8Uy6poTUmKoqp1wAABBpBJkh2HyvTf67eLkm6KCclzNUAANAxxYS7gI5o64FiTV32D52urFO/Lkn65YQB4S4JAIAOiSATYBv3nNTtz36iilqn8vNStfzWoUpPtIe7LAAAOiSCTAC99fkxTV+xWbX1Ll3ep5P++98vU5KDRwwAQLDwWzZAVn92UPet2iany+hfL8rSf938L4qLjQ53WQAAdGgRMdh3yZIl6tmzp+Li4jRs2DD94x//CHdJXp79cK/ueWmrnC6j6y/tqqWTLyXEAAAQApYPMi+99JJmzZqlBx98UJs3b1Z+fr7GjRun48ePh7s0GWP0X+t268H/t1OSNPXynnrsB/mKibb8YwUAoEOw/G/chQsX6o477tCtt96qiy66SE8//bQSEhL05z//Oax1GWP0mzf+qT+89aUk6e4x/fTgtRexXgwAACFk6TEytbW12rRpk2bPnu05FhUVpbFjx2rjxo3NfqampkY1NTWe70tLSwNelzFGD7y6XS99ekCSNPffLtJt3+0V8PsAAICWWbpF5sSJE3I6ncrKyvI6npWVpaNHjzb7mQULFig1NdXz6tatW8Drstls6peVpCib9NgN+YQYAADCxNJBxh+zZ89WSUmJ53XgwIGg3Of2K3rr/+65Uj8oyAvK9QEAQOss3bXUuXNnRUdH69ixY17Hjx07puzs7GY/43A45HCEZoPGvl2SQ3IfAADQPEu3yNjtdhUUFGjdunWeYy6XS+vWrdPw4cPDWBkAALACS7fISNKsWbM0ZcoUXXbZZRo6dKgef/xxVVRU6NZbbw13aQAAIMwsH2RuvPFGffPNN5o7d66OHj2qSy65RG+++WaTAcAAAOD8YzPGmHAXEUylpaVKTU1VSUmJUlJSwl0OAABog7b+/rb0GBkAAICWEGQAAEDEIsgAAICIRZABAAARiyADAAAiFkEGAABELIIMAACIWAQZAAAQsQgyAAAgYll+i4L2ci9cXFpaGuZKAABAW7l/b7e2AUGHDzJlZWWSpG7duoW5EgAA4KuysjKlpqae83yH32vJ5XLp8OHDSk5Ols1mC9h1S0tL1a1bNx04cIA9nEKA5x1aPO/Q45mHFs87tPx53sYYlZWVKTc3V1FR5x4J0+FbZKKiopSXlxe066ekpPA/ghDieYcWzzv0eOahxfMOLV+fd0stMW4M9gUAABGLIAMAACIWQcZPDodDDz74oBwOR7hLOS/wvEOL5x16PPPQ4nmHVjCfd4cf7AsAADouWmQAAEDEIsgAAICIRZABAAARiyADAAAiFkHGT0uWLFHPnj0VFxenYcOG6R//+Ee4S+oQ3nvvPV177bXKzc2VzWbTmjVrvM4bYzR37lzl5OQoPj5eY8eO1e7du8NTbAewYMECDRkyRMnJyerSpYuuu+467dq1y+s91dXVmj59ujp16qSkpCRNmjRJx44dC1PFkW3p0qUaPHiwZ1Gw4cOH6+9//7vnPM86eB599FHZbDbNnDnTc4znHVgPPfSQbDab12vAgAGe88F63gQZP7z00kuaNWuWHnzwQW3evFn5+fkaN26cjh8/Hu7SIl5FRYXy8/O1ZMmSZs//7ne/0+LFi/X000/r448/VmJiosaNG6fq6uoQV9oxFBYWavr06froo4/01ltvqa6uTldffbUqKio877nnnnv017/+VatWrVJhYaEOHz6s66+/PoxVR668vDw9+uij2rRpkz799FONHj1a3/ve97Rz505JPOtg+eSTT/THP/5RgwcP9jrO8w68gQMH6siRI57Xhg0bPOeC9rwNfDZ06FAzffp0z/dOp9Pk5uaaBQsWhLGqjkeSWb16ted7l8tlsrOzze9//3vPseLiYuNwOMyLL74Yhgo7nuPHjxtJprCw0BjT8HxjY2PNqlWrPO/55z//aSSZjRs3hqvMDiU9Pd38z//8D886SMrKyky/fv3MW2+9ZUaOHGnuvvtuYwx/t4PhwQcfNPn5+c2eC+bzpkXGR7W1tdq0aZPGjh3rORYVFaWxY8dq48aNYays4ysqKtLRo0e9nn1qaqqGDRvGsw+QkpISSVJGRoYkadOmTaqrq/N65gMGDFD37t155u3kdDq1cuVKVVRUaPjw4TzrIJk+fbquueYar+cq8Xc7WHbv3q3c3Fz17t1bkydP1v79+yUF93l3+E0jA+3EiRNyOp3KysryOp6VlaUvvvgiTFWdH44ePSpJzT579zn4z+VyaebMmRoxYoQuvvhiSQ3P3G63Ky0tzeu9PHP/bd++XcOHD1d1dbWSkpK0evVqXXTRRdqyZQvPOsBWrlypzZs365NPPmlyjr/bgTds2DAtX75c/fv315EjRzRv3jxdccUV2rFjR1CfN0EGgKSGf7nu2LHDq08bgde/f39t2bJFJSUleuWVVzRlyhQVFhaGu6wO58CBA7r77rv11ltvKS4uLtzlnBcmTJjg+Xrw4MEaNmyYevTooZdfflnx8fFBuy9dSz7q3LmzoqOjm4y0PnbsmLKzs8NU1fnB/Xx59oE3Y8YMvf7661q/fr3y8vI8x7Ozs1VbW6vi4mKv9/PM/We329W3b18VFBRowYIFys/P1xNPPMGzDrBNmzbp+PHjuvTSSxUTE6OYmBgVFhZq8eLFiomJUVZWFs87yNLS0nTBBRfoq6++Curfb4KMj+x2uwoKCrRu3TrPMZfLpXXr1mn48OFhrKzj69Wrl7Kzs72efWlpqT7++GOevZ+MMZoxY4ZWr16td955R7169fI6X1BQoNjYWK9nvmvXLu3fv59nHiAul0s1NTU86wAbM2aMtm/fri1btnhel112mSZPnuz5mucdXOXl5dqzZ49ycnKC+/e7XUOFz1MrV640DofDLF++3Hz++edm2rRpJi0tzRw9ejTcpUW8srIy89lnn5nPPvvMSDILFy40n332mdm3b58xxphHH33UpKWlmddee81s27bNfO973zO9evUyVVVVYa48Mt11110mNTXVvPvuu+bIkSOeV2Vlpec9P/3pT0337t3NO++8Yz799FMzfPhwM3z48DBWHbkeeOABU1hYaIqKisy2bdvMAw88YGw2m/m///s/YwzPOtjOnrVkDM870O69917z7rvvmqKiIvPBBx+YsWPHms6dO5vjx48bY4L3vAkyfvqv//ov0717d2O3283QoUPNRx99FO6SOoT169cbSU1eU6ZMMcY0TMGeM2eOycrKMg6Hw4wZM8bs2rUrvEVHsOaetSSzbNkyz3uqqqrMz372M5Oenm4SEhLM97//fXPkyJHwFR3BbrvtNtOjRw9jt9tNZmamGTNmjCfEGMOzDrZvBxmed2DdeOONJicnx9jtdtO1a1dz4403mq+++spzPljP22aMMe1r0wEAAAgPxsgAAICIRZABAAARiyADAAAiFkEGAABELIIMAACIWAQZAAAQsQgyAAAgYhFkAATUqFGjNHPmzHCX4cVms2nNmjXhLgNAELAgHoCAOnXqlGJjY5WcnKyePXtq5syZIQs2Dz30kNasWaMtW7Z4HT969KjS09PlcDhCUgeA0IkJdwEAOpaMjIyAX7O2tlZ2u93vz7ObMdBx0bUEIKDcXUujRo3Svn37dM8998hms8lms3nes2HDBl1xxRWKj49Xt27d9Itf/EIVFRWe8z179tTDDz+sf//3f1dKSoqmTZsmSfrlL3+pCy64QAkJCerdu7fmzJmjuro6SdLy5cs1b948bd261XO/5cuXS2ratbR9+3aNHj1a8fHx6tSpk6ZNm6by8nLP+alTp+q6667TY489ppycHHXq1EnTp0/33AuAdRBkAATFX/7yF+Xl5Wn+/Pk6cuSIjhw5Iknas2ePxo8fr0mTJmnbtm166aWXtGHDBs2YMcPr84899pjy8/P12Wefac6cOZKk5ORkLV++XJ9//rmeeOIJ/elPf9KiRYskSTfeeKPuvfdeDRw40HO/G2+8sUldFRUVGjdunNLT0/XJJ59o1apVevvtt5vcf/369dqzZ4/Wr1+vZ599VsuXL/cEIwDWQdcSgKDIyMhQdHS0kpOTvbp2FixYoMmTJ3vGzfTr10+LFy/WyJEjtXTpUsXFxUmSRo8erXvvvdfrmr/+9a89X/fs2VP33XefVq5cqfvvv1/x8fFKSkpSTExMi11JK1asUHV1tZ577jklJiZKkp588klde+21+u1vf6usrCxJUnp6up588klFR0drwIABuuaaa7Ru3TrdcccdAXk+AAKDIAMgpLZu3apt27bphRde8BwzxsjlcqmoqEgXXnihJOmyyy5r8tmXXnpJixcv1p49e1ReXq76+nqlpKT4dP9//vOfys/P94QYSRoxYoRcLpd27drlCTIDBw5UdHS05z05OTnavn27T/cCEHwEGQAhVV5erjvvvFO/+MUvmpzr3r275+uzg4Ykbdy4UZMnT9a8efM0btw4paamauXKlfrDH/4QlDpjY2O9vrfZbHK5XEG5FwD/EWQABI3dbpfT6fQ6dumll+rzzz9X3759fbrWhx9+qB49euhXv/qV59i+fftavd+3XXjhhVq+fLkqKio8YemDDz5QVFSU+vfv71NNAMKPwb4AgqZnz5567733dOjQIZ04cUJSw8yjDz/8UDNmzNCWLVu0e/duvfbaa00G235bv379tH//fq1cuVJ79uzR4sWLtXr16ib3Kyoq0pYtW3TixAnV1NQ0uc7kyZMVFxenKVOmaMeOHVq/fr1+/vOf65ZbbvF0KwGIHAQZAEEzf/587d27V3369FFmZqYkafDgwSosLNSXX36pK664Qv/yL/+iuXPnKjc3t8VrTZw4Uffcc49mzJihSy65RB9++KFnNpPbpEmTNH78eF111VXKzMzUiy++2OQ6CQkJWrt2rU6dOqUhQ4boBz/4gcaMGaMnn3wycH9wACHDyr4AACBi0SIDAAAiFkEGAABELIIMAACIWAQZAAAQsQgyAAAgYhFkAABAxCLIAACAiEWQAQAAEYsgAwAAIhZBBgAARCyCDAAAiFgEGQAAELH+P40jrb63KHrfAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "続いて，方策反復法を実装します．方策反復法はベルマン期待作用素を十分な回数実行し，$Q^\\pi$を計算します．\n",
        "\n",
        "* 方策更新：$\\pi_{k+1} = \\operatorname{Gr}(Q_k)$\n",
        "* 方策評価：$Q_{k+1} = Q^{\\pi_{k+1}}$"
      ],
      "metadata": {
        "id": "UZyAHgbZT8gO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def PolicyIteration(mdp: MDP, gamma: float, iteration: int):\n",
        "  \"\"\"\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    iteration (int): 方策更新の回数です\n",
        "  \"\"\"\n",
        "  Q = np.zeros((mdp.S, mdp.A)) # 適当なQの初期値を生成します\n",
        "  policy = np.ones((mdp.S, mdp.A)) / mdp.A  # 適当な方策の初期値を生成します\n",
        "  for _ in range(iteration): # 方策更新を繰り返します\n",
        "\n",
        "    # 十分な回数ベルマン期待作用素を繰り返してQpiを計算します\n",
        "    for _ in range(100):\n",
        "      Q = Bellman_expected_operator(mdp, gamma, Q, policy)\n",
        "\n",
        "    # 方策更新をします\n",
        "    policy = compute_greedy_policy(Q)\n",
        "  return policy"
      ],
      "metadata": {
        "id": "7ONpxNSxT_on"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "方策反復法が実装できました！\n",
        "方策反復法のイテレーションに応じて，得られる収益がどれくらいになるか見てみましょう．"
      ],
      "metadata": {
        "id": "8HGkUQD4XOQl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "gamma = 0.99\n",
        "returns = []\n",
        "for iteration in range(50):\n",
        "  policy_PI = PolicyIteration(mdp, gamma, iteration)\n",
        "  return_PI = ExpectedReturnBellman(mdp, gamma, policy_PI)\n",
        "  returns.append(return_PI)\n",
        "\n",
        "\n",
        "print(\"最初の収益:\", returns[0])\n",
        "print(\"収束後の収益：\", returns[-1])\n",
        "plt.plot(returns)\n",
        "plt.title(\"Policy Iteration\")\n",
        "plt.ylabel(\"Return\")\n",
        "plt.xlabel(\"iteration\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 526
        },
        "id": "DqNkXNX1XNxV",
        "outputId": "a42db260-6d6a-49f9-d9b7-7cc77a67f754"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "最初の収益: 0.15565560410758736\n",
            "収束後の収益： 22.247476468494074\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'iteration')"
            ]
          },
          "metadata": {},
          "execution_count": 36
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHHCAYAAACle7JuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAzbElEQVR4nO3deXhU9dn/8c9kmwTIQlgSIgECyqIWfETFFFlEHoHHiwpiBasV3KgWqog+VqogiDZa64ZS7CpgQXhQwcu6Cxh+yKKyiKhQwLCVHSWBwAxJ5vv7A+fgGFAyc5ZMeL+ua65mzjlz5s6X9Lpv7/M95+szxhgBAADEoQSvAwAAAIgWhQwAAIhbFDIAACBuUcgAAIC4RSEDAADiFoUMAACIWxQyAAAgblHIAACAuEUhAwAA4haFDICT6tmzp3r27Gm937x5s3w+n6ZOnepZTPGAcQLcQyED1CFTp06Vz+ezXqmpqWrbtq1Gjhyp3bt3ex1eVD744AP5fD69/PLL1rYlS5Zo/PjxOnDggHeBSZo5c6aefvppT2MATndJXgcAwH4PPfSQCgoKFAgEtHjxYk2ZMkVvvvmm1q5dq3r16kV93pYtW+rIkSNKTk62MdqaW7JkiSZMmKBhw4YpKyvLszhmzpyptWvXatSoURHba8s4AacDChmgDurXr58uuOACSdItt9yiRo0a6cknn9Rrr72ma6+9Nurzhrs8ddXhw4djKvTC6vo4AbUJl5aA00CvXr0kSSUlJZKkyspKTZw4UW3atJHf71erVq30u9/9TsFg8AfPc7K5H+vWrdM111yjJk2aKC0tTe3atdP9998vSVq4cKF8Pp/mzp1b7XwzZ86Uz+fT0qVLT/l3GT9+vP73f/9XklRQUGBdRtu8ebN1zD//+U917txZaWlpys7O1pAhQ7Rt27aI8/Ts2VPnnnuuVqxYoe7du6tevXr63e9+J0l67bXXdMUVVygvL09+v19t2rTRxIkTVVVVFfH5N954Q1u2bLFiaNWq1Q+O04IFC9StWzfVr19fWVlZuvLKK/Xll19W+/18Pp82btxodZwyMzN144036vDhw6c8TsDpgo4McBrYtGmTJKlRo0aSjnVppk2bpquvvlp33323li9frqKiIn355ZcnLDh+yJo1a9StWzclJydr+PDhatWqlTZt2qTXX39djzzyiHr27Kn8/HzNmDFDAwcOjPjsjBkz1KZNGxUWFp7y91111VX697//rZdeeklPPfWUGjduLElq0qSJJOmRRx7R2LFjdc011+iWW27R3r179eyzz6p79+5atWpVxKWo/fv3q1+/fhoyZIiuv/565eTkSDo216hBgwYaPXq0GjRooAULFmjcuHEqKyvT448/Lkm6//77VVpaqu3bt+upp56SJDVo0OCkcb///vvq16+fWrdurfHjx+vIkSN69tln1bVrV61cudIqgsKuueYaFRQUqKioSCtXrtTf/vY3NW3aVI899tgpjxVwWjAA6owXXnjBSDLvv/++2bt3r9m2bZuZNWuWadSokUlLSzPbt283q1evNpLMLbfcEvHZe+65x0gyCxYssLb16NHD9OjRw3pfUlJiJJkXXnjB2ta9e3eTnp5utmzZEnG+UChk/TxmzBjj9/vNgQMHrG179uwxSUlJ5sEHH/zB32nhwoVGkpkzZ4617fHHHzeSTElJScSxmzdvNomJieaRRx6J2P7ZZ5+ZpKSkiO09evQwkszzzz9f7TsPHz5cbduvfvUrU69ePRMIBKxtV1xxhWnZsmW1Y080Tuedd55p2rSp2b9/v7Xt008/NQkJCeaGG26wtj344INGkrnpppsizjlw4EDTqFGjat8FnO64tATUQb1791aTJk2Un5+vIUOGqEGDBpo7d67OOOMMvfnmm5Kk0aNHR3zm7rvvliS98cYbp/w9e/fu1aJFi3TTTTepRYsWEft8Pp/18w033KBgMBhx59Hs2bNVWVmp66+/vsa/38m8+uqrCoVCuuaaa7Rv3z7rlZubq7POOksLFy6MON7v9+vGG2+sdp60tDTr54MHD2rfvn3q1q2bDh8+rHXr1tU4rp07d2r16tUaNmyYsrOzre0dO3bUf//3f1v/Jt912223Rbzv1q2b9u/fr7Kyshp/P1CXcWkJqIMmT56stm3bKikpSTk5OWrXrp0SEo79d8uWLVuUkJCgM888M+Izubm5ysrK0pYtW075e7766itJ0rnnnvuDx7Vv314XXnihZsyYoZtvvlnSsctKF198cbU4YrFhwwYZY3TWWWedcP/37yI644wzlJKSUu24zz//XA888IAWLFhQrXAoLS2tcVzhMW3Xrl21fR06dNA777yj8vJy1a9f39r+/cKwYcOGkqRvvvlGGRkZNY4BqKsoZIA66KKLLrLuWjqZ73ZM3HDDDTfozjvv1Pbt2xUMBrVs2TI999xztn5HKBSSz+fTW2+9pcTExGr7vz+H5budl7ADBw6oR48eysjI0EMPPaQ2bdooNTVVK1eu1G9/+1uFQiFbYz6ZE8UvScYYV74fiBcUMsBppmXLlgqFQtqwYYM6dOhgbd+9e7cOHDigli1bnvK5WrduLUlau3btjx47ZMgQjR49Wi+99JL1jJXBgwfX/BfQyYuwNm3ayBijgoICtW3bNqpzf/DBB9q/f79effVVde/e3doevuPrVOL4vvCYrl+/vtq+devWqXHjxhHdGACnjjkywGnmf/7nfySp2hNpn3zySUnSFVdcccrnatKkibp3765//OMf2rp1a8S+73cOGjdurH79+umf//ynZsyYob59+1p3HNVUOOl//8m+V111lRITEzVhwoRq32+M0f79+3/03OFOyHc/f/ToUf3pT386YRyncqmpWbNmOu+88zRt2rSImNeuXat3333X+jcBUHN0ZIDTTKdOnTR06FD95S9/sS6jfPTRR5o2bZoGDBigSy+9tEbnmzRpki655BKdf/75Gj58uAoKCrR582a98cYbWr16dcSxN9xwg66++mpJ0sSJE6P+HTp37izp2C3QQ4YMUXJysvr37682bdro4Ycf1pgxY7R582YNGDBA6enpKikp0dy5czV8+HDdc889P3jun/70p2rYsKGGDh2qO+64Qz6fTy+++OIJL+l07txZs2fP1ujRo3XhhReqQYMG6t+//wnP+/jjj6tfv34qLCzUzTffbN1+nZmZqfHjx0c9FsBpz7sbpgDYLXz79ccff/yDx1VUVJgJEyaYgoICk5ycbPLz882YMWMibi025tRuvzbGmLVr15qBAwearKwsk5qaatq1a2fGjh1b7XuDwaBp2LChyczMNEeOHDml3+lEt18bY8zEiRPNGWecYRISEqrdiv3KK6+YSy65xNSvX9/Ur1/ftG/f3owYMcKsX78+4nc755xzTvidH374obn44otNWlqaycvLM/fee6955513jCSzcOFC67hDhw6ZX/ziFyYrK8tIsm7FPtk4vf/++6Zr164mLS3NZGRkmP79+5svvvgi4pjw7dd79+6N2B7+t/3+LefA6c5nDDPHALijsrJSeXl56t+/v/7+9797HQ6AOoA5MgBcM2/ePO3du1c33HCD16EAqCPoyABw3PLly7VmzRpNnDhRjRs31sqVK70OCUAdQUcGgOOmTJmi22+/XU2bNtX06dO9DgdAHUJHBgAAxC06MgAAIG5RyAAAgLhV5x+IFwqFtGPHDqWnp7u+tgwAAIiOMUYHDx5UXl6etejtidT5QmbHjh3Kz8/3OgwAABCFbdu2qXnz5ifdX+cLmfT0dEnHBiIjI8PjaAAAwKkoKytTfn6+lcdPps4XMuHLSRkZGRQyAADEmR+bFsJkXwAAELcoZAAAQNyikAEAAHGLQgYAAMQtChkAABC3KGQAAEDcopABAABxi0IGAADELQoZAAAQtyhkAABA3KKQAQAAcYtCBgAAxK06v2hkXXG0MqT95UFJkjHHtn37PzLhDR74scW84O2/T6zq6r+v3f8mPzZOtfVvIB7/fe0cSzt+f7f/lmqrrLRk1fd7U1JQyNRy+w8FNW3pFr24dLO+OVzhdTgAAFTz+4E/0S+6tPDkuylkaqnN+8r11//3lV5esV3BypAkKTHBp4Rvi3WfrB8s8VnHAwDiXaKHE1UoZGqZVVu/0V8WfaW3P99lXULq2DxTw7u3Vt9zcpXk5V8LAAC1DIVMLRAKGS1Yt0d/WfSVPtr8tbX90nZNNLx7G13cOjtur5sCAOAkChmPHT5aqZ8/v1Sf7yiTJCUn+vSzTmdoePfWapeb7nF0AADUbhQyHlux5Rt9vqNMqckJGlrYSjd2LVBuZqrXYQEAEBcoZDy2budBSVKv9k015n86eBwNAADxhZmjHvty17FLSu1zMzyOBACA+EMh47H1u451ZNozHwYAgBqjkPFQZVVIG3YfkkRHBgCAaFDIeKhkX7mOVoVUPyVRzRumeR0OAABxh0LGQ+u+vazULjddCQk8JwYAgJqikPHQum8n+rbjshIAAFGhkPFQ+NbrDs2Y6AsAQDQoZDy0zrpjiY4MAADRoJDxSFmgQv85cESS1C6HjgwAANGgkPFI+PkxeZmpyqyX7HE0AADEJwoZj3z3jiUAABAdChmPrNv57dIEzZgfAwBAtChkPLKOpQkAAIgZhYwHjDHfWWOJjgwAANGikPHA9m+O6FCwUsmJPrVuUt/rcAAAiFsUMh4IX1Y6s2m6khP5JwAAIFpkUQ+s/3ZpAubHAAAQGwoZD3zJRF8AAGxBIeMBbr0GAMAeFDIuC1RUqWRfuSQ6MgAAxIpCxmUb9xxSyEgN6yWrabrf63AAAIhrFDIu++6K1z6fz+NoAACIbxQyLgvPj2GNJQAAYkch47JwR6ZDMwoZAABi5WkhU1RUpAsvvFDp6elq2rSpBgwYoPXr10ccEwgENGLECDVq1EgNGjTQoEGDtHv3bo8ijt06liYAAMA2nhYyxcXFGjFihJYtW6b33ntPFRUVuvzyy1VeXm4dc9ddd+n111/XnDlzVFxcrB07duiqq67yMOro7T0Y1L5DQfl8UtscOjIAAMQqycsvf/vttyPeT506VU2bNtWKFSvUvXt3lZaW6u9//7tmzpypXr16SZJeeOEFdejQQcuWLdPFF1/sRdhRCy8U2apRfaWlJHocDQAA8a9WzZEpLS2VJGVnZ0uSVqxYoYqKCvXu3ds6pn379mrRooWWLl16wnMEg0GVlZVFvGqLdSxNAACArWpNIRMKhTRq1Ch17dpV5557riRp165dSklJUVZWVsSxOTk52rVr1wnPU1RUpMzMTOuVn5/vdOinLDw/hjuWAACwR60pZEaMGKG1a9dq1qxZMZ1nzJgxKi0ttV7btm2zKcLYHe/IMNEXAAA7eDpHJmzkyJH617/+pUWLFql58+bW9tzcXB09elQHDhyI6Mrs3r1bubm5JzyX3++X31/7nphbWRXSht2HJHHrNQAAdvG0I2OM0ciRIzV37lwtWLBABQUFEfs7d+6s5ORkzZ8/39q2fv16bd26VYWFhW6HG5PN+w8rWBlSvZRE5Tes53U4AADUCZ52ZEaMGKGZM2fqtddeU3p6ujXvJTMzU2lpacrMzNTNN9+s0aNHKzs7WxkZGfrNb36jwsLCuLtjKXxZqW1OuhISWJoAAAA7eFrITJkyRZLUs2fPiO0vvPCChg0bJkl66qmnlJCQoEGDBikYDKpPnz7605/+5HKksVvPE30BALCdp4WMMeZHj0lNTdXkyZM1efJkFyJyzpc7v71jiQfhAQBgm1pz11JdZ92x1Iw7lgAAsAuFjAsOBiq0/ZsjkngYHgAAdqKQccG/dx+7rJSbkaqseikeRwMAQN1BIeOC8PyY9kz0BQDAVhQyLgjfscQTfQEAsBeFjAtYLBIAAGdQyDjMGGMtFsmlJQAA7EUh47AdpQEdDFQqOdGn1o0beB0OAAB1CoWMw9btPHZZqU2TBkpJYrgBALATmdVh1mUl5scAAGA7ChmHHZ8fwx1LAADYjULGYeFLS+3oyAAAYDsKGQcFK6v01b5ySVIHniEDAIDtKGQctHHPIVWFjLLqJSsnw+91OAAA1DkUMg7asPuQJKltTrp8Pp/H0QAAUPdQyDioLFAhSWrSgG4MAABOoJBxUKCiSpLk5/kxAAA4ggzroGBFSJLkT070OBIAAOomChkHBSrpyAAA4CQyrIOOd2QYZgAAnECGdVCw8lghk5rEpSUAAJxAIeMga7IvHRkAABxBhnUQHRkAAJxFIeMgOjIAADiLDOugcEfGT0cGAABHUMg4KPjt7depdGQAAHAEGdZBgQo6MgAAOIlCxkHWZF86MgAAOIIM66CgtdYSHRkAAJxAIeOg45N9GWYAAJxAhnVQ+PbrVBaNBADAERQyDqIjAwCAs8iwDjp++zUdGQAAnEAh45CqkFFFlZFERwYAAKeQYR0S7sZILFEAAIBTyLAOCT8MT+L2awAAnEIh45BwRyY50afEBJ/H0QAAUDdRyDgk+G1HJpVuDAAAjqGQcUjg244M82MAAHAOWdYhQRaMBADAcRQyDgk/1ZeODAAAziHLOuT4U33pyAAA4BQKGYeEC5lUOjIAADiGLOsQ69IST/UFAMAxZFmHcGkJAADnUcg4JNyR4dISAADOIcs6hI4MAADOo5BxSHiJAjoyAAA4hyzrkAAPxAMAwHEUMg6hIwMAgPPIsg5hiQIAAJxHIeOQcEeG58gAAOAcsqxDwnNkUpPpyAAA4BQKGYdYHRnmyAAA4BiyrEPCc2RSmSMDAIBjKGQcEqAjAwCA48iyDjl+1xJDDACAU8iyDjnekeHSEgAATqGQcQgdGQAAnEeWdUh40UhuvwYAwDkUMg4JVPBAPAAAnEaWdUi4I8MSBQAAOIdCxiHhjgyLRgIA4ByyrAOMMXRkAABwAYWMA45Whayf6cgAAOAcT7PsokWL1L9/f+Xl5cnn82nevHkR+4cNGyafzxfx6tu3rzfB1kB4wUiJjgwAAE7ytJApLy9Xp06dNHny5JMe07dvX+3cudN6vfTSSy5GGJ3wgpE+n5Sc6PM4GgAA6q4kL7+8X79+6tev3w8e4/f7lZub61JE9vjugpE+H4UMAABOqfUTOD744AM1bdpU7dq10+233679+/f/4PHBYFBlZWURL7cFWTASAABX1OpM27dvX02fPl3z58/XY489puLiYvXr109VVVUn/UxRUZEyMzOtV35+vosRHxP4TkcGAAA4x9NLSz9myJAh1s8/+clP1LFjR7Vp00YffPCBLrvsshN+ZsyYMRo9erT1vqyszPViho4MAADuiKtM27p1azVu3FgbN2486TF+v18ZGRkRL7exYCQAAO6Iq0y7fft27d+/X82aNfM6lB8UqAw/1ZdLSwAAOMnTS0uHDh2K6K6UlJRo9erVys7OVnZ2tiZMmKBBgwYpNzdXmzZt0r333qszzzxTffr08TDqH0dHBgAAd3hayHzyySe69NJLrffhuS1Dhw7VlClTtGbNGk2bNk0HDhxQXl6eLr/8ck2cOFF+v9+rkE8JHRkAANzhaSHTs2dPGWNOuv+dd95xMRr70JEBAMAdZFoHsGAkAADuoJBxQKCC268BAHADmdYBdGQAAHAHhYwDwh2ZVDoyAAA4ikzrADoyAAC4g0LGAdYSBdy1BACAo8i0DrAWjeQ5MgAAOIpCxgHHLy0xvAAAOIlM64Djk33pyAAA4CQKGQfQkQEAwB1kWgcEeSAeAACuINM6IPBtRyaV268BAHAUhYwD6MgAAOAOMq0DwnNkmOwLAICzKGQcYHVkmOwLAICjyLQOCNCRAQDAFRQyDqAjAwCAO8i0DmDRSAAA3EEhY7PKqpAqQ0aSlMpdSwAAOIpMa7NwN0aiIwMAgNMoZGwWXmdJYo4MAABOI9PaLNyRSUlMUEKCz+NoAACo2yhkbMaCkQAAuIdsa7OAtTwB82MAAHAahYzN6MgAAOAesq3Nwh0Zbr0GAMB5ZFub8TA8AADcQyFjM2t5AjoyAAA4jmxrM2vBSDoyAAA4jkLGZnRkAABwD9nWZnRkAABwD4WMzejIAADgnqRoPlReXq5HH31U8+fP1549exQKhSL2f/XVV7YEF494jgwAAO6JqpC55ZZbVFxcrF/+8pdq1qyZfD7WFAoLWs+R4dISAABOi6qQeeutt/TGG2+oa9eudscT9+jIAADgnqiybcOGDZWdnW13LHVCgI4MAACuiaqQmThxosaNG6fDhw/bHU/coyMDAIB7orq09MQTT2jTpk3KyclRq1atlJycHLF/5cqVtgQXj6zVr7n9GgAAx0VVyAwYMMDmMOqOcEeGRSMBAHBejQuZyspK+Xw+3XTTTWrevLkTMcU1Fo0EAMA9NW4bJCUl6fHHH1dlZaUT8cS9AA/EAwDANVFl2169eqm4uNjuWOoEOjIAALgnqjky/fr103333afPPvtMnTt3Vv369SP2/+xnP7MluHhERwYAAPdEVcj8+te/liQ9+eST1fb5fD5VVVXFFlUcC7JoJAAAromqkPn+2ko4LlhJRwYAALeQbW0WqKAjAwCAW6LqyDz00EM/uH/cuHFRBVMXBJkjAwCAa6IqZObOnRvxvqKiQiUlJUpKSlKbNm1O60ImwBIFAAC4JqpCZtWqVdW2lZWVadiwYRo4cGDMQcUrY4yOWk/25dISAABOs61tkJGRoQkTJmjs2LF2nTLuhO9YkujIAADgBluzbWlpqUpLS+08ZVwJVhwvZOjIAADgvKguLU2aNCnivTFGO3fu1Isvvqh+/frZElg8Ct96neCTkhJ8HkcDAEDdF1Uh89RTT0W8T0hIUJMmTTR06FCNGTPGlsDikXXrdXKifD4KGQAAnBZVIVNSUmJ3HHWC9TA85scAAOCKqDLuTTfdpIMHD1bbXl5erptuuinmoOIVC0YCAOCuqAqZadOm6ciRI9W2HzlyRNOnT485qHgVXjAylYfhAQDgihpdWiorK5MxRsYYHTx4UKmpqda+qqoqvfnmm2ratKntQcYLOjIAALirRoVMVlaWfD6ffD6f2rZtW22/z+fThAkTbAsu3tCRAQDAXTUqZBYuXChjjHr16qVXXnlF2dnZ1r6UlBS1bNlSeXl5tgcZL+jIAADgrhoVMj169JB07K6lFi1acIvx9wRYMBIAAFdFlXFbtmypxYsX6/rrr9dPf/pT/ec//5Ekvfjii1q8eLGtAcYTOjIAALgrqkLmlVdeUZ8+fZSWlqaVK1cqGAxKOrZEwe9//3tbA4wnQToyAAC4KqqM+/DDD+v555/XX//6VyUnJ1vbu3btqpUrV9oWXLwJhFe+piMDAIAroipk1q9fr+7du1fbnpmZqQMHDsQaU9wKLxpJRwYAAHdElXFzc3O1cePGatsXL16s1q1bxxxUvAqwRAEAAK6KKuPeeuutuvPOO7V8+XL5fD7t2LFDM2bM0N13363bb7/9lM+zaNEi9e/fX3l5efL5fJo3b17EfmOMxo0bp2bNmiktLU29e/fWhg0bognZFcHvLBoJAACcF1Uhc9999+kXv/iFLrvsMh06dEjdu3fXLbfcottvv1233HLLKZ+nvLxcnTp10uTJk0+4/w9/+IMmTZqk559/XsuXL1f9+vXVp08fBQKBaMJ2HItGAgDgrqgyrs/n0/3336+vv/5aa9eu1bJly7R3715lZmaqoKDglM/Tr18/Pfzwwxo4cGC1fcYYPf3003rggQd05ZVXqmPHjpo+fbp27NhRrXNTWwToyAAA4KoaFTLBYFBjxozRBRdcoK5du+rNN9/U2Wefrc8//1zt2rXTM888o7vuusuWwEpKSrRr1y717t3b2paZmakuXbpo6dKlPxhjWVlZxMstdGQAAHBXjZ7sO27cOP35z39W7969tWTJEv385z/XjTfeqGXLlumJJ57Qz3/+cyUm2tON2LVrlyQpJycnYntOTo6170SKioo8W+8p3JHhgXgAALijRq2DOXPmaPr06Xr55Zf17rvvqqqqSpWVlfr00081ZMgQ24qYWIwZM0alpaXWa9u2ba59d7gjw6KRAAC4o0YZd/v27ercubMk6dxzz5Xf79ddd93lyJpLubm5kqTdu3dHbN+9e7e170T8fr8yMjIiXm5hiQIAANxVo0KmqqpKKSkp1vukpCQ1aNDA9qAkqaCgQLm5uZo/f761raysTMuXL1dhYaEj3xmr8BIFdGQAAHBHjebIGGM0bNgw+f1+SVIgENBtt92m+vXrRxz36quvntL5Dh06FPFgvZKSEq1evVrZ2dlq0aKFRo0apYcfflhnnXWWCgoKNHbsWOXl5WnAgAE1Cds1dGQAAHBXjQqZoUOHRry//vrrY/ryTz75RJdeeqn1fvTo0db3TJ06Vffee6/Ky8s1fPhwHThwQJdcconefvttpaamxvS9TgmwaCQAAK7yGWOM10E4qaysTJmZmSotLXV8vkxh0XztLA3o9ZGX6CfNMx39LgAA6rJTzd+0DmxERwYAAHeRcW0UniOTyhwZAABcQSFjI2uyLx0ZAABcQca1SUVVSFWhY9ONWKIAAAB3kHFtEu7GSCwaCQCAWyhkbBKe6CtJKYkMKwAAbiDj2iTckUlJSlBCgv1LNgAAgOooZGwSXp6A+TEAALiHrGuTQAXLEwAA4DYKGZsEK1kwEgAAt5F1bXK8I8OQAgDgFrKuTY53ZLi0BACAWyhkbGI91ZeODAAAriHr2sRaMJLJvgAAuIZCxibWgpFM9gUAwDVkXZsE6cgAAOA6Chmb0JEBAMB9ZF2bHJ/sS0cGAAC3UMjYJDzZl44MAADuIevaxOrI8BwZAABcQyFjkwCLRgIA4Dqyrk2CFeHJvnRkAABwC4WMTQKVdGQAAHAbWdcm4Y4Mc2QAAHAPhYxNgnRkAABwHVnXJoEKFo0EAMBtZF2bhDsyTPYFAMA9FDI2oSMDAID7yLo2oSMDAID7KGRscnytJYYUAAC3kHVtcvzSEh0ZAADcQiFjk+OXlhhSAADcQta1CQ/EAwDAfRQyNgiFjI5WfbvWEnNkAABwDVnXBuEiRqIjAwCAmyhkbBCoqLJ+5q4lAADcQ9a1QfjW68QEn5ITGVIAANxC1rVBuCNDNwYAAHeReW0Q7sjwVF8AANxFIWODIOssAQDgCTKvDQKVXFoCAMALZF4bhDsyXFoCAMBdFDI2YLIvAADeIPPawFr5mo4MAACuopCxAR0ZAAC8Qea1gdWRSaIjAwCAmyhkbBD89q6l1GSGEwAAN5F5bRCooCMDAIAXKGRsQEcGAABvkHltQEcGAABvUMjYINyR8dORAQDAVWReG1iLRtKRAQDAVRQyNrCeI0NHBgAAV5F5bXC8I8NwAgDgJjKvDYJWR4ZLSwAAuIlCxgbHn+zLcAIA4CYyrw2C395+nUpHBgAAV1HI2CBQyaKRAAB4gcxrAzoyAAB4g0LGBnRkAADwBpnXBnRkAADwBoWMDYJ0ZAAA8ASZ1wYsGgkAgDcoZGJkjLE6MqksUQAAgKvIvDGqqDIKmWM/05EBAMBdtbqQGT9+vHw+X8Srffv2XocVIdyNkVg0EgAAtyV5HcCPOeecc/T+++9b75OSalfI4fkxEpN9AQBwW+2qCk4gKSlJubm5XodxUuGOTEpSgnw+n8fRAABweqn1LYQNGzYoLy9PrVu31nXXXaetW7f+4PHBYFBlZWURLyeFF4xMpRsDAIDranX27dKli6ZOnaq3335bU6ZMUUlJibp166aDBw+e9DNFRUXKzMy0Xvn5+Y7GGKj49hkyPAwPAADX+YwxxusgTtWBAwfUsmVLPfnkk7r55ptPeEwwGFQwGLTel5WVKT8/X6WlpcrIyLA9ppVbv9FVf1qi/Ow0/b97e9l+fgAATkdlZWXKzMz80fxd6+fIfFdWVpbatm2rjRs3nvQYv98vv9/vWkxWR4ZbrwEAcF2tvrT0fYcOHdKmTZvUrFkzr0OxhOfIcMcSAADuq9XZ95577lFxcbE2b96sJUuWaODAgUpMTNS1117rdWgWFowEAMA7tfrS0vbt23Xttddq//79atKkiS655BItW7ZMTZo08To0CwtGAgDgnVpdyMyaNcvrEH4UHRkAALxDGyFGAToyAAB4huwbo3BHhkIGAAD3kX1jFJ4jw6UlAADcRyETowAdGQAAPEP2jREdGQAAvEMhEyM6MgAAeIfsGyPrOTJ0ZAAAcB2FTIzoyAAA4B2yb4zoyAAA4B0KmRiFF41MpSMDAIDryL4xClTQkQEAwCsUMjEKd2SYIwMAgPvIvjEKsGgkAACeoZCJUZBFIwEA8AzZN0ZBOjIAAHiGQiZGdGQAAPAO2TdGQR6IBwCAZ8i+MQqwaCQAAJ6hkIlBVcioospIoiMDAIAXyL4xOPrtM2QkOjIAAHiBQiYG4af6SnRkAADwAtk3BuGn+iYl+JSUyFACAOA2sm8MrHWW6MYAAOAJMnAMrHWWmB8DAIAnKGRiEH4YXiodGQAAPEEGjkF4wUg6MgAAeINCJgYsTwAAgLfIwDGgIwMAgLcoZGJARwYAAG+RgWMQ7sjwVF8AALxBIRMDOjIAAHiLDByDIB0ZAAA8RSETgwAdGQAAPEUGjkG4I0MhAwCAN8jAMQh3ZLi0BACANyhkYkBHBgAAb5GBYxBeNJKODAAA3qCQiUGwgsm+AAB4iQwcg3BHhkIGAABvkIFjEKhgsi8AAF6ikImB1ZFJZhgBAPACGTgG4SUKUpPoyAAA4AUKmRiEF42kIwMAgDfIwDE4vmgkHRkAALxAIRODgLVoJMMIAIAXyMAxoCMDAIC3KGRicPzJvgwjAABeIAPHIFBBRwYAAC9RyETJGMOTfQEA8BgZOEpHq0Iy5tjPfp7sCwCAJyhkohTuxkh0ZAAA8AoZOErh+TEShQwAAF4hA0cpWHF8fozP5/M4GgAATk8UMlFioi8AAN4jC0cpfGkplYm+AAB4hkImSlZHhofhAQDgGbJwlILhjgwPwwMAwDMUMlGiIwMAgPfIwlFiwUgAALxHIROlQAULRgIA4DWycJToyAAA4D0KmSjRkQEAwHtk4SjRkQEAwHsUMlEK0pEBAMBzZOEoBejIAADgubgoZCZPnqxWrVopNTVVXbp00UcffeR1SBGLRgIAAG/U+iw8e/ZsjR49Wg8++KBWrlypTp06qU+fPtqzZ4+ncVkdGdZaAgDAM7W+kHnyySd166236sYbb9TZZ5+t559/XvXq1dM//vEPT+NK8PnkT0pgjgwAAB5K8jqAH3L06FGtWLFCY8aMsbYlJCSod+/eWrp06Qk/EwwGFQwGrfdlZWWOxPbQlefqoSvPdeTcAADg1NTqdsK+fftUVVWlnJyciO05OTnatWvXCT9TVFSkzMxM65Wfn+9GqAAAwAO1upCJxpgxY1RaWmq9tm3b5nVIAADAIbX60lLjxo2VmJio3bt3R2zfvXu3cnNzT/gZv98vv9/vRngAAMBjtbojk5KSos6dO2v+/PnWtlAopPnz56uwsNDDyAAAQG1QqzsykjR69GgNHTpUF1xwgS666CI9/fTTKi8v14033uh1aAAAwGO1vpAZPHiw9u7dq3HjxmnXrl0677zz9Pbbb1ebAAwAAE4/PmOM8ToIJ5WVlSkzM1OlpaXKyMjwOhwAAHAKTjV/1+o5MgAAAD+EQgYAAMQtChkAABC3KGQAAEDcopABAABxi0IGAADELQoZAAAQt2r9A/FiFX5MTllZmceRAACAUxXO2z/2uLs6X8gcPHhQkpSfn+9xJAAAoKYOHjyozMzMk+6v80/2DYVC2rFjh9LT0+Xz+Ww7b1lZmfLz87Vt2zaeGOwCxttdjLf7GHN3Md7uima8jTE6ePCg8vLylJBw8pkwdb4jk5CQoObNmzt2/oyMDP5P4CLG212Mt/sYc3cx3u6q6Xj/UCcmjMm+AAAgblHIAACAuEUhEyW/368HH3xQfr/f61BOC4y3uxhv9zHm7mK83eXkeNf5yb4AAKDuoiMDAADiFoUMAACIWxQyAAAgblHIAACAuEUhE6XJkyerVatWSk1NVZcuXfTRRx95HVKdsGjRIvXv3195eXny+XyaN29exH5jjMaNG6dmzZopLS1NvXv31oYNG7wJtg4oKirShRdeqPT0dDVt2lQDBgzQ+vXrI44JBAIaMWKEGjVqpAYNGmjQoEHavXu3RxHHtylTpqhjx47WQ8EKCwv11ltvWfsZa+c8+uij8vl8GjVqlLWN8bbX+PHj5fP5Il7t27e39js13hQyUZg9e7ZGjx6tBx98UCtXrlSnTp3Up08f7dmzx+vQ4l55ebk6deqkyZMnn3D/H/7wB02aNEnPP/+8li9frvr166tPnz4KBAIuR1o3FBcXa8SIEVq2bJnee+89VVRU6PLLL1d5ebl1zF133aXXX39dc+bMUXFxsXbs2KGrrrrKw6jjV/PmzfXoo49qxYoV+uSTT9SrVy9deeWV+vzzzyUx1k75+OOP9ec//1kdO3aM2M542++cc87Rzp07rdfixYutfY6Nt0GNXXTRRWbEiBHW+6qqKpOXl2eKioo8jKrukWTmzp1rvQ+FQiY3N9c8/vjj1rYDBw4Yv99vXnrpJQ8irHv27NljJJni4mJjzLHxTU5ONnPmzLGO+fLLL40ks3TpUq/CrFMaNmxo/va3vzHWDjl48KA566yzzHvvvWd69Ohh7rzzTmMMf9tOePDBB02nTp1OuM/J8aYjU0NHjx7VihUr1Lt3b2tbQkKCevfuraVLl3oYWd1XUlKiXbt2RYx9ZmamunTpwtjbpLS0VJKUnZ0tSVqxYoUqKioixrx9+/Zq0aIFYx6jqqoqzZo1S+Xl5SosLGSsHTJixAhdccUVEeMq8bftlA0bNigvL0+tW7fWddddp61bt0pydrzr/KKRdtu3b5+qqqqUk5MTsT0nJ0fr1q3zKKrTw65duyTphGMf3ofohUIhjRo1Sl27dtW5554r6diYp6SkKCsrK+JYxjx6n332mQoLCxUIBNSgQQPNnTtXZ599tlavXs1Y22zWrFlauXKlPv7442r7+Nu2X5cuXTR16lS1a9dOO3fu1IQJE9StWzetXbvW0fGmkAEg6dh/ua5duzbimjbs165dO61evVqlpaV6+eWXNXToUBUXF3sdVp2zbds23XnnnXrvvfeUmprqdTinhX79+lk/d+zYUV26dFHLli31f//3f0pLS3Pse7m0VEONGzdWYmJitZnWu3fvVm5urkdRnR7C48vY22/kyJH617/+pYULF6p58+bW9tzcXB09elQHDhyIOJ4xj15KSorOPPNMde7cWUVFRerUqZOeeeYZxtpmK1as0J49e3T++ecrKSlJSUlJKi4u1qRJk5SUlKScnBzG22FZWVlq27atNm7c6OjfN4VMDaWkpKhz586aP3++tS0UCmn+/PkqLCz0MLK6r6CgQLm5uRFjX1ZWpuXLlzP2UTLGaOTIkZo7d64WLFiggoKCiP2dO3dWcnJyxJivX79eW7duZcxtEgqFFAwGGWubXXbZZfrss8+0evVq63XBBRfouuuus35mvJ116NAhbdq0Sc2aNXP27zumqcKnqVmzZhm/32+mTp1qvvjiCzN8+HCTlZVldu3a5XVoce/gwYNm1apVZtWqVUaSefLJJ82qVavMli1bjDHGPProoyYrK8u89tprZs2aNebKK680BQUF5siRIx5HHp9uv/12k5mZaT744AOzc+dO63X48GHrmNtuu820aNHCLFiwwHzyySemsLDQFBYWehh1/LrvvvtMcXGxKSkpMWvWrDH33Xef8fl85t133zXGMNZO++5dS8Yw3na7++67zQcffGBKSkrMhx9+aHr37m0aN25s9uzZY4xxbrwpZKL07LPPmhYtWpiUlBRz0UUXmWXLlnkdUp2wcOFCI6naa+jQocaYY7dgjx071uTk5Bi/328uu+wys379em+DjmMnGmtJ5oUXXrCOOXLkiPn1r39tGjZsaOrVq2cGDhxodu7c6V3Qceymm24yLVu2NCkpKaZJkybmsssus4oYYxhrp32/kGG87TV48GDTrFkzk5KSYs444wwzePBgs3HjRmu/U+PtM8aY2Ho6AAAA3mCODAAAiFsUMgAAIG5RyAAAgLhFIQMAAOIWhQwAAIhbFDIAACBuUcgAAIC4RSEDwFY9e/bUqFGjvA4jgs/n07x587wOA4ADeCAeAFt9/fXXSk5OVnp6ulq1aqVRo0a5VtiMHz9e8+bN0+rVqyO279q1Sw0bNpTf73clDgDuSfI6AAB1S3Z2tu3nPHr0qFJSUqL+PKsZA3UXl5YA2Cp8aalnz57asmWL7rrrLvl8Pvl8PuuYxYsXq1u3bkpLS1N+fr7uuOMOlZeXW/tbtWqliRMn6oYbblBGRoaGDx8uSfrtb3+rtm3bql69emrdurXGjh2riooKSdLUqVM1YcIEffrpp9b3TZ06VVL1S0ufffaZevXqpbS0NDVq1EjDhw/XoUOHrP3Dhg3TgAED9Mc//lHNmjVTo0aNNGLECOu7ANQeFDIAHPHqq6+qefPmeuihh7Rz507t3LlTkrRp0yb17dtXgwYN0po1azR79mwtXrxYI0eOjPj8H//4R3Xq1EmrVq3S2LFjJUnp6emaOnWqvvjiCz3zzDP661//qqeeekqSNHjwYN19990655xzrO8bPHhwtbjKy8vVp08fNWzYUB9//LHmzJmj999/v9r3L1y4UJs2bdLChQs1bdo0TZ061SqMANQeXFoC4Ijs7GwlJiYqPT094tJOUVGRrrvuOmvezFlnnaVJkyapR48emjJlilJTUyVJvXr10t133x1xzgceeMD6uVWrVrrnnns0a9Ys3XvvvUpLS1ODBg2UlJT0g5eSZs6cqUAgoOnTp6t+/fqSpOeee079+/fXY489ppycHElSw4YN9dxzzykxMVHt27fXFVdcofnz5+vWW2+1ZXwA2INCBoCrPv30U61Zs0YzZsywthljFAqFVFJSog4dOkiSLrjggmqfnT17tiZNmqRNmzbp0KFDqqysVEZGRo2+/8svv1SnTp2sIkaSunbtqlAopPXr11uFzDnnnKPExETrmGbNmumzzz6r0XcBcB6FDABXHTp0SL/61a90xx13VNvXokUL6+fvFhqStHTpUl133XWaMGGC+vTpo8zMTM2aNUtPPPGEI3EmJydHvPf5fAqFQo58F4DoUcgAcExKSoqqqqoitp1//vn64osvdOaZZ9boXEuWLFHLli11//33W9u2bNnyo9/3fR06dNDUqVNVXl5uFUsffvihEhIS1K5duxrFBMB7TPYF4JhWrVpp0aJF+s9//qN9+/ZJOnbn0ZIlSzRy5EitXr1aGzZs0GuvvVZtsu33nXXWWdq6datmzZqlTZs2adKkSZo7d2617yspKdHq1au1b98+BYPBaue57rrrlJqaqqFDh2rt2rVauHChfvOb3+iXv/yldVkJQPygkAHgmIceekibN29WmzZt1KRJE0lSx44dVVxcrH//+9/q1q2b/uu//kvjxo1TXl7eD57rZz/7me666y6NHDlS5513npYsWWLdzRQ2aNAg9e3bV5deeqmaNGmil156qdp56tWrp3feeUdff/21LrzwQl199dW67LLL9Nxzz9n3iwNwDU/2BQAAcYuODAAAiFsUMgAAIG5RyAAAgLhFIQMAAOIWhQwAAIhbFDIAACBuUcgAAIC4RSEDAADiFoUMAACIWxQyAAAgblHIAACAuEUhAwAA4tb/B0GIiQupHkBmAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**補足**\n",
        "実は方策反復法の方が価値反復法よりも（イテレーションの意味で）素早く収束することが知られています．実験の結果もそうなっていますか？\n",
        "\n",
        "参考：https://rltheory.github.io/lecture-notes/planning-in-mdps/lec4/"
      ],
      "metadata": {
        "id": "v0MfRzrr65A9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## マルチステップ方策評価・方策更新を実装しよう\n",
        "\n",
        "授業でやったマルチステップ期待ベルマン作用素とマルチステップ最適ベルマン作用素を実装しましょう．\n",
        "\n",
        "* マルチステップ期待ベルマン作用素 $B^\\pi_m: \\mathbb{R}^{S\\times A}\\to \\mathbb{R}^{S\\times A}$：$B^\\pi_m(Q) = B^\\pi(B^\\pi(B^\\pi(\\cdots (Q))))$\n",
        "* マルチステップ最適ベルマン作用素 $B_n: \\mathbb{R}^{S\\times A}\\to \\mathbb{R}^{S\\times A}$：$B_n(Q) = B(B(B(\\cdots(Q))))$\n",
        "\n",
        "\n",
        "また，マルチステップ貪欲方策も実装します．\n",
        "* マルチステップ貪欲方策：$\\operatorname{Gr}(B_n(Q))$"
      ],
      "metadata": {
        "id": "Q1zzQgDsHs_t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def MultiStep_Bellman_expected_operator(mdp: MDP, gamma: float, Q: np.ndarray, policy: np.ndarray, m: int):\n",
        "  \"\"\"\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    Q (np.ndarray): ベルマン期待作用素に入力するQ関数です\n",
        "    policy (np.ndarray): ベルマン期待作用素で使う方策です\n",
        "    m (int): マルチステップ数\n",
        "  \"\"\"\n",
        "  assert m >= 0\n",
        "  S, A = mdp.S, mdp.A\n",
        "  # 方策とQ関数はSxAの行列です\n",
        "  assert Q.shape == (S, A)\n",
        "  assert policy.shape == (S, A)\n",
        "\n",
        "  for _ in range(m):\n",
        "    policy_Q = (policy * Q).sum(axis=1) # πQです\n",
        "    P_policy_Q = mdp.P @ policy_Q  # P(πQ)です\n",
        "    Q = mdp.rew + gamma * P_policy_Q # ベルマン期待作用素の結果です\n",
        "  return Q\n",
        "\n",
        "\n",
        "def MultiStep_Bellman_optimal_operator(mdp: MDP, gamma: float, Q: np.ndarray, n: int):\n",
        "  \"\"\"\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    Q (np.ndarray): ベルマン期待作用素に入力するQ関数です\n",
        "    n (int): マルチステップ数\n",
        "  \"\"\"\n",
        "  assert n >= 0\n",
        "  # Q関数はSxAの行列です\n",
        "  assert Q.shape == (mdp.S, mdp.A)\n",
        "\n",
        "  for _ in range(n):\n",
        "    max_Q = Q.max(axis=1) # maxQです\n",
        "    P_max_Q = mdp.P @ max_Q # P(maxQ)です\n",
        "    Q = mdp.rew + gamma * P_max_Q # ベルマン最適作用素の結果です\n",
        "  return Q\n",
        "\n",
        "\n",
        "def MultiStep_greedy_policy(mdp: MDP, gamma: float, Q: np.ndarray, n: int):\n",
        "  \"\"\"与えられたQ関数とmdpに対して，nステップ先読みした貪欲方策を計算します．\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    Q (np.ndarray): SxAの行列\n",
        "  \"\"\"\n",
        "  BQ = MultiStep_Bellman_optimal_operator(mdp, gamma, Q, n)\n",
        "  policy = compute_greedy_policy(BQ)\n",
        "  return policy"
      ],
      "metadata": {
        "id": "bTPC8R8regoQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "最後にマルチステップ方策評価＆更新を実装しましょう．\n",
        "\n",
        "* マルチステップ方策更新：$\\pi_{k+1} = \\operatorname{Gr}(B_n(Q_k))$\n",
        "* マルチステップ方策評価：$Q_{k+1} = B_m^{\\pi_{k+1}}(Q_k)$\n"
      ],
      "metadata": {
        "id": "N4hZQgSegy-c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def MultiStepPolicyIteration(mdp: MDP, gamma: float, update_step: int, eval_step: int, iteration: int):\n",
        "  \"\"\"\n",
        "  Args:\n",
        "    mdp (MDP): マルコフ決定過程です.（S, A, P, r)を持っています．\n",
        "    gamma (float): 割引率(0 <= gamma <= 1)です\n",
        "    update_step (int): 方策更新のステップ数\n",
        "    eval_step (int): 方策評価のステップ数\n",
        "    iteration (int): 方策更新の回数です\n",
        "  \"\"\"\n",
        "  Q = np.zeros((mdp.S, mdp.A)) # 適当なQの初期値を生成します\n",
        "  policy = np.ones((mdp.S, mdp.A)) / mdp.A  # 適当な方策の初期値を生成します\n",
        "  for _ in range(iteration): # 方策更新を繰り返します\n",
        "    Q = MultiStep_Bellman_expected_operator(mdp, gamma, Q, policy, eval_step)\n",
        "    policy = MultiStep_greedy_policy(mdp, gamma, Q, update_step)\n",
        "  return policy"
      ],
      "metadata": {
        "id": "sTRJznv5wnuE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "マルチステップ方策評価＆更新の挙動を確認してみましょう．\n",
        "授業でやったように，$(m, n)=(1, 0)$なら価値反復法，$(m, n)=(\\infty, 0)$なら方策反復法です．\n",
        "$m, n$を変えたらどうなるか見てみましょう．"
      ],
      "metadata": {
        "id": "-jNi_9Yl4q9z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from tqdm import tqdm\n",
        "\n",
        "gamma = 0.99\n",
        "\n",
        "for m in tqdm(range(1, 3)):\n",
        "  for n in range(0, 3):\n",
        "    returns = []\n",
        "    for iteration in range(20):\n",
        "      policy_multi = MultiStepPolicyIteration(mdp, gamma,n, m, iteration)\n",
        "      return_multi = ExpectedReturnBellman(mdp, gamma, policy_multi)\n",
        "      returns.append(return_multi)\n",
        "    plt.plot(returns, label=f\"(m, n)=({m}, {n})\")\n",
        "plt.title(\"Multi-step Policy Iteration\")\n",
        "plt.ylabel(\"Return\")\n",
        "plt.xlabel(\"iteration\")\n",
        "\n",
        "plt.legend()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 508
        },
        "id": "3Uldv5OM4qbz",
        "outputId": "3181e563-5619-460d-e93b-093de433946d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 2/2 [00:02<00:00,  1.15s/it]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7c4024dcb4c0>"
            ]
          },
          "metadata": {},
          "execution_count": 39
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "ステップ数が変わると何が起きるか？については，こちらの論文を参照してください．\n",
        "\n",
        "* https://arxiv.org/abs/2103.00107\n",
        "* https://arxiv.org/abs/1805.07956\n",
        "* https://arxiv.org/abs/1802.03654"
      ],
      "metadata": {
        "id": "pYD7dSVY9hm0"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dgH8Feawy7f9"
      },
      "source": [
        "# もっと発展的な動的計画法\n",
        "\n",
        "今回は行列形式で動的計画法の実装を確認しました。練習として、自分の力で次の論文たちを実装してみてください。\n",
        "\n",
        "* [Leverage the Average: an Analysis of KL Regularization in RL](https://arxiv.org/abs/2003.14089)\n",
        "* [Theoretical Analysis of Efficiency and Robustness of Softmax and Gap-Increasing Operators in Reinforcement Learning](https://proceedings.mlr.press/v89/kozuno19a.html)\n",
        "\n",
        "Pがわからない場合は今回の行列形式はどうなるでしょうか?以下が参考になります：\n",
        "\n",
        "* [Generalized Markov Decision Processes: Dynamic-programming and Reinforcement-learning Algorithms](https://sites.ualberta.ca/~szepesva/papers/gmdp.ps.pdf)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g1HRRtoOy7f9"
      },
      "outputs": [],
      "source": []
    }
  ],
  "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"
      }
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}