RL_Project_3_Q2_Gene_Regulatory_Network-4.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "UjiPNdIopIZI"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.patches import Rectangle\n",
        "from copy import copy, deepcopy\n",
        "import random\n",
        "import math\n",
        "import pickle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "FbluC9Vspv-s"
      },
      "outputs": [],
      "source": [
        "\"\"\"create action arrays\"\"\"\n",
        "def define_action_space(i):\n",
        "  actions=[]\n",
        "  if(i==1):\n",
        "    a1=np.array([[0],[0],[0],[0]])\n",
        "    a2=np.array([[0],[1],[0],[0]])\n",
        "    a3=np.array([[0],[0],[1],[0]])\n",
        "    a4=np.array([[0],[0],[1],[1]])\n",
        "    a5=np.array([[0],[0],[0],[1]])\n",
        "    actions.append(a1)\n",
        "    actions.append(a2)\n",
        "    actions.append(a3)\n",
        "    actions.append(a4)\n",
        "    actions.append(a5)\n",
        "  else:\n",
        "    a1=np.array([[0],[0],[0],[0]])\n",
        "    a2=np.array([[0],[1],[0],[0]])\n",
        "    a3=np.array([[0],[0],[1],[0]])\n",
        "    a4=np.array([[0],[0],[0],[1]])\n",
        "    actions.append(a1)\n",
        "    actions.append(a2)\n",
        "    actions.append(a3)\n",
        "    actions.append(a4)\n",
        "  return actions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "pOuufDcTp8YF"
      },
      "outputs": [],
      "source": [
        "\"\"\"test create action\"\"\"\n",
        "def test_define_action_space():\n",
        "  action_op1=define_action_space(1)\n",
        "  actions_op0=define_action_space(0)\n",
        "  assert(len(action_op1)==5)\n",
        "  temp_array=np.array([[0],[0],[0],[1]])\n",
        "  assert(np.array_equal(action_op1[4],temp_array))\n",
        "  assert(np.array_equal(actions_op0[3],temp_array))\n",
        "  assert(len(actions_op0)==4)\n",
        "test_define_action_space()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "wBciDeF8qIZ0"
      },
      "outputs": [],
      "source": [
        "def create_states():\n",
        "  states=[]\n",
        "  first_array=np.array([[0],[0],[0],[0]])\n",
        "  for i in range(16):\n",
        "    number_list=[]\n",
        "    byte_string='{0:04b}'.format(i)\n",
        "    for ch in byte_string:\n",
        "      number_list.append(int(ch))\n",
        "    states.append(np.asarray(number_list).reshape(4,1))\n",
        "  return states\n",
        "#create_states()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yG2LwlQgqLMY",
        "outputId": "eb567c53-dc35-45b8-9f45-21725ef9db80"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(16, 4, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "np.shape(create_states())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "v85G1KgebMYS"
      },
      "outputs": [],
      "source": [
        "def state_to_Index(input_state):\n",
        "  dim=np.shape(input_state)[0]\n",
        "  index=0\n",
        "  for i in range(dim):\n",
        "    index+=math.pow(2,i)*input_state[i]\n",
        "  return int(index)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "XQfCKFsbbrlH"
      },
      "outputs": [],
      "source": [
        "def test_state_to_Index():\n",
        "  test_input_state=np.array([[1],[1],[0],[1]])\n",
        "  assert(state_to_Index(test_input_state)==11)\n",
        "  test_input_state=np.array([[1],[1],[1],[1]])\n",
        "  assert(state_to_Index(test_input_state)==15)\n",
        "test_state_to_Index()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "ToHHvUJEsecy"
      },
      "outputs": [],
      "source": [
        "def computeL1Norm(a):   # assumes input is np array of shape x,1\n",
        "  norm=0\n",
        "  for i in range(np.shape(a)[0]):\n",
        "    norm+=np.abs(a[i][0])\n",
        "  return norm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "Ni4hozyzuQU0"
      },
      "outputs": [],
      "source": [
        "def test_computeL1Norm():\n",
        "  arr=np.array([[0],[1],[2]])\n",
        "  assert(computeL1Norm(arr)==3)\n",
        "test_computeL1Norm()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "RBzqW1deuT_A"
      },
      "outputs": [],
      "source": [
        "def calculate_two_state_reward(state1,state2,action):  # state 2 is the destination state\n",
        "  return computeL1Norm(5*state2)-computeL1Norm(action)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "TQ5AWCMguab_"
      },
      "outputs": [],
      "source": [
        "def test_calculate_two_state_reward():\n",
        "  state1=np.array([[1],[0]])\n",
        "  state2=np.array([[0],[1]])\n",
        "  action=np.array([[1],[1]])\n",
        "  test_ans=calculate_two_state_reward(state1, state2,action)\n",
        "  assert(test_ans==3)\n",
        "test_calculate_two_state_reward()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "B2ktJEmluc3a"
      },
      "outputs": [],
      "source": [
        "def create_some_noise(vector_size,p):\n",
        "  return np.random.binomial(1,p,vector_size).reshape(vector_size,1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4CHcT5vEybqf",
        "outputId": "72a55a11-942a-4510-db4c-675dc466c0f4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0]\n",
            " [0]\n",
            " [0]\n",
            " [0]]\n"
          ]
        }
      ],
      "source": [
        "def test_create_some_noise():\n",
        "  print(create_some_noise(4,0.05))\n",
        "test_create_some_noise()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "gh5TRMtJ2lWE"
      },
      "outputs": [],
      "source": [
        "# assume matrix is np array of shape(x,1)\n",
        "def vectorize_matrix(some_matrix):\n",
        "  dim1 = np.shape(some_matrix)[0]\n",
        "  for i in range(dim1):\n",
        "    if(some_matrix[i,0]>0):\n",
        "      some_matrix[i,0]=1\n",
        "    else:\n",
        "      some_matrix[i,0]=0\n",
        "  return some_matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "NSE1UmVN4tB-"
      },
      "outputs": [],
      "source": [
        "def test_vectorize_matrix():\n",
        "  test_matrix=np.array([[2],[0],[0],[0]])\n",
        "  test_matrix=vectorize_matrix(test_matrix)\n",
        "  assert(test_matrix[0,0]==1)\n",
        "  assert(test_matrix[2,0]==0)\n",
        "test_vectorize_matrix()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "WhpHdvGH5vJp"
      },
      "outputs": [],
      "source": [
        "def computeXOR(a,b):\n",
        "  xor=[]\n",
        "  for i in range(np.shape(a)[0]):\n",
        "    if(a[i][0]==b[i][0]):\n",
        "      ans=0\n",
        "    else:\n",
        "      ans=1\n",
        "    xor.append(ans)\n",
        "  return np.asarray(xor).reshape(np.shape(a)[0],1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "rBtAwvMi7FSp"
      },
      "outputs": [],
      "source": [
        "def test_compute_XOR():\n",
        "  arr1=np.array([[0],[0],[1],[1]])\n",
        "  arr2=np.array([[0],[1],[0],[1]])\n",
        "  arr3=computeXOR(arr1,arr2)\n",
        "  assert(arr3.shape==(4,1))\n",
        "  assert(arr3[0][0]==0)\n",
        "  assert(arr3[1][0]==1)\n",
        "  assert(arr3[2][0]==1)\n",
        "  assert(arr3[3][0]==0)\n",
        "test_compute_XOR()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "LN-Pvx98yeci"
      },
      "outputs": [],
      "source": [
        "def compute_next_state(connectivity_matrix,current_state,action,noise):\n",
        "  assert(np.shape(current_state)[0]==4)\n",
        "  assert(np.shape(current_state)[1]==1)\n",
        "  assert(np.shape(action)[0]==4)\n",
        "  assert(np.shape(action)[1]==1)\n",
        "  next_state=computeXOR(computeXOR(vectorize_matrix(np.matmul(connectivity_matrix,current_state)),action),noise)\n",
        "  return next_state"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "rMOCjYrG8iS4"
      },
      "outputs": [],
      "source": [
        "def test_compute_next_state():\n",
        "  connectivity_matrix=np.array([[0,0,-1,0],[1,0,-1,-1],[0,1,0,0],[-1,1,1,0]])\n",
        "  test_action=np.array([[0],[0],[0],[1]])\n",
        "  test_state=np.array([[0],[1],[1],[1]])\n",
        "  noise=np.array([[0],[0],[0],[0]])\n",
        "  test_next_state=np.array([[0],[0],[1],[0]])\n",
        "  assert(np.array_equal(test_next_state,np.array([[0],[0],[1],[0]])))\n",
        "test_compute_next_state()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TLWVW-F_o8ce"
      },
      "source": [
        "**Q-Learning**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "o92oTbospPmv"
      },
      "outputs": [],
      "source": [
        "def create_Q_Matrix(action_space_size):\n",
        "  Q_Matrix=np.zeros(shape=(16,action_space_size))\n",
        "  for i in range(16):\n",
        "    for k in range(action_space_size):\n",
        "      Q_Matrix[i,k]=0\n",
        "  return Q_Matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "NogSHuygq0hz"
      },
      "outputs": [],
      "source": [
        "def test_create_Q_Matrix():\n",
        "  test_state=create_states()\n",
        "  test_Q_Matrix=create_Q_Matrix(4)\n",
        "  assert(np.shape(test_Q_Matrix)[1]==4)\n",
        "  assert(np.shape(test_Q_Matrix)[0]==16)\n",
        "  #assert(np.shape(test_Q_Matrix)[1]==4)\n",
        "  assert(test_Q_Matrix[0,0]==0)\n",
        "test_create_Q_Matrix()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "gwfVigaW-yUu"
      },
      "outputs": [],
      "source": [
        "def epsilonGreedy(qlist,epsilon):\n",
        "  #qlist=[qa1,qa2,qa3,qa4]\n",
        "  action = np.random.uniform()\n",
        "  action_space_size=len(qlist)\n",
        "  # exploration\n",
        "  if(action<epsilon):\n",
        "    #print(\"in exploration\")\n",
        "    non_greedy_choice=random.randint(0,action_space_size-1)\n",
        "    #print(\"greedy choice:{}\".format(greedy_choice))\n",
        "    action_taken=non_greedy_choice+1\n",
        "    '''if(non_greedy_choice==0):\n",
        "      action_taken=1\n",
        "    elif(non_greedy_choice==1):\n",
        "      action_taken=2\n",
        "    elif(non_greedy_choice==2):\n",
        "      action_taken=3\n",
        "    elif(non_greedy_choice==3):\n",
        "      action_taken=4'''\n",
        "    return action_taken\n",
        "  # greedy approach - exploitation\n",
        "  # randommization for equal case\n",
        "  maxq=max(qlist)\n",
        "  if(qlist[0]==qlist[1]):\n",
        "    maxindex=random.randint(0,1)\n",
        "  max_list=[]\n",
        "  for i in range(len(qlist)):\n",
        "    if(np.isclose(qlist[i],maxq)):\n",
        "      max_list.append(i)\n",
        "  maxindex = random.choice(max_list)\n",
        "  #print(maxindex)\n",
        "  action_taken=maxindex+1\n",
        "  return action_taken"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-kaSdpEWFusL",
        "outputId": "e2a331e4-9892-4079-b8e0-d90161bbbf2f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ],
      "source": [
        "def test_epsilon_greedy():\n",
        "  print(epsilonGreedy([1,2,3,4],0.9))\n",
        "test_epsilon_greedy()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "Y4UxzhjuyXbN"
      },
      "outputs": [],
      "source": [
        "def find_max_Q(qmatrix,i,action_space_size):\n",
        "  max=qmatrix[i,0]\n",
        "  pos=0\n",
        "  for k in range(action_space_size):\n",
        "    if(qmatrix[i,k]>max):\n",
        "      max=qmatrix[i,k]\n",
        "      pos=k\n",
        "  # check for multiple equal Q-values\n",
        "  maxposlist=[]\n",
        "  for k in range(action_space_size):\n",
        "    if(qmatrix[i,k]==max):\n",
        "      maxposlist.append(k)\n",
        "  #print(maxposlist)\n",
        "  pos=np.random.choice(maxposlist)\n",
        "  max=qmatrix[i,pos]\n",
        "  return max,pos"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pQYXJlHD1nLI",
        "outputId": "6eb6fa2b-8a24-441e-b7b0-ad5a4118378a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ],
      "source": [
        "def test_find_max_Q():\n",
        "  qmatrix=create_Q_Matrix(4)\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  max_item,max_index=find_max_Q(qmatrix,0,4)\n",
        "  assert(max_item==0)\n",
        "  print(max_index)\n",
        "test_find_max_Q()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "sp5Cwjwr-9Pj"
      },
      "outputs": [],
      "source": [
        "def Q_Learning(value_matrix,action_space_size,epsilon,alpha,gamma,p,episodes_limit,steps_limit,start_state,connectivity_matrix):\n",
        "  # states must be a 4x1 np array\n",
        "  Q_Matrix=create_Q_Matrix(action_space_size)\n",
        "  rewards_in_episodes=[]\n",
        "  vector_actions=define_action_space(3)\n",
        "  for i in range(episodes_limit):\n",
        "    # an episode\n",
        "    in_episode_total=0\n",
        "    state=start_state\n",
        "    steps_iter=0\n",
        "    while(steps_iter<steps_limit):\n",
        "      steps_iter+=1\n",
        "      current_state_index=state_to_Index(state)\n",
        "      qlist=[]\n",
        "      for j in range(action_space_size):\n",
        "        qlist.append(Q_Matrix[current_state_index,j])\n",
        "      action_to_take=epsilonGreedy(qlist,epsilon)\n",
        "      potential_next_state=compute_next_state(connectivity_matrix,state,vector_actions[action_to_take-1],create_some_noise(4,p))\n",
        "      reward=calculate_two_state_reward(state,potential_next_state,vector_actions[action_to_take-1])\n",
        "      in_episode_total+=reward\n",
        "      max_q,max_q_action=find_max_Q(Q_Matrix,state_to_Index(potential_next_state),action_space_size)\n",
        "      Q_Matrix[current_state_index,action_to_take-1]+=alpha*(reward+gamma*max_q-Q_Matrix[current_state_index,action_to_take-1])\n",
        "      state=potential_next_state\n",
        "    rewards_in_episodes.append(in_episode_total/steps_iter)\n",
        "  return Q_Matrix,rewards_in_episodes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {
        "id": "b4nyno11sJ81"
      },
      "outputs": [],
      "source": [
        "def average_rewards_across_runs(no_of_runs,rewards_across_runs):\n",
        "  averaged_rewards=[]\n",
        "  for k in range(len(rewards_across_runs)):\n",
        "    rewards_across_runs[k]=np.cumsum(rewards_across_runs[k])\n",
        "    for l1 in range(len(rewards_across_runs[k])):\n",
        "      rewards_across_runs[k][l1]=(rewards_across_runs[k][l1])/(l1+1)\n",
        "  for i in range(len(rewards_across_runs[0])):\n",
        "    component_total=0\n",
        "    for j in range(len(rewards_across_runs)):\n",
        "      component_total+=rewards_across_runs[j][i]\n",
        "    averaged_rewards.append(component_total/(len(rewards_across_runs)))\n",
        "  return averaged_rewards"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {
        "id": "yNZB_MRRtXfp"
      },
      "outputs": [],
      "source": [
        "def test_average_rewards_across_runs():\n",
        "  test_input=[]\n",
        "  for i in range(10):\n",
        "    test_ip=[0]*500\n",
        "    test_input.append(test_ip)\n",
        "  test_out=average_rewards_across_runs(10,test_input)\n",
        "  assert(len(test_out)==500)\n",
        "test_average_rewards_across_runs()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {
        "id": "7NGDMwWqvG9x"
      },
      "outputs": [],
      "source": [
        "def get_connectivity_matrix():\n",
        "  connectivity_matrix=np.array([[0,0,-1,0],[1,0,-1,-1],[0,1,0,0],[-1,1,1,0]])\n",
        "  return connectivity_matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MF9H_XO0z7zT",
        "outputId": "857764d3-c252-4f98-db15-60d400414fbc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 0  0 -1  0]\n",
            " [ 1  0 -1 -1]\n",
            " [ 0  1  0  0]\n",
            " [-1  1  1  0]]\n"
          ]
        }
      ],
      "source": [
        "def test_get_connectivity_matrix():\n",
        "  print(get_connectivity_matrix())\n",
        "test_get_connectivity_matrix()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "zqlYStG0v8DM"
      },
      "outputs": [],
      "source": [
        "def generate_Q_learning_policy(Q_Matrix):\n",
        "  xdim=Q_Matrix.shape[0]\n",
        "  action_space_size=Q_Matrix.shape[1]\n",
        "  policy=np.zeros((xdim))\n",
        "  for i in range(xdim):\n",
        "    max_q,max_q_action=find_max_Q(Q_Matrix,i,action_space_size)\n",
        "    policy[i]=int(max_q_action)\n",
        "  return policy"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "id": "jAjEYOgQXXsY"
      },
      "outputs": [],
      "source": [
        "def plot_episode_wise_rewards(rewards_in_episodes):\n",
        "  xdim=len(rewards_in_episodes)\n",
        "  fig, bob = plt.subplots(figsize=(10, 10),dpi=80)\n",
        "  bob.set(title = \"Accumulated reward vs episodes for alpha=0.2\",xlabel = \"episodes\", ylabel = \"Accumulated reward\")\n",
        "  bob.plot(range(xdim),rewards_in_episodes)\n",
        "  #plt.legend(['epsilon=0','epsilon=0.1','epsilon=0.2','epsilon=0.5'])\n",
        "  plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def printPolicy(policy):\n",
        "  policy_to_print=[]\n",
        "  for i in range(np.shape(policy)[0]):\n",
        "    if(policy[i]==0):\n",
        "      policy_to_print.append('a0')\n",
        "    elif(policy[i]==1):\n",
        "      policy_to_print.append('a1')\n",
        "    elif(policy[i]==2):\n",
        "      policy_to_print.append('a2')\n",
        "    elif(policy[i]==3):\n",
        "      policy_to_print.append('a3')\n",
        "  return policy_to_print"
      ],
      "metadata": {
        "id": "jV3L-D0rBf2B"
      },
      "execution_count": 43,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "GTQZ7B0ppO_y",
        "outputId": "6eb44588-8d95-406d-b592-eef4201de13c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a1', 'a2', 'a1', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 2 iteration\n",
            "['a1', 'a1', 'a1', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 3 iteration\n",
            "['a1', 'a1', 'a1', 'a3', 'a1', 'a0', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 4 iteration\n",
            "['a1', 'a0', 'a1', 'a2', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 5 iteration\n",
            "['a1', 'a3', 'a1', 'a2', 'a1', 'a2', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 6 iteration\n",
            "['a1', 'a3', 'a1', 'a0', 'a1', 'a0', 'a1', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 7 iteration\n",
            "['a1', 'a0', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 8 iteration\n",
            "['a1', 'a0', 'a1', 'a0', 'a1', 'a3', 'a1', 'a1', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 9 iteration\n",
            "['a1', 'a3', 'a1', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 10 iteration\n",
            "['a1', 'a1', 'a1', 'a3', 'a1', 'a1', 'a1', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "def run_Q_Learning(no_of_runs):\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  value_matrix=np.zeros(shape=(16,1))\n",
        "  rewards_across_runs=[]\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  for i in range(no_of_runs):\n",
        "    connectivity_matrix=get_connectivity_matrix()\n",
        "    q,rewards=Q_Learning(value_matrix,4,0.1,0.2,0.95,0.05,500,500,start_state=np.array([[0],[0],[0],[0]]),connectivity_matrix=get_connectivity_matrix())\n",
        "    policy=generate_Q_learning_policy(q)\n",
        "    rewards_across_runs.append(rewards)\n",
        "    print(\"Policy for {} iteration\".format(i+1))\n",
        "    print_policy=printPolicy(policy)\n",
        "    print(print_policy)\n",
        "    #if(policy[state_to_Index(start_state)]==3):\n",
        "    #  policy_to_display=policy\n",
        "    #path=create_path_dict(policy)\n",
        "    #path_to_goal_exsists(path)\n",
        "  rewards=average_rewards_across_runs(no_of_runs,rewards_across_runs)\n",
        "  plot_episode_wise_rewards(rewards)\n",
        "  #draw_graphs(policy_to_display,rewards)\n",
        "  return rewards\n",
        "q_learning_rewards=run_Q_Learning(10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kaB16F_ti10P"
      },
      "source": [
        "**SARSA**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {
        "id": "qjT7C9ZAL1L4"
      },
      "outputs": [],
      "source": [
        "def SARSA_learning(value_matrix,action_space_size,epsilon,alpha,gamma,p,episodes_limit,steps_limit,start_state,connectivity_matrix):\n",
        "  sarsa_matrix=create_Q_Matrix(action_space_size)\n",
        "  vector_actions=define_action_space(3)\n",
        "  rewards_in_episodes=[]\n",
        "  for i in range(episodes_limit):\n",
        "    state=start_state\n",
        "    current_state_index=state_to_Index(state)\n",
        "    sarsa_list=[]\n",
        "    for j in range(action_space_size):\n",
        "      sarsa_list.append(sarsa_matrix[current_state_index,j])\n",
        "    action_to_take=epsilonGreedy(sarsa_list,epsilon)\n",
        "    in_episode_total=0\n",
        "    steps_iter=0\n",
        "    while(steps_iter<steps_limit):\n",
        "      steps_iter+=1\n",
        "      if(steps_iter>steps_limit):\n",
        "        break\n",
        "      potential_next_state=compute_next_state(connectivity_matrix,state,vector_actions[action_to_take-1],create_some_noise(4,p))\n",
        "      next_state_index=state_to_Index(potential_next_state)\n",
        "      reward=calculate_two_state_reward(state,potential_next_state,vector_actions[action_to_take-1])\n",
        "      in_episode_total+=reward\n",
        "      sarsa_next_list=[]\n",
        "      for k1 in range(action_space_size):\n",
        "        sarsa_next_list.append(sarsa_matrix[next_state_index,k1])\n",
        "      action_in_next_state=epsilonGreedy(sarsa_next_list,epsilon)\n",
        "      sarsa_matrix[current_state_index,action_to_take-1]+=alpha*(reward+gamma*sarsa_matrix[next_state_index,action_in_next_state-1]-sarsa_matrix[current_state_index,action_to_take-1])\n",
        "      state=potential_next_state\n",
        "      action_to_take=action_in_next_state\n",
        "      current_state_index=next_state_index\n",
        "    rewards_in_episodes.append(in_episode_total/steps_iter)\n",
        "  return sarsa_matrix,rewards_in_episodes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "YQkO795Iqr3r",
        "outputId": "d034b818-de20-421e-d0b9-d70159bab3d0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a2', 'a2', 'a1', 'a3', 'a1', 'a3', 'a1', 'a0', 'a1', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 2 iteration\n",
            "['a2', 'a2', 'a1', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a0', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1']\n",
            "Policy for 3 iteration\n",
            "['a1', 'a2', 'a1', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 4 iteration\n",
            "['a1', 'a1', 'a1', 'a3', 'a1', 'a2', 'a1', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 5 iteration\n",
            "['a1', 'a0', 'a1', 'a1', 'a1', 'a2', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 6 iteration\n",
            "['a1', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 7 iteration\n",
            "['a1', 'a1', 'a1', 'a0', 'a1', 'a3', 'a1', 'a0', 'a1', 'a2', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1']\n",
            "Policy for 8 iteration\n",
            "['a1', 'a2', 'a1', 'a1', 'a2', 'a2', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1']\n",
            "Policy for 9 iteration\n",
            "['a2', 'a2', 'a1', 'a3', 'a1', 'a1', 'a1', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 10 iteration\n",
            "['a1', 'a2', 'a1', 'a1', 'a1', 'a3', 'a1', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "def run_SARSA_Learning(no_of_runs):\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  value_matrix=np.zeros(shape=(16,1))\n",
        "  rewards_across_runs=[]\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  for i in range(no_of_runs):\n",
        "    connectivity_matrix=get_connectivity_matrix()\n",
        "    sarsa,rewards=SARSA_learning(value_matrix,4,0.1,0.2,0.95,0.05,500,500,start_state=np.array([[0],[0],[0],[0]]),connectivity_matrix=get_connectivity_matrix())\n",
        "    policy=generate_Q_learning_policy(sarsa)\n",
        "    rewards_across_runs.append(rewards)\n",
        "    print(\"Policy for {} iteration\".format(i+1))\n",
        "    print_policy=printPolicy(policy)\n",
        "    print(print_policy)\n",
        "  rewards=average_rewards_across_runs(no_of_runs,rewards_across_runs)\n",
        "  plot_episode_wise_rewards(rewards)\n",
        "  return rewards\n",
        "sarsa_rewards=run_SARSA_Learning(10)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**SARSA-LAMBDA**"
      ],
      "metadata": {
        "id": "bmJyVInC53Ls"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "z0H6b_aorgCh"
      },
      "outputs": [],
      "source": [
        "def sarsa_lamda_update(sarsa_matrix,error_matrix,delta,alpha,gamma):\n",
        "  state_space_size=np.shape(sarsa_matrix)[0]\n",
        "  action_space_size=np.shape(sarsa_matrix)[1]\n",
        "  for i in range(state_space_size):\n",
        "    for j in range(action_space_size):\n",
        "      sarsa_matrix[i,j]+=alpha*delta*error_matrix[i,j]\n",
        "      error_matrix[i,j]=error_matrix[i,j]*gamma\n",
        "  return sarsa_matrix,error_matrix"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def SARSA_lambda(value_matrix,action_space_size,epsilon,alpha,gamma,p,episodes_limit,steps_limit,start_state,connectivity_matrix):\n",
        "  sarsa_matrix=create_Q_Matrix(action_space_size)\n",
        "  vector_actions=define_action_space(3)\n",
        "  rewards_in_episodes=[]\n",
        "  for i in range(episodes_limit):\n",
        "    state=start_state\n",
        "    current_state_index=state_to_Index(state)\n",
        "    sarsa_list=[]\n",
        "    error_matrix=create_Q_Matrix(action_space_size)\n",
        "    for j in range(action_space_size):\n",
        "      sarsa_list.append(sarsa_matrix[current_state_index,j])\n",
        "    action_to_take=epsilonGreedy(sarsa_list,epsilon)\n",
        "    in_episode_total=0\n",
        "    steps_iter=0\n",
        "    while(steps_iter<steps_limit):\n",
        "      steps_iter+=1\n",
        "      if(steps_iter>steps_limit):\n",
        "        break\n",
        "      potential_next_state=compute_next_state(connectivity_matrix,state,vector_actions[action_to_take-1],create_some_noise(4,p))\n",
        "      next_state_index=state_to_Index(potential_next_state)\n",
        "      reward=calculate_two_state_reward(state,potential_next_state,vector_actions[action_to_take-1])\n",
        "      in_episode_total+=reward\n",
        "      sarsa_next_list=[]\n",
        "      for k1 in range(action_space_size):\n",
        "        sarsa_next_list.append(sarsa_matrix[next_state_index,k1])\n",
        "      action_in_next_state=epsilonGreedy(sarsa_next_list,epsilon)\n",
        "      delta=alpha*(reward+gamma*sarsa_matrix[next_state_index,action_in_next_state-1]-sarsa_matrix[current_state_index,action_to_take-1])\n",
        "      error_matrix[current_state_index,action_to_take-1]+=1\n",
        "      sarsa_matrix,error_matrix=sarsa_lamda_update(sarsa_matrix,error_matrix,delta)\n",
        "      #next state updates\n",
        "      state=potential_next_state\n",
        "      action_to_take=action_in_next_state\n",
        "      current_state_index=next_state_index\n",
        "    rewards_in_episodes.append(in_episode_total/steps_iter)\n",
        "  return sarsa_matrix,rewards_in_episodes"
      ],
      "metadata": {
        "id": "jGOqMWXiyyY8"
      },
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def run_SARSA_Lambda_Learning(no_of_runs):\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  value_matrix=np.zeros(shape=(16,1))\n",
        "  rewards_across_runs=[]\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  for i in range(no_of_runs):\n",
        "    connectivity_matrix=get_connectivity_matrix()\n",
        "    sarsa,rewards=SARSA_learning(value_matrix,4,0.1,0.2,0.95,0.05,500,500,start_state=np.array([[0],[0],[0],[0]]),connectivity_matrix=get_connectivity_matrix())\n",
        "    policy=generate_Q_learning_policy(sarsa)\n",
        "    rewards_across_runs.append(rewards)\n",
        "    print(\"Policy for {} iteration\".format(i+1))\n",
        "    print_policy=printPolicy(policy)\n",
        "    print(print_policy)\n",
        "  rewards=average_rewards_across_runs(no_of_runs,rewards_across_runs)\n",
        "  plot_episode_wise_rewards(rewards)\n",
        "  return rewards # change this\n",
        "sarsa_lambda_rewards=run_SARSA_Lambda_Learning(10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "O95C-4ge8VBl",
        "outputId": "6f7301ca-7246-4515-fa3c-dd4778ff69e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a1', 'a3', 'a1', 'a0', 'a1', 'a3', 'a1', 'a1', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 2 iteration\n",
            "['a1', 'a2', 'a1', 'a1', 'a1', 'a2', 'a1', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1']\n",
            "Policy for 3 iteration\n",
            "['a1', 'a0', 'a1', 'a1', 'a1', 'a3', 'a1', 'a0', 'a1', 'a1', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 4 iteration\n",
            "['a2', 'a2', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 5 iteration\n",
            "['a1', 'a0', 'a1', 'a3', 'a1', 'a1', 'a1', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 6 iteration\n",
            "['a1', 'a2', 'a1', 'a0', 'a2', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 7 iteration\n",
            "['a2', 'a1', 'a1', 'a2', 'a2', 'a1', 'a1', 'a1', 'a1', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 8 iteration\n",
            "['a1', 'a0', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a2', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 9 iteration\n",
            "['a1', 'a3', 'a1', 'a1', 'a1', 'a3', 'a1', 'a0', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 10 iteration\n",
            "['a1', 'a0', 'a1', 'a3', 'a1', 'a1', 'a1', 'a3', 'a2', 'a3', 'a1', 'a3', 'a1', 'a2', 'a1', 'a1']\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Actor-Critic**"
      ],
      "metadata": {
        "id": "qnJMdB53MR1i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def actor_critic_action(action_space_size,policy,x):\n",
        "  # returns 0,1,2,3\n",
        "  poslist=[]\n",
        "  #print(policy[0,0,0])\n",
        "  for i in range(action_space_size):\n",
        "    poslist.append(i)\n",
        "  return np.random.choice(poslist,p=policy[x])"
      ],
      "metadata": {
        "id": "lnms-6Go8ho4"
      },
      "execution_count": 47,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def test_actor_critic_action():\n",
        "  test_policy=np.array([[0.25,0.25,0.25,0.25]])\n",
        "  #print(np.shape(test_policy))\n",
        "  #print(actor_critic_action(4,test_policy,0,0))\n",
        "  #assert(actor_critic_action(4,test_policy,0,0)==2 or actor_critic_action(4,test_policy,0,0)==3)\n",
        "  test_policy2=np.zeros(shape=[2,4])\n",
        "  print(np.shape(test_policy2))\n",
        "  test_policy2[0]=[0.5,0.1,0.2,0.2]\n",
        "  test_policy2[1]=[0.5,0.2,0.3,0.0]\n",
        "  print(actor_critic_action(4,test_policy,0))\n",
        "test_actor_critic_action()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2vvMRp0PNDDb",
        "outputId": "292d5370-4cec-480c-eef6-17105aabf05d"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2, 4)\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def recompute_policy(preference_matrix,policy_matrix,x,action_space_size):\n",
        "  expo_sum=0\n",
        "  for i in range(action_space_size):\n",
        "    expo_sum+=np.exp(preference_matrix[x,i])\n",
        "  for j in range(action_space_size):\n",
        "    policy_matrix[x,j]=np.exp(preference_matrix[x,j])/expo_sum\n",
        "  return policy_matrix"
      ],
      "metadata": {
        "id": "p2RBP6A6NSXr"
      },
      "execution_count": 49,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def test_recompute_policy():\n",
        "  test_policy=np.array([[0,0.1,0.2,0.2]])\n",
        "  test_preference=np.array([[0,0,0,0]])\n",
        "  ans=recompute_policy(test_preference,test_policy,0,4)\n",
        "  assert(ans[0,0]==0.25)\n",
        "  assert(ans[0,1]==0.25)\n",
        "  assert(ans[0,2]==0.25)\n",
        "  assert(ans[0,3]==0.25)\n",
        "  # sum of all policy matrix at state should be 1\n",
        "test_recompute_policy()"
      ],
      "metadata": {
        "id": "ICO_M167NzST"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_random_state():\n",
        "  states_set=create_states()\n",
        "  xdim=np.shape(states_set)[0]\n",
        "  random_number = random.randint(0,xdim-1)\n",
        "  return states_set[random_number]"
      ],
      "metadata": {
        "id": "LfO0bOkpktAs"
      },
      "execution_count": 68,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def test_get_random_state():\n",
        "  print(get_random_state())\n",
        "test_get_random_state()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZphjECxJk-he",
        "outputId": "d0e2f7e6-a030-4437-b6af-2458c46ce14b"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1]\n",
            " [0]\n",
            " [1]\n",
            " [0]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def actor_critic(value_matrix,gamma,alpha,beta,action_space_size,episodes_limit,steps_limit,p,start_state,connectivity_matrix):\n",
        "  qMatrix=create_Q_Matrix(action_space_size)\n",
        "  xdim=np.shape(qMatrix)[0]\n",
        "  vMatrix=np.zeros([xdim,1])\n",
        "  preference_matrix=np.zeros(shape=(xdim,action_space_size))\n",
        "  policy_matrix=np.zeros(shape=(xdim,action_space_size))\n",
        "  vector_actions=define_action_space(3)\n",
        "  #put np.nan in these matrices for wall states\n",
        "  for i in range(xdim):\n",
        "    for a in range(action_space_size):\n",
        "      policy_matrix[i,a]=(1/action_space_size)\n",
        "  rewards=[]\n",
        "  for i in range(episodes_limit):\n",
        "    #state=start_state\n",
        "    state=get_random_state()\n",
        "    cx=state_to_Index(start_state)\n",
        "    step_count=0\n",
        "    episode_Reward=0\n",
        "    while(step_count<steps_limit):\n",
        "      step_count+=1\n",
        "      action_to_take=actor_critic_action(action_space_size,policy_matrix,cx)\n",
        "      potential_next_state=compute_next_state(connectivity_matrix,state,vector_actions[action_to_take],create_some_noise(4,p))\n",
        "      next_state_index=state_to_Index(potential_next_state)\n",
        "      reward=calculate_two_state_reward(state,potential_next_state,vector_actions[action_to_take])\n",
        "      delta=reward+gamma*vMatrix[next_state_index] - vMatrix[cx]\n",
        "      vMatrix[cx] = vMatrix[cx]+alpha*delta\n",
        "      preference_matrix[cx,action_to_take]+=beta*delta*(1-policy_matrix[cx,action_to_take])\n",
        "      #recompute policy for cx,cy\n",
        "      policy_matrix=recompute_policy(preference_matrix,policy_matrix,cx,action_space_size)\n",
        "      cx=next_state_index\n",
        "      episode_Reward+=reward\n",
        "    rewards.append(episode_Reward/step_count)\n",
        "  return policy_matrix,rewards"
      ],
      "metadata": {
        "id": "TymQWYpGOTlr"
      },
      "execution_count": 75,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_actor_critic_policy(policy_matrix):\n",
        "  xdim=np.shape(policy_matrix)[0]\n",
        "  action_space_size=np.shape(policy_matrix)[1]\n",
        "  policy=np.zeros(shape=(xdim))\n",
        "  for i in range(xdim):\n",
        "    maxpos=0\n",
        "    for k in range(action_space_size):\n",
        "      if(policy_matrix[i,k]>policy_matrix[i,maxpos]):\n",
        "        maxpos=k\n",
        "    policy[i]=int(maxpos)\n",
        "  return policy"
      ],
      "metadata": {
        "id": "WFCBaab4Zl-3"
      },
      "execution_count": 65,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def test_generate_actor_critic_policy():\n",
        "  test_policy_matrix1=test_policy=np.array([[0.0,0.2,0.7,0.1]])\n",
        "  print(np.shape(test_policy_matrix1))\n",
        "  test_policy=generate_actor_critic_policy(test_policy_matrix1)\n",
        "  print(test_policy[0])\n",
        "test_generate_actor_critic_policy()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CBB4lhWtaKkR",
        "outputId": "3327f90f-b559-46a8-9f17-683bf286e8c5"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 4)\n",
            "2.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def run_actor_critic(no_of_runs):\n",
        "  rewards_across_runs=[]\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  for i in range(no_of_runs):\n",
        "    value_matrix=create_Q_Matrix(4)\n",
        "    policy_matrix,rewards=actor_critic(value_matrix,0.95,0.2,0.05,4,500,500,0.05,start_state,get_connectivity_matrix())\n",
        "    policy=generate_actor_critic_policy(policy_matrix)\n",
        "    print(\"Policy for {} iteration\".format(i+1))\n",
        "    print_policy=printPolicy(policy)\n",
        "    print(print_policy)\n",
        "    rewards_across_runs.append(rewards)\n",
        "  rewards=average_rewards_across_runs(no_of_runs,rewards_across_runs)\n",
        "  plot_episode_wise_rewards(rewards)\n",
        "  return rewards\n",
        "actor_critic_learning_rewards=run_actor_critic(10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "wxgH13BmdfW9",
        "outputId": "42e11901-2203-48c2-b3ac-1f54ffcc9af9"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a3', 'a1', 'a3', 'a3', 'a3', 'a2', 'a3', 'a0', 'a1', 'a3', 'a1', 'a3', 'a1', 'a3', 'a3', 'a0']\n",
            "Policy for 2 iteration\n",
            "['a2', 'a1', 'a2', 'a1', 'a2', 'a2', 'a2', 'a2', 'a2', 'a2', 'a1', 'a0', 'a2', 'a2', 'a2', 'a2']\n",
            "Policy for 3 iteration\n",
            "['a1', 'a2', 'a2', 'a1', 'a3', 'a1', 'a3', 'a2', 'a3', 'a3', 'a3', 'a1', 'a3', 'a2', 'a1', 'a3']\n",
            "Policy for 4 iteration\n",
            "['a3', 'a1', 'a1', 'a1', 'a3', 'a2', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a3', 'a2', 'a1', 'a3']\n",
            "Policy for 5 iteration\n",
            "['a3', 'a1', 'a1', 'a1', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a3', 'a0', 'a1', 'a0']\n",
            "Policy for 6 iteration\n",
            "['a1', 'a3', 'a2', 'a2', 'a2', 'a2', 'a2', 'a2', 'a2', 'a1', 'a3', 'a3', 'a2', 'a2', 'a3', 'a1']\n",
            "Policy for 7 iteration\n",
            "['a2', 'a2', 'a1', 'a1', 'a1', 'a2', 'a2', 'a1', 'a1', 'a0', 'a1', 'a1', 'a1', 'a2', 'a1', 'a3']\n",
            "Policy for 8 iteration\n",
            "['a1', 'a1', 'a3', 'a3', 'a3', 'a1', 'a3', 'a2', 'a3', 'a3', 'a3', 'a2', 'a1', 'a3', 'a3', 'a3']\n",
            "Policy for 9 iteration\n",
            "['a1', 'a1', 'a2', 'a2', 'a2', 'a2', 'a2', 'a2', 'a2', 'a0', 'a3', 'a1', 'a2', 'a2', 'a2', 'a3']\n",
            "Policy for 10 iteration\n",
            "['a3', 'a1', 'a1', 'a2', 'a1', 'a2', 'a1', 'a1', 'a2', 'a1', 'a2', 'a3', 'a2', 'a2', 'a2', 'a2']\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fig, bob = plt.subplots(figsize=(10, 10),dpi=80)\n",
        "bob.set(title = \"Accumulated reward for different algorithms vs episodes\",xlabel = \"episodes\", ylabel = \"Accumulated reward per step\")\n",
        "bob.plot(range(500),actor_critic_learning_rewards)\n",
        "bob.plot(range(500),q_learning_rewards)\n",
        "bob.plot(range(500),sarsa_rewards)\n",
        "bob.plot(range(500),sarsa_lambda_rewards)\n",
        "plt.legend(['actor-critic','Q-Learning','SARSA','SARSA-Lambda'])\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 685
        },
        "id": "WuUR9vLegbbe",
        "outputId": "811b547a-2abd-4284-c96c-6d5d6e4bb801"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def run_actor_critic_again(no_of_runs):\n",
        "  rewards_across_runs=[]\n",
        "  start_state=np.array([[0],[0],[0],[0]])\n",
        "  for i in range(no_of_runs):\n",
        "    value_matrix=create_Q_Matrix(4)\n",
        "    policy_matrix,rewards=actor_critic(value_matrix,0.95,0.2,0.05,4,500,500,0.05,start_state,get_connectivity_matrix())\n",
        "    policy=generate_actor_critic_policy(policy_matrix)\n",
        "    print(\"Policy for {} iteration\".format(i+1))\n",
        "    print_policy=printPolicy(policy)\n",
        "    print(print_policy)\n",
        "    rewards_across_runs.append(rewards)\n",
        "  rewards=average_rewards_across_runs(no_of_runs,rewards_across_runs)\n",
        "  plot_episode_wise_rewards(rewards)\n",
        "  return rewards\n",
        "\n",
        "actor_critic_learning_rewards2=run_actor_critic_again(10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "zOYFQf2uG43a",
        "outputId": "df6a2409-d903-40fd-cfcc-af17df8e3fa5"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a2', 'a3', 'a3', 'a2', 'a1', 'a1', 'a3', 'a3', 'a1', 'a1', 'a2', 'a2', 'a1', 'a0', 'a0', 'a0']\n",
            "Policy for 2 iteration\n",
            "['a2', 'a3', 'a3', 'a1', 'a0', 'a0', 'a3', 'a0', 'a1', 'a2', 'a2', 'a2', 'a1', 'a1', 'a1', 'a3']\n",
            "Policy for 3 iteration\n",
            "['a2', 'a0', 'a3', 'a0', 'a1', 'a3', 'a3', 'a0', 'a0', 'a1', 'a2', 'a2', 'a0', 'a0', 'a2', 'a0']\n",
            "Policy for 4 iteration\n",
            "['a3', 'a2', 'a2', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a2', 'a1', 'a2', 'a1', 'a0', 'a1', 'a1']\n",
            "Policy for 5 iteration\n",
            "['a3', 'a1', 'a2', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a2', 'a1', 'a0', 'a1', 'a1']\n",
            "Policy for 6 iteration\n",
            "['a2', 'a1', 'a3', 'a2', 'a0', 'a1', 'a3', 'a0', 'a1', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 7 iteration\n",
            "['a1', 'a2', 'a2', 'a1', 'a3', 'a1', 'a1', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 8 iteration\n",
            "['a3', 'a0', 'a2', 'a1', 'a3', 'a1', 'a2', 'a2', 'a1', 'a0', 'a1', 'a2', 'a1', 'a2', 'a1', 'a1']\n",
            "Policy for 9 iteration\n",
            "['a2', 'a3', 'a3', 'a2', 'a1', 'a2', 'a1', 'a0', 'a3', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 10 iteration\n",
            "['a2', 'a2', 'a3', 'a1', 'a1', 'a0', 'a1', 'a0', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "alpha_values=[0.01,0.05,0.1]\n",
        "beta_values=[0.001,0.005,0.01]\n",
        "varying_actor_critic_rewards=[]\n",
        "for a in alpha_values:\n",
        "  for b in beta_values:\n",
        "    varying_actor_critic_rewards.append(run_actor_critic_again(10))\n",
        "fig, bob = plt.subplots(figsize=(10, 10),dpi=80)\n",
        "bob.set(title = \"Accumulated reward vs episodes for alpha=0.2\",xlabel = \"episodes\", ylabel = \"Accumulated reward\")\n",
        "for i in range(len(varying_actor_critic_rewards)):\n",
        "  bob.plot(range(500),varying_actor_critic_rewards[i])\n",
        "plt.legend(['alpha=0.01 & beta=0.001','alpha=0.01 & beta=0.005','alpha=0.01 & beta=0.01','alpha=0.05 & beta=0.001','alpha=0.05 & beta=0.005','alpha=0.05 & beta=0.01','alpha=0.1 & beta=0.001','alpha=0.1 & beta=0.005','alpha=0.1 & beta=0.01'])\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "tWqTLNZhSVru",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "714bd825-bd06-47d2-fa65-dae427d773b5"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a2', 'a3', 'a3', 'a1', 'a2', 'a1', 'a3', 'a0', 'a1', 'a1', 'a2', 'a0', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 2 iteration\n",
            "['a2', 'a3', 'a3', 'a2', 'a2', 'a1', 'a2', 'a2', 'a1', 'a0', 'a1', 'a1', 'a1', 'a0', 'a0', 'a0']\n",
            "Policy for 3 iteration\n",
            "['a3', 'a1', 'a2', 'a0', 'a1', 'a1', 'a3', 'a3', 'a1', 'a1', 'a0', 'a2', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 4 iteration\n",
            "['a3', 'a2', 'a2', 'a1', 'a1', 'a1', 'a3', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1', 'a1', 'a0', 'a1']\n",
            "Policy for 5 iteration\n",
            "['a2', 'a2', 'a3', 'a2', 'a1', 'a3', 'a3', 'a3', 'a0', 'a1', 'a2', 'a3', 'a1', 'a0', 'a0', 'a0']\n",
            "Policy for 6 iteration\n",
            "['a2', 'a3', 'a3', 'a2', 'a1', 'a3', 'a1', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 7 iteration\n",
            "['a2', 'a0', 'a3', 'a2', 'a1', 'a0', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1']\n",
            "Policy for 8 iteration\n",
            "['a2', 'a1', 'a3', 'a2', 'a3', 'a3', 'a2', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 9 iteration\n",
            "['a2', 'a3', 'a2', 'a3', 'a1', 'a3', 'a3', 'a0', 'a1', 'a0', 'a1', 'a1', 'a1', 'a0', 'a1', 'a0']\n",
            "Policy for 10 iteration\n",
            "['a1', 'a1', 'a3', 'a1', 'a0', 'a1', 'a3', 'a3', 'a0', 'a3', 'a1', 'a2', 'a1', 'a1', 'a0', 'a1']\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a2', 'a3', 'a2', 'a3', 'a1', 'a0', 'a3', 'a2', 'a0', 'a2', 'a1', 'a2', 'a1', 'a0', 'a1', 'a3']\n",
            "Policy for 2 iteration\n",
            "['a1', 'a3', 'a3', 'a2', 'a1', 'a3', 'a3', 'a3', 'a3', 'a2', 'a2', 'a2', 'a1', 'a1', 'a1', 'a3']\n",
            "Policy for 3 iteration\n",
            "['a2', 'a2', 'a3', 'a3', 'a2', 'a3', 'a2', 'a2', 'a1', 'a1', 'a1', 'a0', 'a1', 'a0', 'a1', 'a1']\n",
            "Policy for 4 iteration\n",
            "['a1', 'a3', 'a2', 'a3', 'a3', 'a1', 'a1', 'a0', 'a1', 'a3', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1']\n",
            "Policy for 5 iteration\n",
            "['a2', 'a3', 'a2', 'a2', 'a3', 'a0', 'a0', 'a3', 'a1', 'a2', 'a1', 'a1', 'a1', 'a0', 'a1', 'a1']\n",
            "Policy for 6 iteration\n",
            "['a2', 'a3', 'a1', 'a2', 'a3', 'a0', 'a3', 'a3', 'a1', 'a2', 'a1', 'a0', 'a0', 'a0', 'a0', 'a1']\n",
            "Policy for 7 iteration\n",
            "['a2', 'a2', 'a3', 'a2', 'a1', 'a3', 'a0', 'a0', 'a1', 'a2', 'a3', 'a0', 'a1', 'a3', 'a1', 'a1']\n",
            "Policy for 8 iteration\n",
            "['a2', 'a0', 'a2', 'a2', 'a3', 'a3', 'a1', 'a1', 'a1', 'a2', 'a1', 'a2', 'a1', 'a1', 'a1', 'a0']\n",
            "Policy for 9 iteration\n",
            "['a1', 'a2', 'a3', 'a1', 'a1', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a3', 'a1', 'a1']\n",
            "Policy for 10 iteration\n",
            "['a2', 'a0', 'a3', 'a3', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1']\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a2', 'a1', 'a3', 'a2', 'a1', 'a3', 'a3', 'a0', 'a2', 'a0', 'a3', 'a3', 'a0', 'a0', 'a0', 'a1']\n",
            "Policy for 2 iteration\n",
            "['a2', 'a0', 'a3', 'a0', 'a1', 'a1', 'a1', 'a1', 'a2', 'a0', 'a0', 'a1', 'a1', 'a0', 'a1', 'a0']\n",
            "Policy for 3 iteration\n",
            "['a2', 'a1', 'a3', 'a1', 'a3', 'a0', 'a1', 'a1', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 4 iteration\n",
            "['a2', 'a2', 'a3', 'a3', 'a1', 'a3', 'a3', 'a3', 'a2', 'a1', 'a3', 'a3', 'a1', 'a0', 'a0', 'a1']\n",
            "Policy for 5 iteration\n",
            "['a2', 'a3', 'a3', 'a1', 'a3', 'a1', 'a1', 'a1', 'a1', 'a2', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1']\n",
            "Policy for 6 iteration\n",
            "['a2', 'a1', 'a3', 'a3', 'a0', 'a3', 'a3', 'a0', 'a1', 'a1', 'a3', 'a3', 'a0', 'a0', 'a3', 'a3']\n",
            "Policy for 7 iteration\n",
            "['a3', 'a3', 'a2', 'a2', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a0', 'a1', 'a1']\n",
            "Policy for 8 iteration\n",
            "['a2', 'a0', 'a3', 'a2', 'a3', 'a1', 'a1', 'a1', 'a1', 'a1', 'a1', 'a0', 'a1', 'a0', 'a1', 'a1']\n",
            "Policy for 9 iteration\n",
            "['a2', 'a3', 'a2', 'a3', 'a3', 'a3', 'a1', 'a0', 'a1', 'a2', 'a1', 'a1', 'a1', 'a2', 'a1', 'a1']\n",
            "Policy for 10 iteration\n",
            "['a3', 'a1', 'a3', 'a3', 'a1', 'a3', 'a3', 'a3', 'a1', 'a2', 'a2', 'a1', 'a1', 'a1', 'a1', 'a0']\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Policy for 1 iteration\n",
            "['a3', 'a2', 'a2', 'a3', 'a0', 'a3', 'a3', 'a1', 'a1', 'a0', 'a1', 'a2', 'a1', 'a1', 'a1', 'a1']\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-80-06ab5de771da>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0malpha_values\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m   \u001b[0;32mfor\u001b[0m \u001b[0mb\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbeta_values\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mvarying_actor_critic_rewards\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_actor_critic_again\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbob\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplots\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdpi\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m80\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mbob\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtitle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Accumulated reward vs episodes for alpha=0.2\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mxlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"episodes\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mylabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Accumulated reward\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-79-734e7f4d749c>\u001b[0m in \u001b[0;36mrun_actor_critic_again\u001b[0;34m(no_of_runs)\u001b[0m\n\u001b[1;32m      4\u001b[0m   \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mno_of_runs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mvalue_matrix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcreate_Q_Matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mpolicy_matrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrewards\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mactor_critic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue_matrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.95\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.05\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m500\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m500\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0.05\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mstart_state\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mget_connectivity_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m     \u001b[0mpolicy\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgenerate_actor_critic_policy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpolicy_matrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Policy for {} iteration\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-75-3869f4ac14f8>\u001b[0m in \u001b[0;36mactor_critic\u001b[0;34m(value_matrix, gamma, alpha, beta, action_space_size, episodes_limit, steps_limit, p, start_state, connectivity_matrix)\u001b[0m\n\u001b[1;32m     21\u001b[0m       \u001b[0maction_to_take\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mactor_critic_action\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maction_space_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpolicy_matrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m       \u001b[0mpotential_next_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcompute_next_state\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconnectivity_matrix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvector_actions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maction_to_take\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcreate_some_noise\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m       \u001b[0mnext_state_index\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstate_to_Index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpotential_next_state\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     24\u001b[0m       \u001b[0mreward\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcalculate_two_state_reward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mpotential_next_state\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mvector_actions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0maction_to_take\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m       \u001b[0mdelta\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreward\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mgamma\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mvMatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnext_state_index\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mvMatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<ipython-input-6-8091e6b2ade6>\u001b[0m in \u001b[0;36mstate_to_Index\u001b[0;34m(input_state)\u001b[0m\n\u001b[1;32m      3\u001b[0m   \u001b[0mindex\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m   \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdim\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0mindex\u001b[0m\u001b[0;34m+=\u001b[0m\u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput_state\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m   \u001b[0;32mreturn\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "AnCgHfDwOyxR"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "name": "RL Project 3 Q2 Gene Regulatory Network.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}