original_RL_mouse_inn_maze.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# core"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "core.py\n",
    "環境とエージェントの抽象クラス\n",
    "\"\"\"\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "class coreEnv:\n",
    "    \"\"\" 環境の抽象クラス \"\"\"\n",
    "    def __init__(self):\n",
    "        \"\"\" 初期処理 \"\"\"\n",
    "        # 引数の設定は適時編集\n",
    "        self.n_act = 2  # <--- 行動数を設定\n",
    "        self.done = False\n",
    "        # ------------------------- 編集ここから\n",
    "        # ------------------------- ここまで\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\" 状態を初期化 \"\"\"\n",
    "        self.done = False\n",
    "        # ------------------------- 編集ここから\n",
    "        obs = np.array([0, 0, 0, 0])  # ndarray\n",
    "        # ------------------------- ここまで\n",
    "        return obs\n",
    "\n",
    "    def step(self, act):\n",
    "        \"\"\" 状態を更新 \"\"\"\n",
    "        # 最終状態の次の状態はリセット\n",
    "        if self.done is True:\n",
    "            obs = self.reset()\n",
    "            return None, None, obs\n",
    "        # ------------------------- 編集ここから\n",
    "        rwd = 1.0                   # float\n",
    "        done = True                 # bool\n",
    "        # ------------------------- ここまで\n",
    "        self.done = done\n",
    "        # ------------------------- 編集ここから\n",
    "        # self.done を使った処理\n",
    "        obs = np.array([0, 0, 0, 0])  # ndarray\n",
    "        # ------------------------- ここまで\n",
    "        return rwd, done, obs\n",
    "\n",
    "    def render(self):\n",
    "        \"\"\" 状態に対応した画像を作成 \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        # img: 3d ndarray\n",
    "        img = np.zeros((100, 200, 3), dtype=np.uint8)\n",
    "        # ------------------------- ここまで\n",
    "        return img\n",
    "\n",
    "\n",
    "class coreAgt:\n",
    "    \"\"\" エージェントの抽象クラス \"\"\"\n",
    "    def __init__(self):\n",
    "        \"\"\" 初期処理 \"\"\"\n",
    "        # 引数の設定は適時編集\n",
    "        self.epsilon = 0.4\n",
    "        # ------------------------- 編集ここから\n",
    "        # ------------------------- ここまで\n",
    "\n",
    "    def select_action(self, obs):\n",
    "        \"\"\" 観測に対して行動を出力 \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        act = 0  # int\n",
    "        # ------------------------- ここまで\n",
    "        return act\n",
    "\n",
    "    def learn(self, obs, act, rwd, done, next_obs):\n",
    "        \"\"\" 学習 \"\"\"\n",
    "        if rwd is None:\n",
    "            return\n",
    "        # ------------------------- 編集ここから\n",
    "        # ------------------------- ここまで\n",
    "\n",
    "    def get_Q(self, obs):\n",
    "        \"\"\" 観測に対するQ値を出力 \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        Q = np.ndarray([0, 0])  # ndarray\n",
    "        # ------------------------- ここまで\n",
    "        return Q\n",
    "\n",
    "    def save_weights(self, filepath):\n",
    "        \"\"\" 方策のパラメータの保存 \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        # ------------------------- ここまで\n",
    "\n",
    "    def load_weights(self, filepath):\n",
    "        \"\"\" 方策のパラメータの読み込み \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        # ------------------------- ここまで\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### env_myenv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # import cv2\n",
    "# import numpy as np\n",
    "# # import core\n",
    "# import mujoco\n",
    "# # from tqdm import trange\n",
    "\n",
    "# xml_path = './xml_models/micromouse.xml'\n",
    "# times = []\n",
    "# left_motor_kakusokudo = []\n",
    "# right_motor_kakusokudo = []\n",
    "# sensor_LF = []\n",
    "# sensor_LS = []\n",
    "# sensor_RF = []\n",
    "# sensor_RS = []\n",
    "\n",
    "\n",
    "\n",
    "# class MyEnv(coreEnv):\n",
    "\n",
    "#     def __init__(self): #引数で受け取るとかは特にないからこんな感じ　各インスタンス変数に値を入れていく\n",
    "#         self.n_act = 5\n",
    "#         self.done = False #最初だからFalse\n",
    "#         self.state = None #状態表示用変数\n",
    "#         self.m = mujoco.MjModel.from_xml_path(xml_path)#modelを読み込んで用意\n",
    "#         self.d = mujoco.MjData(self.m) #モデルのデータを用意\n",
    "\n",
    "#     def reset(self):\n",
    "#         \"\"\" 状態を初期化 \"\"\"\n",
    "#         self.done = False\n",
    "#         # ------------------------- 編集ここから\n",
    "#         self.state = 'start'\n",
    "#         mujoco.mj_resetData(self.m, self.d)\n",
    "#         obs = np.array([0, 0, 0, 0])  # ndarray\n",
    "#         # ------------------------- ここまで\n",
    "#         return obs\n",
    "    \n",
    "#     def step(self, act):\n",
    "#         \"\"\" 状態を更新 \"\"\"\n",
    "#         # 最終状態の次の状態はリセット\n",
    "#         if self.done is True:\n",
    "#             obs = self.reset()\n",
    "#             return None, None, obs\n",
    "#         # ------------------------- 編集ここから\n",
    "#         self.d.ctrl = act\n",
    "#         mujoco.mj_step(self.m, self.d)\n",
    "#         mujoco.mj_kinematics(self.m, self.d)\n",
    "#         goal_pos = self.d.geom('goal').xpos\n",
    "#         mm_pos = self.d.geom('mein_body').xpos\n",
    "#         self.goal_range = np.sqrt((goal_pos[0] - mm_pos[0])**2+(goal_pos[1] - mm_pos[1])**2)\n",
    "\n",
    "#         rwd = -self.goal_range      # float  goalとの距離がそのまま罰になる\n",
    "#         done = False                 # bool\n",
    "\n",
    "#         if self.goal_range < 0.06: #ゴールに十分近かったら報酬を与えて，終了判定\n",
    "#             rwd = 300\n",
    "#             done = True\n",
    "\n",
    "#         # ------------------------- ここまで\n",
    "#         self.done = done\n",
    "#         # ------------------------- 編集ここから\n",
    "#         # self.done を使った処理\n",
    "#         ob1 = self.d.sensordata[0].copy() #sensor_LF\n",
    "#         ob2 = self.d.sensordata[1].copy() #sensor_LS\n",
    "#         ob3 = self.d.sensordata[2].copy() #sensor_RF\n",
    "#         ob4 = self.d.sensordata[3].copy() #sensor_RS\n",
    "#         obs = np.array([ob1, ob2, ob3, ob4])  # ndarray\n",
    "#         # ------------------------- ここまで\n",
    "#         return rwd, done, obs\n",
    "    \n",
    "#     def render(self):\n",
    "#         \"\"\" 状態に対応した画像を作成 \"\"\"\n",
    "#         # ------------------------- 編集ここから\n",
    "#         # img: 3d ndarray\n",
    "#         self.viewer.sync() # mj_stepで進めたシミュレーションを，描画に反映する　　物理状態の変更を反映する\n",
    "#         # ------------------------- ここまで\n",
    "#         return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# agt_TableQ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "agt_tableQ.py\n",
    "Qテーブルを使ったQ学習アルゴリズム\n",
    "\"\"\"\n",
    "import sys\n",
    "import pickle\n",
    "import numpy as np\n",
    "\n",
    "# 自作モジュール\n",
    "# import core\n",
    "\n",
    "\n",
    "class TableQAgt(coreAgt):\n",
    "    \"\"\" Qテーブルを使ったQ学習エージェントクラス \"\"\"\n",
    "    def __init__(           # 引数とデフォルト値の設定 (A)\n",
    "            self,\n",
    "            n_act=4,            # int: 行動の種類数\n",
    "            init_val_Q=0,       # float: Q値の初期値\n",
    "            epsilon=0.1,        # float: 乱雑度\n",
    "            alpha=0.1,          # float: 学習率\n",
    "            gamma=0.9,          # float: 割引率\n",
    "            max_memory=10000,     # int: 記憶する最大の観測数\n",
    "            filepath=None,      # str: 保存用ファイル名\n",
    "            ):\n",
    "        \"\"\" 初期処理 \"\"\"\n",
    "        # 引数の設定は適時編集\n",
    "        self.epsilon = epsilon\n",
    "        # ------------------------- 編集ここから\n",
    "        self.n_act = n_act\n",
    "        # エージェントのハイパーパラメータ (B)\n",
    "        self.init_val_Q = init_val_Q\n",
    "        self.gamma = gamma\n",
    "        self.alpha = alpha\n",
    "\n",
    "        # 保存ファイル名 (C)\n",
    "        self.filepath = filepath\n",
    "\n",
    "        # Qテーブル関連 (D)\n",
    "        self.Q = {}     # Qテーブルの辞書を用意\n",
    "        self.len_Q = 0  # Qテーブルに登録した観測の数記録変数　最初だから０\n",
    "        self.max_memory = max_memory #記録する最大の観測数\n",
    "        # ------------------------- ここまで\n",
    "\n",
    "    def select_action(self, obs):\n",
    "        \"\"\" 観測に対して行動を出力 \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        # obsを文字列に変換 (A)　辞書でやってるから，ndarray型を変える必要があるので文字列に変換しといてる\n",
    "        obs = str(obs)\n",
    "\n",
    "        # obs が登録されていなかったら初期値を与えて登録 (B) #登録されていたら何もしない\n",
    "        self._check_and_add_observation(obs)\n",
    "\n",
    "        # 確率的に処理を分岐 (C)\n",
    "        if np.random.rand() < self.epsilon:\n",
    "            # epsilon の確率(D)\n",
    "            act_select = np.random.randint(0, self.n_act)  # ランダム行動選択\n",
    "        else:\n",
    "            # 1-epsilon の確率(E)\n",
    "            act_select = np.argmax(self.Q[obs])  # Qを最大にする行動\n",
    "\n",
    "        # ------------------------- ここまで\n",
    "        return act_select\n",
    "\n",
    "    def _check_and_add_observation(self, obs):\n",
    "        \"\"\" obs が登録されていなかったら初期値を与えて登録 \"\"\"\n",
    "        if obs not in self.Q:  # (A) セルフQにその辞書のキーがなかったら，\n",
    "            self.Q[obs] = [self.init_val_Q] * self.n_act  # (B)　obsをキーとして，Qの初期値をact個用意して追加\n",
    "            self.len_Q += 1  # (C)　追加したので，Qの大きさの変数を１増やす\n",
    "            if self.len_Q > self.max_memory:  # (D)　Qの大きさがマックスを超えたら\n",
    "                print(f'観測の登録数が上限 ' +\n",
    "                      f'{self.max_memory:d} に達しました。')\n",
    "                sys.exit() #プログラムは即座に終了\n",
    "            if (self.len_Q < 100 and self.len_Q % 10 == 0) or \\\n",
    "                    (self.len_Q % 100 == 0):  # (E) 100以下で１０で割り切れる場合　または　１００で割り切れる場合\n",
    "                print(f'the number of obs in Q-table' +\n",
    "                      f' --- {self.len_Q:d}') #表示する\n",
    "\n",
    "    def learn(self, obs, act, rwd, done, next_obs):\n",
    "        \"\"\" 学習 \"\"\"\n",
    "        if rwd is None:  # rwdがNoneだったら戻る(A)\n",
    "            return\n",
    "        # ------------------------- 編集ここから\n",
    "        # obs, next_obs を文字列に変換 (B)　今とその次のobsを使って学習を行うために必要\n",
    "        obs = str(obs)\n",
    "        next_obs = str(next_obs)\n",
    "\n",
    "        # next_obs が登録されていなかったら初期値を与えて登録 (C)\n",
    "        self._check_and_add_observation(next_obs)\n",
    "\n",
    "        # 学習のターゲットを作成 (D)\n",
    "        if done is True: #動的計画法の一番後ろだったら期待値は報酬そのものであるため\n",
    "            target = rwd\n",
    "        else: #動的計画法的に，まだエピソードが終わらない場合の期待値はその報酬とその次の状態の最大のＱ値をとる行動のＱ値であるため\n",
    "            target = rwd + self.gamma * max(self.Q[next_obs])\n",
    "\n",
    "        # Qをターゲットに近づける (E)\n",
    "        self.Q[obs][act] = (1 - self.alpha) * self.Q[obs][act] + self.alpha * target #平均の更新足　ここではQ値の更新則  すべての経験の平均の期待値がここに追加されるので，ちゃんと行動価値（その行動によって得た値の平均つまり期待値）の値になっている\n",
    "        # ------------------------- ここまで\n",
    "\n",
    "    def get_Q(self, obs):\n",
    "        \"\"\" 観測に対するQ値を出力 \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        obs = str(obs) #受け取ったobsを文字列に変換して，\n",
    "        if obs in self.Q:   # obsがQにある (A)場合はその値を取り出す（その状態での各行動のQ値がそれぞれ出る）\n",
    "            val = self.Q[obs]\n",
    "            Q = np.array(val) #nparray型に変換してから返す\n",
    "        else:               # obsがQにない (B)\n",
    "            Q = None #なければないで終わり\n",
    "        # ------------------------- ここまで\n",
    "        return Q\n",
    "\n",
    "    def save_weights(self, filepath=None):\n",
    "        \"\"\" 方策のパラメータの保存 \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        # Qテーブルの保存\n",
    "        if filepath is None:\n",
    "            filepath = self.filepath + '.pkl'\n",
    "        with open(filepath, mode='wb') as f:\n",
    "            pickle.dump(self.Q, f) #Q値を保存する　\n",
    "        # ------------------------- ここまで\n",
    "\n",
    "    def load_weights(self, filepath=None):\n",
    "        \"\"\" 方策のパラメータの読み込み \"\"\"\n",
    "        # ------------------------- 編集ここから\n",
    "        # Qテーブルの読み込み\n",
    "        if filepath is None:\n",
    "            filepath = self.filepath + '.pkl'\n",
    "        with open(filepath, mode='rb') as f:\n",
    "            self.Q = pickle.load(f) #ここでQ値を復元してる\n",
    "        # ------------------------- ここまで\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MyEnv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "sibuyaatusiタスク\n",
    "\"\"\"\n",
    "\n",
    "import numpy as np  # ベクトル・行列演算ライブラリ (A)\n",
    "import mujoco\n",
    "from tqdm import trange\n",
    "\n",
    "NUM_DIZITIZED = 4\n",
    "MAX_STEP = 50000\n",
    "\n",
    "\n",
    "class MyEnv(coreEnv):\n",
    "    \"\"\" コリドータスクの環境クラス \"\"\"\n",
    "\n",
    "\n",
    "    def __init__(                   # (B)\n",
    "            self,\n",
    "            ):\n",
    "        \"\"\" 初期処理 \"\"\"\n",
    "        # 引数の設定は適時編集\n",
    "        self.n_act = 3  # <--- 行動数を設定 (C)\n",
    "        self.done = False\n",
    "        # ------------------------- 編集ここから\n",
    "        \"\"\" インスタンス生成時の処理 \"\"\"\n",
    "        # タスクパラメータ (D)\n",
    "        # self.model = mujoco.MjModel.from_xml_path('.\\micromouse_straight_new.xml')#modelを読み込んで用意 インスタンスに用意しておく\n",
    "        self.model = mujoco.MjModel.from_xml_path('.\\mouse_in_maze.xml')#modelを読み込んで用意 インスタンスに用意しておく\n",
    "        self.data = mujoco.MjData(self.model) #モデルのデータを用意\n",
    "        self.init_pos = self.data.qpos #ロボットの初期位置座標取得\n",
    "        self.init_vel = self.data.qvel #ロボットの初期速度取得\n",
    "        self.stepcount = 0\n",
    "        self.wheel_left_id = mujoco.mj_name2id(self.model, 3,'left wheel joint')\n",
    "        self.wheel_right_id = mujoco.mj_name2id(self.model, 3,'right wheel joint')\n",
    "        self.wheel_ang_left = self.data.qpos[7]\n",
    "        self.wheel_ang_right = self.data.qpos[8]\n",
    "        print(\"ID!:\",self.wheel_left_id)\n",
    "\n",
    "        # ------------------------- ここまで\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\" 状態を初期化 \"\"\"\n",
    "        self.done = False  # (A)\n",
    "        # ------------------------- 編集ここから\n",
    "        # ロボットの位置を開始位置へ戻す (C)####################################################################################################env.model.geom_pos\n",
    "        # self.data.qpos = self.init_pos\n",
    "        # self.data.qvel = self.init_vel #的な感じにして，初期の位置を与えることで初期位置に戻せるようにする　初期値を記述する　pauseしてからprint dataで取れそう？\n",
    "        self.stepcount = 0\n",
    "        mujoco.mj_resetData(self.model, self.data)\n",
    "\n",
    "        # 初期の観測値を用意 (E)\n",
    "        obs = self._make_obs()\n",
    "        # ------------------------- ここまで\n",
    "        return obs\n",
    "    \n",
    "    # def discretize(value):\n",
    "    # # 0から0.18の範囲を10段階に分割\n",
    "    #     if value == -1:\n",
    "    #         value = 0.18\n",
    "    #     discrete_value = int(value / 0.018)\n",
    "    #     return min(discrete_value, 9)  # 最大値が10段階目になるように調整 9以上にならないようにしている\n",
    "\n",
    "    # def discretize_values(self, ob1, ob2, ob3, ob4):\n",
    "    #     # 各値を離散化\n",
    "    #     discrete_ob1 = self.discretize(ob1)\n",
    "    #     discrete_ob2 = self.discretize(ob2)\n",
    "    #     discrete_ob3 = self.discretize(ob3)\n",
    "    #     discrete_ob4 = self.discretize(ob4)\n",
    "    #     sum = discrete_ob1*1000 + discrete_ob2*100 + discrete_ob3*10 + discrete_ob4*1\n",
    "\n",
    "    #     return sum\n",
    "\n",
    "    # 離散化\n",
    "    def bins(self, clip_min, clip_max, num):\n",
    "        return np.linspace(clip_min, clip_max, num + 1)[1:-1]\n",
    "\n",
    "    def _make_obs(self): #クラスの内部でしか使わない，内部用メソッドであるため_をつけている\n",
    "        \"\"\" 状態から観測を作成(状態（観測）の離散化を行って観測とする) \"\"\"\n",
    "        # 最終状態判定がTrueだったら 9999 を出力 (A)\n",
    "        if self.done is True:\n",
    "            obs = np.array([9] * 4)\n",
    "            return obs #どうせこの後はリセットするし，あまり意味はないかも\n",
    "        \n",
    "        # 4つのセンサの値を受け取り，それを離散化して0~9で表したのち，4桁の整数１つとして観測を表す\n",
    "        ob1 = self.data.sensordata[0].copy() #sensor_LF\n",
    "        ob2 = self.data.sensordata[1].copy() #sensor_LS\n",
    "        ob3 = self.data.sensordata[2].copy() #sensor_RF\n",
    "        ob4 = self.data.sensordata[3].copy() #sensor_RS\n",
    "        if ob1 == -1:\n",
    "            ob1 = 0.15\n",
    "        if ob2 == -1:\n",
    "            ob2 = 0.15\n",
    "        if ob3 == -1:\n",
    "            ob3 = 0.15\n",
    "        if ob4 == -1:\n",
    "            ob4 = 0.15\n",
    "        # quat = self.data.xquat[1]\n",
    "        # rounded_quat = round(quat, 2)\n",
    "        # self.rounded_quat_array = np.array(rounded_quat)\n",
    "\n",
    "        # goal_quat = [0, 0.7, 0, 0]\n",
    "        # self.goal_quat_array = np.array(goal_quat)\n",
    "\n",
    "        # obs = self.rounded_quat_array - self.goal_quat_array\n",
    "\n",
    "\n",
    "        obs=np.digitize(ob1, bins=self.bins(0.0, 0.1, NUM_DIZITIZED))*1000 + \\\n",
    "            np.digitize(ob2, bins=self.bins(0.0, 0.1, NUM_DIZITIZED))*100 + \\\n",
    "            np.digitize(ob3, bins=self.bins(0.0, 0.1, NUM_DIZITIZED))*10 + \\\n",
    "            np.digitize(ob4, bins=self.bins(0.0, 0.1, NUM_DIZITIZED))*1\n",
    "        \n",
    "        # print(obs)\n",
    "        return obs\n",
    "\n",
    "    def step(self, act_select):\n",
    "        \"\"\" 状態を更新 \"\"\"\n",
    "        # 最終状態の次の状態はリセット(A)\n",
    "        if self.done is True:\n",
    "            obs = self.reset()\n",
    "            return 0, None, obs\n",
    "        \n",
    "        # step数が基準を超えたら\n",
    "        if self.stepcount == MAX_STEP:\n",
    "            obs = self.reset()\n",
    "            rwd = 1\n",
    "            return rwd, None, obs\n",
    "        \n",
    "        \n",
    "        if act_select == 0:\n",
    "            act = [0.2, 0.2]\n",
    "        elif act_select == 1:\n",
    "            act = [-0.2, -0.2]\n",
    "        elif act_select == 2:\n",
    "            act = [-0.2, 0.2]\n",
    "        elif act_select == 3:\n",
    "            act = [0.2, -0.2] \n",
    "        # elif act_select == 4:\n",
    "        #     act = [0, 0] #行動選択を具体的なモータ出力に変換している(モータを動かす組み合わせを選ぶ)\n",
    "        else:\n",
    "            print(\"ありえない行動選択をしているこれはバグに違いない\")\n",
    "        \n",
    "        self.data.ctrl = act.copy() #行動選択のactをctrlにコピーすることで，モータを回す\n",
    "        # before_goal_range = np.sqrt((before_goal_pos[0] - before_mm_pos[0])**2+(before_goal_pos[1] - before_mm_pos[1])**2) #三平方の定理\n",
    "        self.prev_wheel_ang_left = self.data.qpos[7]\n",
    "        self.prev_wheel_ang_right = self.data.qpos[8]\n",
    "        \n",
    "        mujoco.mj_step(self.model, self.data) #1step進める###########################################################################################################\n",
    "        self.wheel_ang_left = self.data.qpos[7]\n",
    "        self.wheel_ang_right = self.data.qpos[8]\n",
    "        self.stepcount += 1 #step数を測るためのインスタンス変数\n",
    "        mujoco.mj_kinematics(self.model, self.data) #ネームアクセスするために必要\n",
    "        # goal_pos = self.data.geom('goal').xpos #ゴールの位置座標取得\n",
    "        robot_pos = self.data.geom('mein_body1').xpos #ロボットの位置座標取得\n",
    "        hit_wall_f = self.data.sensordata[4].copy() #フォースセンサの値取得\n",
    "        hit_wall_b = self.data.sensordata[5].copy() #フォースセンサの値取得\n",
    "        \n",
    "        \n",
    "        # if hit_wall_b != 0:\n",
    "        #     print(hit_wall_b)\n",
    "        # if hit_wall_f != 0:\n",
    "        #     print(hit_wall_f)\n",
    "\n",
    "        # goal_range = np.sqrt((goal_pos - robot_pos)**2)\n",
    "        # goal_range = np.sqrt((goal_pos[0] - robot_pos[0])**2+(goal_pos[1] - robot_pos[1])**2) #三平方の定理\n",
    "        # if goal_range < 0.16: #ゴールしたら\n",
    "        #     rwd = 2\n",
    "        #     print(\"goal!!\")\n",
    "        #     whatdone = True\n",
    "        if hit_wall_f > 0 or hit_wall_b > 0:\n",
    "            rwd = (self.stepcount/MAX_STEP) - 1\n",
    "            whatdone = True\n",
    "        # elif\n",
    "        else:\n",
    "            leftwheel_ang = self.wheel_ang_left - self.prev_wheel_ang_left\n",
    "            rightwheel_ang = self.wheel_ang_right - self.prev_wheel_ang_right #前ー後 つまり進んでたら正になるし下がってたら負になる\n",
    "            rwd = (leftwheel_ang + rightwheel_ang)/100 # rwd = (1/(goal_range + 0.2))*0.005 #- np.sqrt(np.sum((self.rounded_quat_array - self.goal_quat_array)**2)) #とにかくずれがバツとなる\n",
    "            # print(rwd)\n",
    "            whatdone = False\n",
    "\n",
    "        # ------------------------- ここまで\n",
    "        self.done = whatdone  # (E) #確定したdone情報を，インスタンス変数のdoneに保存\n",
    "        # ------------------------- 編集ここから\n",
    "        obs = self._make_obs()  # 行動後のobsを作成(F) ここではセンサ値を取得する　next_obsに対応している値で，行動後の観測値である．\n",
    "        # ------------------------- ここまで\n",
    "        return rwd, whatdone, obs\n",
    "\n",
    "    def render(self):\n",
    "        \"\"\" 状態に対応した画像を作成 \"\"\" #工事中################＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃＃\n",
    "        mujoco.viewer.launch_passive(self.model, self.data).sync() # mj_stepで進めたシミュレーションを，描画に反映する　　物理状態の変更を反映する\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# if __name__ == '__main__':\n",
    "#     # 操作方法の表示 (A)\n",
    "#     msg = (\n",
    "#         '\\n' +\n",
    "#         '---- 操作方法 -------------------------------------\\n'\n",
    "#         '[f] 右に進む\\n' +\n",
    "#         '[d] 拾う\\n' +\n",
    "#         '[q] 終了\\n' +\n",
    "#         'クリスタルを拾うと成功\\n' +\n",
    "#         '---------------------------------------------------'\n",
    "#     )\n",
    "#     print(msg)\n",
    "\n",
    "#     # 環境の準備 (B)\n",
    "#     env = MyEnv()\n",
    "\n",
    "#     # 環境のパラメータの与え方例\n",
    "#     \"\"\"\n",
    "#     env = CorridorEnv(\n",
    "#         field_length=6,\n",
    "#         crystal_candidate=(2, 3, 4, 5),\n",
    "#         rwd_fail=-1,\n",
    "#         rwd_move=0,\n",
    "#         rwd_crystal=10,\n",
    "#     )\n",
    "#     \"\"\"\n",
    "\n",
    "#     # 強化学習情報の初期化 (C)\n",
    "#     t = 0\n",
    "#     obs = env.reset()\n",
    "#     act = None\n",
    "#     rwd = None\n",
    "#     done = None\n",
    "\n",
    "#     # 開始の表示 (D)\n",
    "#     print('')\n",
    "#     print('あなたのプレイ開始')\n",
    "\n",
    "#     # 強化学習情報表示の関数定義 (E)\n",
    "#     def show_info(t, act, rwd, done, obs, isFirst=False):\n",
    "#         \"\"\" 強化学習情報の表示 \"\"\"\n",
    "#         if rwd is None:  # (F)\n",
    "#             if isFirst:\n",
    "#                 tt = t\n",
    "#             else:\n",
    "#                 tt = t + 1\n",
    "#             print('')\n",
    "#             print(f'x({tt:d})={str(obs):s}')\n",
    "#         else:  # (G)\n",
    "#             msg = (\n",
    "#                 f'a({t:d})={act:d}, ' +\n",
    "#                 f'r({t:d})={rwd: .2f}, ' +\n",
    "#                 f'done({t:d})={done:}, ' +\n",
    "#                 f'x({t + 1:d})={str(obs):s}'\n",
    "#             )\n",
    "#             print(msg)\n",
    "\n",
    "#     # 強化学習情報表示 (H)\n",
    "#     show_info(t, act, rwd, done, obs, isFirst=True)\n",
    "\n",
    "#     # シミュレーション (I)\n",
    "#     while True:\n",
    "#         # 画面表示 (J)\n",
    "#         image = env.render()\n",
    "#         cv2.imshow('you', image)\n",
    "\n",
    "#         # キーの受付と終了処理 (K)\n",
    "#         key = cv2.waitKey(0)\n",
    "#         if key == ord('q'):\n",
    "#             break\n",
    "\n",
    "#         # あなたの行動選択 (L)\n",
    "#         if key in [ord('d'), ord(' ')]:\n",
    "#             act = 0  # 拾う\n",
    "#         elif key == ord('f'):\n",
    "#             act = 1  # 進む\n",
    "#         else:\n",
    "#             continue\n",
    "\n",
    "#         # 環境の更新 (M)\n",
    "#         rwd, done, obs = env.step(act)\n",
    "\n",
    "#         # 強化学習情報表示 (N)\n",
    "#         show_info(t, act, rwd, done, obs)\n",
    "#         t += 1\n",
    "# 回転の運動方程式から考えて，力学が何が起きているか考える　摩擦適当じゃんそれはまずい．ご法度　"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 実行部分（main?）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID!: 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 7/2500 [00:11<1:07:15,  1.62s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of obs in Q-table --- 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 21/2500 [00:35<1:09:16,  1.68s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of obs in Q-table --- 20\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  1%|          | 29/2500 [00:49<1:18:39,  1.91s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of obs in Q-table --- 30\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  2%|▏         | 53/2500 [01:21<50:09,  1.23s/it]  "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of obs in Q-table --- 40\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  3%|▎         | 84/2500 [01:56<54:58,  1.37s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of obs in Q-table --- 50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  4%|▍         | 102/2500 [02:28<1:12:01,  1.80s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of obs in Q-table --- 60\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  5%|▍         | 113/2500 [02:43<57:35,  1.45s/it]  \n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[6], line 44\u001b[0m\n\u001b[0;32m     42\u001b[0m rwd, done, next_obs \u001b[38;5;241m=\u001b[39m env\u001b[38;5;241m.\u001b[39mstep(act)\n\u001b[0;32m     43\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m act_margin \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m500\u001b[39m):\n\u001b[1;32m---> 44\u001b[0m     \u001b[43mmujoco\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmj_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43menv\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m#1step進める###########################################################################################################\u001b[39;00m\n\u001b[0;32m     45\u001b[0m     viewer\u001b[38;5;241m.\u001b[39msync() \u001b[38;5;66;03m# mj_stepで進めたシミュレーションを，描画に反映する　　物理状態の変更を反映する\u001b[39;00m\n\u001b[0;32m     46\u001b[0m agt\u001b[38;5;241m.\u001b[39mlearn(obs, act, rwd, done, next_obs)\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "from tqdm import trange\n",
    "import numpy as np\n",
    "import mujoco\n",
    "import mujoco.viewer\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "# MAX_STEP = 90000\n",
    "NUM_EPISODE = 2500\n",
    "QTABLE_SAVE_MODE = False\n",
    "INCREMENTAL_LEARNING_MODE = False\n",
    "epi_reward_graph = []\n",
    "# timestep_count = []\n",
    "sumreward = 0\n",
    "\n",
    "\n",
    "env = MyEnv()\n",
    "agt = TableQAgt()\n",
    "\n",
    "if INCREMENTAL_LEARNING_MODE:\n",
    "        # 保存されたQテーブルを読み込む\n",
    "        with open('maze_q_table_wheel_reward.pkl', 'rb') as f:\n",
    "            loaded_data = pickle.load(f)\n",
    "\n",
    "        # 読み込んだデータから必要な変数やリストを取り出す\n",
    "        agt.Q = loaded_data['agt.Q']\n",
    "        type(agt.Q)\n",
    "        agt.len_Q = loaded_data['agt.len_Q']\n",
    "        print(\"agt.len_Q(Qテーブルの数は)\",type(agt.len_Q))\n",
    "        print(agt.len_Q)\n",
    "\n",
    "        print(\"Qtableを読み込みました．追加学習します\")\n",
    "\n",
    "with mujoco.viewer.launch_passive(env.model,env.data) as viewer: #mujoco描画起動\n",
    "\n",
    "    obs = env.reset() #エピソード初期の観測を取得\n",
    "    for episode_num in trange(NUM_EPISODE):\n",
    "        for step_num in range (MAX_STEP):\n",
    "            # time.sleep(1)  # 1秒間停止\n",
    "            act = agt.select_action(obs) #obsにより，行動を決める　Qテーブルのそのマス目を用意して，たまにイプシロングリーディでランダム動作が起きる\n",
    "            # print(\"Qtableは：\",str(obs),agt.Q[str(obs)])\n",
    "            # print(env.wheel_ang_left)\n",
    "            rwd, done, next_obs = env.step(act)\n",
    "            for act_margin in range(500):\n",
    "                mujoco.mj_step(env.model, env.data) #1step進める###########################################################################################################\n",
    "                viewer.sync() # mj_stepで進めたシミュレーションを，描画に反映する　　物理状態の変更を反映する\n",
    "            agt.learn(obs, act, rwd, done, next_obs)\n",
    "            # print(obs)####################\n",
    "            obs = next_obs\n",
    "            sumreward += rwd\n",
    "            if done == True:\n",
    "                obs = env.reset() #エピソード初期の観測を取得\n",
    "                break\n",
    "        epi_reward_graph.append(sumreward)\n",
    "        sumreward = 0\n",
    "\n",
    "        # print(episode_num % 10)\n",
    "\n",
    "        \n",
    "        if episode_num % 10 == 9: #10エピソードごとにQテーブル保存\n",
    "            if QTABLE_SAVE_MODE:\n",
    "                # Qテーブルを保存する\n",
    "                # 保存したい変数やリストを辞書にまとめる\n",
    "                data_to_save = { #辞書でまとめてます\n",
    "                    'agt.Q': agt.Q,\n",
    "                    'agt.len_Q': agt.len_Q,\n",
    "                }\n",
    "                with open('maze_q_table_wheel_reward.pkl', 'wb') as f:\n",
    "                    pickle.dump(data_to_save, f)\n",
    "                print(\"Qtable保存しました\")\n",
    "\n",
    "def generate_numbered_array(length):\n",
    "    return list(range(1, length+1))\n",
    "\n",
    "# 例: 長さ指定の配列を生成\n",
    "timestep_count = generate_numbered_array((episode_num+1))\n",
    "plt.xlabel(\"episode数\", fontname=\"MS Gothic\")\n",
    "plt.ylabel(\"reward\", fontname=\"MS Gothic\")\n",
    "plt.grid()\n",
    "plt.title(\"エピソードごとの報酬\", fontname=\"MS Gothic\")\n",
    "plt.plot(timestep_count, epi_reward_graph, linestyle='solid', label=\"reward\")\n",
    "plt.legend(prop={'family':'MS Gothic'})\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "途中で学習止めた時用のグラフ出すコード"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m現在のセルまたは前のセルでコードを実行中に、カーネルがクラッシュしました。エラーの原因を特定するには、セル内のコードを確認してください。詳細については、<a href='https://aka.ms/vscodeJupyterKernelCrash'>こちら</a> をクリックしてください。さらなる詳細については、Jupyter [log] (command:jupyter.viewOutput) を参照してください。"
     ]
    }
   ],
   "source": [
    "def generate_numbered_array(length):\n",
    "    return list(range(1, length))\n",
    "\n",
    "# 例: 長さ指定の配列を生成\n",
    "timestep_count = generate_numbered_array((episode_num+1))\n",
    "plt.xlabel(\"episode数\", fontname=\"MS Gothic\")\n",
    "plt.ylabel(\"reward\", fontname=\"MS Gothic\")\n",
    "plt.grid()\n",
    "plt.title(\"エピソードごとの報酬\", fontname=\"MS Gothic\")\n",
    "plt.plot(timestep_count, epi_reward_graph, linestyle='solid', label=\"reward\")\n",
    "plt.legend(prop={'family':'MS Gothic'})\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Qtableは： 3232 [-0.0018317902756860383, -0.004220287971822212, -0.002526959236582997, -2.3073350184116115e-07]\n"
     ]
    }
   ],
   "source": [
    "print()\n",
    "print(\"Qtableは：\",str(obs),agt.Q[str(obs)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9.99999060e-01  9.92104958e-24 -1.37118702e-03  4.89481227e-20]\n"
     ]
    }
   ],
   "source": [
    "print(env.data.xquat[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "x and y must have same first dimension, but have shapes (99,) and (100,)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\atusi\\OneDrive\\ドキュメント\\研究関連（修士）\\Github\\sibuya\\original_RL_mouse.ipynb セル 14\u001b[0m line \u001b[0;36m9\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/atusi/OneDrive/%E3%83%89%E3%82%AD%E3%83%A5%E3%83%A1%E3%83%B3%E3%83%88/%E7%A0%94%E7%A9%B6%E9%96%A2%E9%80%A3%EF%BC%88%E4%BF%AE%E5%A3%AB%EF%BC%89/Github/sibuya/original_RL_mouse.ipynb#X16sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m plt\u001b[39m.\u001b[39mgrid()\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/atusi/OneDrive/%E3%83%89%E3%82%AD%E3%83%A5%E3%83%A1%E3%83%B3%E3%83%88/%E7%A0%94%E7%A9%B6%E9%96%A2%E9%80%A3%EF%BC%88%E4%BF%AE%E5%A3%AB%EF%BC%89/Github/sibuya/original_RL_mouse.ipynb#X16sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m plt\u001b[39m.\u001b[39mtitle(\u001b[39m\"\u001b[39m\u001b[39m合計報酬推移\u001b[39m\u001b[39m\"\u001b[39m, fontname\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mMS Gothic\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/atusi/OneDrive/%E3%83%89%E3%82%AD%E3%83%A5%E3%83%A1%E3%83%B3%E3%83%88/%E7%A0%94%E7%A9%B6%E9%96%A2%E9%80%A3%EF%BC%88%E4%BF%AE%E5%A3%AB%EF%BC%89/Github/sibuya/original_RL_mouse.ipynb#X16sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m plt\u001b[39m.\u001b[39;49mplot(timestep_count, epi_reward_graph, linestyle\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39msolid\u001b[39;49m\u001b[39m'\u001b[39;49m, label\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39mreward\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/atusi/OneDrive/%E3%83%89%E3%82%AD%E3%83%A5%E3%83%A1%E3%83%B3%E3%83%88/%E7%A0%94%E7%A9%B6%E9%96%A2%E9%80%A3%EF%BC%88%E4%BF%AE%E5%A3%AB%EF%BC%89/Github/sibuya/original_RL_mouse.ipynb#X16sZmlsZQ%3D%3D?line=9'>10</a>\u001b[0m plt\u001b[39m.\u001b[39mlegend(prop\u001b[39m=\u001b[39m{\u001b[39m'\u001b[39m\u001b[39mfamily\u001b[39m\u001b[39m'\u001b[39m:\u001b[39m'\u001b[39m\u001b[39mMS Gothic\u001b[39m\u001b[39m'\u001b[39m})\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/atusi/OneDrive/%E3%83%89%E3%82%AD%E3%83%A5%E3%83%A1%E3%83%B3%E3%83%88/%E7%A0%94%E7%A9%B6%E9%96%A2%E9%80%A3%EF%BC%88%E4%BF%AE%E5%A3%AB%EF%BC%89/Github/sibuya/original_RL_mouse.ipynb#X16sZmlsZQ%3D%3D?line=10'>11</a>\u001b[0m plt\u001b[39m.\u001b[39mshow()\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\colab_env\\lib\\site-packages\\matplotlib\\pyplot.py:2869\u001b[0m, in \u001b[0;36mplot\u001b[1;34m(scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m   2867\u001b[0m \u001b[39m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[39m.\u001b[39mplot)\n\u001b[0;32m   2868\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mplot\u001b[39m(\u001b[39m*\u001b[39margs, scalex\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, scaley\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m-> 2869\u001b[0m     \u001b[39mreturn\u001b[39;00m gca()\u001b[39m.\u001b[39mplot(\n\u001b[0;32m   2870\u001b[0m         \u001b[39m*\u001b[39margs, scalex\u001b[39m=\u001b[39mscalex, scaley\u001b[39m=\u001b[39mscaley,\n\u001b[0;32m   2871\u001b[0m         \u001b[39m*\u001b[39m\u001b[39m*\u001b[39m({\u001b[39m\"\u001b[39m\u001b[39mdata\u001b[39m\u001b[39m\"\u001b[39m: data} \u001b[39mif\u001b[39;00m data \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m {}), \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\colab_env\\lib\\site-packages\\matplotlib\\axes\\_axes.py:1688\u001b[0m, in \u001b[0;36mAxes.plot\u001b[1;34m(self, scalex, scaley, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1445\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m   1446\u001b[0m \u001b[39mPlot y versus x as lines and/or markers.\u001b[39;00m\n\u001b[0;32m   1447\u001b[0m \n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1685\u001b[0m \u001b[39m(``'green'``) or hex strings (``'#008000'``).\u001b[39;00m\n\u001b[0;32m   1686\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m   1687\u001b[0m kwargs \u001b[39m=\u001b[39m cbook\u001b[39m.\u001b[39mnormalize_kwargs(kwargs, mlines\u001b[39m.\u001b[39mLine2D)\n\u001b[1;32m-> 1688\u001b[0m lines \u001b[39m=\u001b[39m [\u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_lines(\u001b[39m*\u001b[39margs, data\u001b[39m=\u001b[39mdata, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)]\n\u001b[0;32m   1689\u001b[0m \u001b[39mfor\u001b[39;00m line \u001b[39min\u001b[39;00m lines:\n\u001b[0;32m   1690\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39madd_line(line)\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\colab_env\\lib\\site-packages\\matplotlib\\axes\\_base.py:311\u001b[0m, in \u001b[0;36m_process_plot_var_args.__call__\u001b[1;34m(self, data, *args, **kwargs)\u001b[0m\n\u001b[0;32m    309\u001b[0m     this \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m args[\u001b[39m0\u001b[39m],\n\u001b[0;32m    310\u001b[0m     args \u001b[39m=\u001b[39m args[\u001b[39m1\u001b[39m:]\n\u001b[1;32m--> 311\u001b[0m \u001b[39myield from\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_plot_args(\n\u001b[0;32m    312\u001b[0m     this, kwargs, ambiguous_fmt_datakey\u001b[39m=\u001b[39;49mambiguous_fmt_datakey)\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\colab_env\\lib\\site-packages\\matplotlib\\axes\\_base.py:504\u001b[0m, in \u001b[0;36m_process_plot_var_args._plot_args\u001b[1;34m(self, tup, kwargs, return_kwargs, ambiguous_fmt_datakey)\u001b[0m\n\u001b[0;32m    501\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes\u001b[39m.\u001b[39myaxis\u001b[39m.\u001b[39mupdate_units(y)\n\u001b[0;32m    503\u001b[0m \u001b[39mif\u001b[39;00m x\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m] \u001b[39m!=\u001b[39m y\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m]:\n\u001b[1;32m--> 504\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mx and y must have same first dimension, but \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m    505\u001b[0m                      \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mhave shapes \u001b[39m\u001b[39m{\u001b[39;00mx\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m and \u001b[39m\u001b[39m{\u001b[39;00my\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[0;32m    506\u001b[0m \u001b[39mif\u001b[39;00m x\u001b[39m.\u001b[39mndim \u001b[39m>\u001b[39m \u001b[39m2\u001b[39m \u001b[39mor\u001b[39;00m y\u001b[39m.\u001b[39mndim \u001b[39m>\u001b[39m \u001b[39m2\u001b[39m:\n\u001b[0;32m    507\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mx and y can be no greater than 2D, but have \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m    508\u001b[0m                      \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mshapes \u001b[39m\u001b[39m{\u001b[39;00mx\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m and \u001b[39m\u001b[39m{\u001b[39;00my\u001b[39m.\u001b[39mshape\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n",
      "\u001b[1;31mValueError\u001b[0m: x and y must have same first dimension, but have shapes (99,) and (100,)"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 例: 長さ指定の配列を生成\n",
    "def generate_numbered_array(length):\n",
    "    return list(range(1, length+0))\n",
    "timestep_count = generate_numbered_array((episode_num+1))\n",
    "plt.xlabel(\"時間t\", fontname=\"MS Gothic\")\n",
    "plt.ylabel(\"報酬\", fontname=\"MS Gothic\")\n",
    "plt.grid()\n",
    "plt.title(\"合計報酬推移\", fontname=\"MS Gothic\")\n",
    "plt.plot(timestep_count, epi_reward_graph, linestyle='solid', label=\"reward\")\n",
    "plt.legend(prop={'family':'MS Gothic'})\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.     0.     0.   ]\n",
      " [ 0.     0.     0.001]\n",
      " [ 0.04   0.03   0.001]\n",
      " [ 0.04  -0.03   0.001]\n",
      " [-0.04   0.03   0.001]\n",
      " [-0.04  -0.03   0.001]\n",
      " [-0.027  0.     0.001]\n",
      " [ 0.027  0.     0.001]\n",
      " [ 0.     0.     0.   ]\n",
      " [ 0.     0.     0.   ]\n",
      " [ 0.     0.     0.   ]\n",
      " [ 0.     0.     0.   ]\n",
      " [ 0.     0.     0.   ]\n",
      " [ 0.     0.     0.   ]\n",
      " [ 0.     0.     0.   ]\n",
      " [ 0.     0.     0.   ]]\n"
     ]
    }
   ],
   "source": [
    "print(env.model.geom_pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "digitize() takes from 2 to 3 positional arguments but 4 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32mc:\\myprojects\\iRL\\main\\RL_mouse.ipynb セル 10\u001b[0m line \u001b[0;36m3\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#X12sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mnumpy\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mnp\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#X12sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m ob1 \u001b[39m=\u001b[39m \u001b[39m0.7\u001b[39m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#X12sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m obs\u001b[39m=\u001b[39mnp\u001b[39m.\u001b[39;49mdigitize(ob1, \u001b[39m0.0\u001b[39;49m, \u001b[39m0.18\u001b[39;49m, \u001b[39m10\u001b[39;49m)\u001b[39m*\u001b[39m\u001b[39m1000\u001b[39m\n",
      "File \u001b[1;32m<__array_function__ internals>:198\u001b[0m, in \u001b[0;36mdigitize\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: digitize() takes from 2 to 3 positional arguments but 4 were given"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "ob1 = 0.7\n",
    "obs=np.digitize(ob1, 0.0, 0.18, 10)*1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# agt_netQ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "partially initialized module 'charset_normalizer' has no attribute 'md__mypyc' (most likely due to a circular import)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\requests\\compat.py:11\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m---> 11\u001b[0m     \u001b[39mimport\u001b[39;00m \u001b[39mchardet\u001b[39;00m\n\u001b[0;32m     12\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mImportError\u001b[39;00m:\n",
      "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'chardet'",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\myprojects\\iRL\\main\\RL_mouse.ipynb セル 6\u001b[0m line \u001b[0;36m1\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mos\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m \u001b[39m# import torch\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m \u001b[39m# from torch import nn\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m \n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=9'>10</a>\u001b[0m \u001b[39m# import torch.optim as optim\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=10'>11</a>\u001b[0m \u001b[39m# from torch.utils.data import DataLoader\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=11'>12</a>\u001b[0m \u001b[39m# from torchvision import datasets, transforms\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=12'>13</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mkeras\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmodels\u001b[39;00m \u001b[39mimport\u001b[39;00m Sequential\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=13'>14</a>\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mkeras\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mlayers\u001b[39;00m \u001b[39mimport\u001b[39;00m Dense, Flatten\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W5sZmlsZQ%3D%3D?line=18'>19</a>\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mmujoco\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\__init__.py:51\u001b[0m\n\u001b[0;32m     49\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m autograph\n\u001b[0;32m     50\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m bitwise\n\u001b[1;32m---> 51\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m compat\n\u001b[0;32m     52\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m config\n\u001b[0;32m     53\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m data\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\__init__.py:37\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[39m\"\"\"Compatibility functions.\u001b[39;00m\n\u001b[0;32m      4\u001b[0m \n\u001b[0;32m      5\u001b[0m \u001b[39mThe `tf.compat` module contains two sets of compatibility functions.\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     32\u001b[0m \n\u001b[0;32m     33\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m     35\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39msys\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39m_sys\u001b[39;00m\n\u001b[1;32m---> 37\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m v1\n\u001b[0;32m     38\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m v2\n\u001b[0;32m     39\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m \u001b[39mimport\u001b[39;00m forward_compatibility_horizon\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v1\\__init__.py:30\u001b[0m\n\u001b[0;32m     28\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m autograph\n\u001b[0;32m     29\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m bitwise\n\u001b[1;32m---> 30\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m compat\n\u001b[0;32m     31\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m config\n\u001b[0;32m     32\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m data\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v1\\compat\\__init__.py:38\u001b[0m\n\u001b[0;32m     35\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39msys\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39m_sys\u001b[39;00m\n\u001b[0;32m     37\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m v1\n\u001b[1;32m---> 38\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m v2\n\u001b[0;32m     39\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m \u001b[39mimport\u001b[39;00m forward_compatibility_horizon\n\u001b[0;32m     40\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m \u001b[39mimport\u001b[39;00m forward_compatible\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v1\\compat\\v2\\__init__.py:28\u001b[0m\n\u001b[0;32m     25\u001b[0m \u001b[39m# pylint: disable=g-bad-import-order\u001b[39;00m\n\u001b[0;32m     27\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m compat\n\u001b[1;32m---> 28\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m __internal__\n\u001b[0;32m     29\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m __operators__\n\u001b[0;32m     30\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m audio\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v2\\__init__.py:33\u001b[0m\n\u001b[0;32m     31\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m autograph\n\u001b[0;32m     32\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m bitwise\n\u001b[1;32m---> 33\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m compat\n\u001b[0;32m     34\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m config\n\u001b[0;32m     35\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m data\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v2\\compat\\__init__.py:38\u001b[0m\n\u001b[0;32m     35\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39msys\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39m_sys\u001b[39;00m\n\u001b[0;32m     37\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m v1\n\u001b[1;32m---> 38\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m v2\n\u001b[0;32m     39\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m \u001b[39mimport\u001b[39;00m forward_compatibility_horizon\n\u001b[0;32m     40\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m \u001b[39mimport\u001b[39;00m forward_compatible\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v2\\compat\\v2\\__init__.py:37\u001b[0m\n\u001b[0;32m     35\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m data\n\u001b[0;32m     36\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m debugging\n\u001b[1;32m---> 37\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m distribute\n\u001b[0;32m     38\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m dtypes\n\u001b[0;32m     39\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39m_api\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mv2\u001b[39;00m \u001b[39mimport\u001b[39;00m errors\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v2\\distribute\\__init__.py:182\u001b[0m\n\u001b[0;32m    180\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m cluster_resolver\n\u001b[0;32m    181\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m coordinator\n\u001b[1;32m--> 182\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m experimental\n\u001b[0;32m    183\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcollective_all_reduce_strategy\u001b[39;00m \u001b[39mimport\u001b[39;00m CollectiveAllReduceStrategy \u001b[39mas\u001b[39;00m MultiWorkerMirroredStrategy\n\u001b[0;32m    184\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcross_device_ops\u001b[39;00m \u001b[39mimport\u001b[39;00m CrossDeviceOps\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v2\\distribute\\experimental\\__init__.py:10\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m coordinator\n\u001b[0;32m      9\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m partitioners\n\u001b[1;32m---> 10\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m \u001b[39mimport\u001b[39;00m rpc\n\u001b[0;32m     11\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcentral_storage_strategy\u001b[39;00m \u001b[39mimport\u001b[39;00m CentralStorageStrategy\n\u001b[0;32m     12\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcollective_all_reduce_strategy\u001b[39;00m \u001b[39mimport\u001b[39;00m _CollectiveAllReduceStrategyExperimental \u001b[39mas\u001b[39;00m MultiWorkerMirroredStrategy\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\_api\\v2\\compat\\v2\\distribute\\experimental\\rpc\\__init__.py:8\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[39m\"\"\"Public API for tf.distribute.experimental.rpc namespace.\u001b[39;00m\n\u001b[0;32m      4\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m      6\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39msys\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39m_sys\u001b[39;00m\n\u001b[1;32m----> 8\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mexperimental\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mrpc\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mrpc_ops\u001b[39;00m \u001b[39mimport\u001b[39;00m Client\n\u001b[0;32m      9\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mexperimental\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mrpc\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mrpc_ops\u001b[39;00m \u001b[39mimport\u001b[39;00m Server\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\python\\distribute\\experimental\\__init__.py:22\u001b[0m\n\u001b[0;32m     20\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m \u001b[39mimport\u001b[39;00m parameter_server_strategy\n\u001b[0;32m     21\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m \u001b[39mimport\u001b[39;00m tpu_strategy\n\u001b[1;32m---> 22\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mfailure_handling\u001b[39;00m \u001b[39mimport\u001b[39;00m failure_handling\n\u001b[0;32m     23\u001b[0m \u001b[39m# pylint: enable=unused-import\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\python\\distribute\\failure_handling\\failure_handling.py:33\u001b[0m\n\u001b[0;32m     31\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcheckpoint\u001b[39;00m \u001b[39mimport\u001b[39;00m checkpoint_management\n\u001b[0;32m     32\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m \u001b[39mimport\u001b[39;00m multi_worker_util\n\u001b[1;32m---> 33\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mdistribute\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mfailure_handling\u001b[39;00m \u001b[39mimport\u001b[39;00m gce_util\n\u001b[0;32m     34\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39meager\u001b[39;00m \u001b[39mimport\u001b[39;00m context\n\u001b[0;32m     35\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mframework\u001b[39;00m \u001b[39mimport\u001b[39;00m constant_op\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\tensorflow\\python\\distribute\\failure_handling\\gce_util.py:20\u001b[0m\n\u001b[0;32m     17\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mos\u001b[39;00m\n\u001b[0;32m     18\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39msys\u001b[39;00m\n\u001b[1;32m---> 20\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mrequests\u001b[39;00m\n\u001b[0;32m     22\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msix\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmoves\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39murllib\u001b[39;00m \u001b[39mimport\u001b[39;00m request\n\u001b[0;32m     23\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtensorflow\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mpython\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39meager\u001b[39;00m \u001b[39mimport\u001b[39;00m context\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\requests\\__init__.py:45\u001b[0m\n\u001b[0;32m     41\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mwarnings\u001b[39;00m\n\u001b[0;32m     43\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39murllib3\u001b[39;00m\n\u001b[1;32m---> 45\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39mexceptions\u001b[39;00m \u001b[39mimport\u001b[39;00m RequestsDependencyWarning\n\u001b[0;32m     47\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m     48\u001b[0m     \u001b[39mfrom\u001b[39;00m \u001b[39mcharset_normalizer\u001b[39;00m \u001b[39mimport\u001b[39;00m __version__ \u001b[39mas\u001b[39;00m charset_normalizer_version\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\requests\\exceptions.py:9\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[39mrequests.exceptions\u001b[39;00m\n\u001b[0;32m      3\u001b[0m \u001b[39m~~~~~~~~~~~~~~~~~~~\u001b[39;00m\n\u001b[0;32m      4\u001b[0m \n\u001b[0;32m      5\u001b[0m \u001b[39mThis module contains the set of Requests' exceptions.\u001b[39;00m\n\u001b[0;32m      6\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m      7\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39murllib3\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mexceptions\u001b[39;00m \u001b[39mimport\u001b[39;00m HTTPError \u001b[39mas\u001b[39;00m BaseHTTPError\n\u001b[1;32m----> 9\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39m.\u001b[39;00m\u001b[39mcompat\u001b[39;00m \u001b[39mimport\u001b[39;00m JSONDecodeError \u001b[39mas\u001b[39;00m CompatJSONDecodeError\n\u001b[0;32m     12\u001b[0m \u001b[39mclass\u001b[39;00m \u001b[39mRequestException\u001b[39;00m(\u001b[39mIOError\u001b[39;00m):\n\u001b[0;32m     13\u001b[0m \u001b[39m    \u001b[39m\u001b[39m\"\"\"There was an ambiguous exception that occurred while handling your\u001b[39;00m\n\u001b[0;32m     14\u001b[0m \u001b[39m    request.\u001b[39;00m\n\u001b[0;32m     15\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\requests\\compat.py:13\u001b[0m\n\u001b[0;32m     11\u001b[0m     \u001b[39mimport\u001b[39;00m \u001b[39mchardet\u001b[39;00m\n\u001b[0;32m     12\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mImportError\u001b[39;00m:\n\u001b[1;32m---> 13\u001b[0m     \u001b[39mimport\u001b[39;00m \u001b[39mcharset_normalizer\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mchardet\u001b[39;00m\n\u001b[0;32m     15\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39msys\u001b[39;00m\n\u001b[0;32m     17\u001b[0m \u001b[39m# -------\u001b[39;00m\n\u001b[0;32m     18\u001b[0m \u001b[39m# Pythons\u001b[39;00m\n\u001b[0;32m     19\u001b[0m \u001b[39m# -------\u001b[39;00m\n\u001b[0;32m     20\u001b[0m \n\u001b[0;32m     21\u001b[0m \u001b[39m# Syntax sugar.\u001b[39;00m\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\charset_normalizer\\__init__.py:23\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[39mCharset-Normalizer\u001b[39;00m\n\u001b[0;32m      3\u001b[0m \u001b[39m~~~~~~~~~~~~~~\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m     21\u001b[0m \u001b[39m:license: MIT, see LICENSE for more details.\u001b[39;00m\n\u001b[0;32m     22\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m---> 23\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcharset_normalizer\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mapi\u001b[39;00m \u001b[39mimport\u001b[39;00m from_fp, from_path, from_bytes, normalize\n\u001b[0;32m     24\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcharset_normalizer\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mlegacy\u001b[39;00m \u001b[39mimport\u001b[39;00m detect\n\u001b[0;32m     25\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcharset_normalizer\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mversion\u001b[39;00m \u001b[39mimport\u001b[39;00m __version__, VERSION\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\env_iRL\\lib\\site-packages\\charset_normalizer\\api.py:10\u001b[0m\n\u001b[0;32m      7\u001b[0m     PathLike \u001b[39m=\u001b[39m Union[\u001b[39mstr\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mos.PathLike[str]\u001b[39m\u001b[39m'\u001b[39m]  \u001b[39m# type: ignore\u001b[39;00m\n\u001b[0;32m      9\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcharset_normalizer\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mconstant\u001b[39;00m \u001b[39mimport\u001b[39;00m TOO_SMALL_SEQUENCE, TOO_BIG_SEQUENCE, IANA_SUPPORTED\n\u001b[1;32m---> 10\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcharset_normalizer\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmd\u001b[39;00m \u001b[39mimport\u001b[39;00m mess_ratio\n\u001b[0;32m     11\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcharset_normalizer\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mmodels\u001b[39;00m \u001b[39mimport\u001b[39;00m CharsetMatches, CharsetMatch\n\u001b[0;32m     12\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mwarnings\u001b[39;00m \u001b[39mimport\u001b[39;00m warn\n",
      "\u001b[1;31mAttributeError\u001b[0m: partially initialized module 'charset_normalizer' has no attribute 'md__mypyc' (most likely due to a circular import)"
     ]
    }
   ],
   "source": [
    "# \"\"\"\n",
    "# agt_netQ.py\n",
    "# ニューラルネット（Qネットワーク）を使ったQ学習アルゴリズム\n",
    "# \"\"\"\n",
    "# import numpy as np\n",
    "# import os\n",
    "# import torch\n",
    "# from torch import nn\n",
    "\n",
    "# import torch.optim as optim\n",
    "# from torch.utils.data import DataLoader\n",
    "# from torchvision import datasets, transforms\n",
    "# # from tensorflow.keras.models import Sequential\n",
    "# # from tensorflow.keras.layers import Dense, Flatten\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# import mujoco\n",
    "\n",
    "# # 自作モジュール\n",
    "# # import core\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SimpleNet(\n",
      "  (fc1): Linear(in_features=4, out_features=32, bias=True)\n",
      "  (fc2): Linear(in_features=32, out_features=2, bias=True)\n",
      "  (relu): ReLU()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# # ネットワークの定義\n",
    "# class SimpleNet(nn.Module):\n",
    "#     def __init__(self):\n",
    "#         super(SimpleNet, self).__init__()\n",
    "#         self.fc1 = nn.Linear(4, 32)  # 入力層から中間層への結合\n",
    "#         self.fc2 = nn.Linear(32, 2)  # 中間層から出力層への結合\n",
    "\n",
    "#     def forward(self, x):\n",
    "#         x = torch.relu(self.fc1(x))  # 中間層でReLUを使用\n",
    "#         x = self.fc2(x)  # 出力層では活性化関数を使わない（恒等関数）\n",
    "#         return x\n",
    "\n",
    "# # ネットワークのインスタンス化\n",
    "# net = SimpleNet()\n",
    "\n",
    "# # オプティマイザの定義\n",
    "# optimizer = optim.Adam(net.parameters(), lr=0.01)\n",
    "\n",
    "# # ネットワークの構造を表示\n",
    "# print(net)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class NetQAgt(coreAgt):\n",
    "#     \"\"\" Qネットワークを使ったQ学習エージェントクラス \"\"\"\n",
    "#     def __init__(               # 引数とデフォルト値の設定 (A)\n",
    "#             self,\n",
    "#             n_act=3,            # int: 行動の種類数（ネットワークの出力数）\n",
    "#             input_size=(4,),    # tuple of int: 入力サイズ\n",
    "#             n_dense=32,         # int: 中間層のニューロン数\n",
    "#             epsilon=0.1,        # float: 乱雑度\n",
    "#             gamma=0.9,          # float: 割引率\n",
    "#             filepath=None,      # str: 保存ファイル名\n",
    "#             ):\n",
    "#         \"\"\" 初期処理 \"\"\"\n",
    "#         # 引数の設定は適時編集\n",
    "#         self.epsilon = epsilon\n",
    "#         # ------------------------- 編集ここから\n",
    "\n",
    "#         # アトリビュートにパラメータを保存 (B)\n",
    "#         self.n_act = n_act\n",
    "#         self.input_size = input_size\n",
    "#         self.n_dense = n_dense\n",
    "#         self.gamma = gamma\n",
    "#         self.filepath = filepath\n",
    "\n",
    "#         # アトリビュートにモデルを保存 (C)\n",
    "#         self.model = self._build_Qnet()\n",
    "#         # ------------------------- ここまで\n",
    "\n",
    "#     def _build_Qnet(self):\n",
    "#         \"\"\" 指定したパラメータでQネットワークを構築 \"\"\"\n",
    "#         # Qネットワークの構築 (A)\n",
    "#         self.net = SimpleNet()\n",
    "#         # オプティマイザの定義\n",
    "#         self.optimizer = optim.Adam(net.parameters(), lr=0.01)\n",
    "#         # 損失関数の定義\n",
    "#         self.criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "#         return net\n",
    "\n",
    "#     def select_action(self, obs):\n",
    "#         \"\"\"  観測に対して行動を出力 \"\"\"\n",
    "#     # ------------------------- 編集ここから\n",
    "#     # 確率的に処理を分岐 (A)\n",
    "#         if np.random.rand() < self.epsilon:\n",
    "#             # ランダム行動 (B)\n",
    "#             act = np.random.randint(0, self.n_act)\n",
    "#         else:\n",
    "#             # obsに対するQ値のリストを取得 (C)\n",
    "#             Q = self.get_Q(obs)\n",
    "\n",
    "#             # Qを最大にする行動\n",
    "#             act = np.argmax(Q)\n",
    "#         # ------------------------- ここまで\n",
    "#         return act\n",
    "\n",
    "#     def get_Q(self, obs):\n",
    "#         \"\"\" 観測に対するQ値を出力 \"\"\"\n",
    "#         # ------------------------- 編集ここから\n",
    "#         # 観測obsを入力し出力を得る (A)\n",
    "#         Q = self.model.predict(\n",
    "#             obs.reshape((1,) + self.input_size))[0, :]\n",
    "#         # ------------------------- ここまで\n",
    "#         return Q\n",
    "\n",
    "#     def learn(self, obs, act, rwd, done, next_obs):\n",
    "#         \"\"\" 学習 \"\"\"\n",
    "#         if rwd is None:\n",
    "#             return\n",
    "#         # ------------------------- 編集ここから\n",
    "\n",
    "#         # obs に対するQネットワークの出力yを得る (A)\n",
    "#         y = self.get_Q(obs)\n",
    "\n",
    "#         # target にyの内容をコピーする (B)\n",
    "#         target = y.copy()\n",
    "\n",
    "#         if done is False:\n",
    "#             # 最終状態でなかったら next_obsに対する next_yを得る(C)\n",
    "#             next_y = self.get_Q(next_obs)\n",
    "\n",
    "#             # Q[obs][act]のtarget_actを作成 (D)\n",
    "#             target_act = rwd + self.gamma * max(next_y)\n",
    "#         else:\n",
    "#             # 最終状態の場合は報酬だけでtarget_actを作成 (E)\n",
    "#             target_act = rwd\n",
    "\n",
    "#         # targetのactの要素だけtarget_actにする (F)\n",
    "#         target[act] = target_act\n",
    "\n",
    "#         # obsと target のペアを与えて学習 (G)\n",
    "\n",
    "#         # 学習のループ\n",
    "#         for epoch in range(1):  # 1エポックの例\n",
    "#             optimizer.zero_grad()  # 勾配をリセット\n",
    "#             output = net(obs)  # フォワードパス\n",
    "#             loss = self.criterion(output, target)  # 損失の計算\n",
    "#             loss.backward()  # バックワードパス（勾配の計算）\n",
    "#             optimizer.step()  # パラメータの更新\n",
    "#         # ------------------------- ここまで\n",
    "#         return \n",
    "\n",
    "#     # def save_weights(self, filepath=None):\n",
    "#     #     \"\"\" モデルの重みデータの保存 \"\"\"\n",
    "#     #     # ------------------------- 編集ここから\n",
    "#     #     if filepath is None:\n",
    "#     #         filepath = self.filepath\n",
    "#     #     self.model.save(filepath + '.h5', overwrite=True)\n",
    "#     #     # ------------------------- ここまで\n",
    "\n",
    "#     # def load_weights(self, filepath=None):\n",
    "#     #     \"\"\" モデルの重みデータの読み込み \"\"\"\n",
    "#     #     # ------------------------- 編集ここから\n",
    "#     #     if filepath is None:\n",
    "#     #         filepath = self.filepath\n",
    "#     #     self.model = tf.keras.models.load_model(filepath + '.h5')\n",
    "#     #     # ------------------------- ここまで\n",
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# if __name__ == '__main__':\n",
    "#     # エージェントのインスタンス生成 (A)\n",
    "#     agt = NetQAgt(n_act=3, input_size=(5,))\n",
    "\n",
    "#     # 行動選択 (B)\n",
    "#     obs = np.array([[1, 1, 1, 1, 1]])\n",
    "#     act = agt.select_action(obs)\n",
    "#     print('act', act)\n",
    "\n",
    "#     # 学習 (C)\n",
    "#     rwd = 1\n",
    "#     done = False\n",
    "#     next_obs = np.array([[1, 1, 1, 1, 2]])\n",
    "#     agt.learn(obs, act, rwd, done, next_obs)\n",
    "\n",
    "#     # モデル構造の表示 (D)\n",
    "#     print('モデルの構造')\n",
    "#     agt.model.summary()\n",
    "\n",
    "#     # 重みパラメータの保存 (E)\n",
    "#     agt.save_weights('agt_data/test')\n",
    "\n",
    "#     # 重みパラメータの読み込み (F)\n",
    "#     agt.load_weights('agt_data/test')\n",
    "\n",
    "#     # モデルへの観測の入力 (G)\n",
    "#     y = agt.model.predict(obs)\n",
    "#     print('モデルの出力 y', y.reshape(-1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mujocoで学習開始!!!\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'SimpleNet' object has no attribute 'predict'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\myprojects\\iRL\\main\\RL_mouse.ipynb セル 11\u001b[0m line \u001b[0;36m1\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m obs \u001b[39m=\u001b[39m env\u001b[39m.\u001b[39mreset()\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=9'>10</a>\u001b[0m \u001b[39mfor\u001b[39;00m t \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m100\u001b[39m):\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=10'>11</a>\u001b[0m     act \u001b[39m=\u001b[39m agt\u001b[39m.\u001b[39;49mselect_action(obs) \u001b[39m#たまにQ値最適の行動を選ぶ　グリーディほう\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=11'>12</a>\u001b[0m     rwd, done, next_obs \u001b[39m=\u001b[39m env\u001b[39m.\u001b[39mstep(act) \n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=12'>13</a>\u001b[0m     reward_for_graph\u001b[39m.\u001b[39mappend(rwd)\n",
      "\u001b[1;32mc:\\myprojects\\iRL\\main\\RL_mouse.ipynb セル 11\u001b[0m line \u001b[0;36m4\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=45'>46</a>\u001b[0m     act \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mrandom\u001b[39m.\u001b[39mrandint(\u001b[39m0\u001b[39m, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_act)\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=46'>47</a>\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=47'>48</a>\u001b[0m     \u001b[39m# obsに対するQ値のリストを取得 (C)\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=48'>49</a>\u001b[0m     Q \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mget_Q(obs)\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=50'>51</a>\u001b[0m     \u001b[39m# Qを最大にする行動\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=51'>52</a>\u001b[0m     act \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margmax(Q)\n",
      "\u001b[1;32mc:\\myprojects\\iRL\\main\\RL_mouse.ipynb セル 11\u001b[0m line \u001b[0;36m6\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=56'>57</a>\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\" 観測に対するQ値を出力 \"\"\"\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=57'>58</a>\u001b[0m \u001b[39m# ------------------------- 編集ここから\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=58'>59</a>\u001b[0m \u001b[39m# 観測obsを入力し出力を得る (A)\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=59'>60</a>\u001b[0m Q \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mmodel\u001b[39m.\u001b[39;49mpredict(\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=60'>61</a>\u001b[0m     obs\u001b[39m.\u001b[39mreshape((\u001b[39m1\u001b[39m,) \u001b[39m+\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39minput_size))[\u001b[39m0\u001b[39m, :]\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=61'>62</a>\u001b[0m \u001b[39m# ------------------------- ここまで\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#W6sZmlsZQ%3D%3D?line=62'>63</a>\u001b[0m \u001b[39mreturn\u001b[39;00m Q\n",
      "File \u001b[1;32mc:\\Users\\atusi\\anaconda3\\envs\\takara\\lib\\site-packages\\torch\\nn\\modules\\module.py:1614\u001b[0m, in \u001b[0;36mModule.__getattr__\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m   1612\u001b[0m     \u001b[39mif\u001b[39;00m name \u001b[39min\u001b[39;00m modules:\n\u001b[0;32m   1613\u001b[0m         \u001b[39mreturn\u001b[39;00m modules[name]\n\u001b[1;32m-> 1614\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mAttributeError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39m'\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m object has no attribute \u001b[39m\u001b[39m'\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[0;32m   1615\u001b[0m     \u001b[39mtype\u001b[39m(\u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m, name))\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'SimpleNet' object has no attribute 'predict'"
     ]
    }
   ],
   "source": [
    "# from tqdm import trange\n",
    "# print('mujocoで学習開始!!!')\n",
    "# reward_for_graph = []\n",
    "\n",
    "# env=MyEnv()\n",
    "\n",
    "# agt= NetQAgt(2,4,32,0.1,0.9,)\n",
    "\n",
    "# obs = env.reset()\n",
    "# for t in range(100):\n",
    "#     act = agt.select_action(obs) #たまにQ値最適の行動を選ぶ　グリーディほう\n",
    "#     rwd, done, next_obs = env.step(act) \n",
    "#     reward_for_graph.append(rwd)\n",
    "\n",
    "#     agt.learn(obs, act, rwd, done, next_obs)\n",
    "\n",
    "#     obs = next_obs\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "^C\n"
     ]
    }
   ],
   "source": [
    "!pip uninstall tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "module 'tensorflow' has no attribute 'keras'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32mc:\\myprojects\\iRL\\main\\RL_mouse.ipynb セル 9\u001b[0m line \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/myprojects/iRL/main/RL_mouse.ipynb#X11sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m fashion_mnist \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39;49mkeras\u001b[39m.\u001b[39mdatasets\u001b[39m.\u001b[39mfashion_mnist\n",
      "\u001b[1;31mAttributeError\u001b[0m: module 'tensorflow' has no attribute 'keras'"
     ]
    }
   ],
   "source": [
    "fashion_mnist = tf.keras.datasets.fashion_mnist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 離散化コード"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discretize(value):\n",
    "    # 0から0.18の範囲を10段階に分割\n",
    "    if value == -1:\n",
    "        value = 0.18\n",
    "    discrete_value = int(value / 0.018)\n",
    "    return min(discrete_value, 9)  # 最大値が10段階目になるように調整 9以上にならないようにしている\n",
    "\n",
    "def discretize_values(ob1, ob2, ob3, ob4):\n",
    "    # 各値を離散化\n",
    "    discrete_ob1 = discretize(ob1)\n",
    "    discrete_ob2 = discretize(ob2)\n",
    "    discrete_ob3 = discretize(ob3)\n",
    "    discrete_ob4 = discretize(ob4)\n",
    "    sum = discrete_ob1*1000 + discrete_ob2*100 + discrete_ob3*10 + discrete_ob4*1\n",
    "\n",
    "    return discrete_ob1, discrete_ob2, discrete_ob3, discrete_ob4, sum\n",
    "\n",
    "# 例: ob1=0.05, ob2=0.10, ob3=0.15, ob4=0.18 の場合\n",
    "ob1 = 0.14\n",
    "ob2 = 0.10\n",
    "ob3 = 0.15\n",
    "ob4 = 0.18\n",
    "\n",
    "discrete_ob1, discrete_ob2, discrete_ob3, discrete_ob4, sum = discretize_values(ob1, ob2, ob3, ob4)\n",
    "\n",
    "print(f\"Discretized Values: {discrete_ob1}, {discrete_ob2}, {discrete_ob3}, {discrete_ob4}, {sum}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env_iRL",
   "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}