diff --git a/Aimbot-PPO-Python/Pytorch/MultiNN-PPO.py b/Aimbot-PPO-Python/Pytorch/MultiNN-PPO.py index 67d0533..af97665 100644 --- a/Aimbot-PPO-Python/Pytorch/MultiNN-PPO.py +++ b/Aimbot-PPO-Python/Pytorch/MultiNN-PPO.py @@ -26,8 +26,10 @@ from typing import List bestReward = -1 +SCrecieved = 0 + DEFAULT_SEED = 9331 -ENV_PATH = "../Build/3.0/Goto/Aimbot-ParallelEnv" +ENV_PATH = "../Build/2.9/Goto-NonNormalization/Aimbot-ParallelEnv" SIDE_CHANNEL_UUID = uuid.UUID("8bbfb62a-99b4-457c-879d-b78b69066b5e") WAND_ENTITY = "koha9" WORKER_ID = 1 @@ -35,7 +37,7 @@ BASE_PORT = 1000 # tensorboard names game_name = "Aimbot_Target_Hybrid_PMNN_V3" -game_type = "PList_Go_LeakyReLU" +game_type = "Mix_Verification" # max round steps per agent is 2500/Decision_period, 25 seconds # !!!check every parameters before run!!! @@ -44,7 +46,7 @@ TOTAL_STEPS = 3150000 BATCH_SIZE = 512 MAX_TRAINNING_DATASETS = 6000 DECISION_PERIOD = 1 -LEARNING_RATE = 1e-3 +LEARNING_RATE = 6.5e-4 GAMMA = 0.99 GAE_LAMBDA = 0.95 EPOCHS = 3 @@ -54,17 +56,17 @@ POLICY_COEF = [1.0, 1.0, 1.0, 1.0] ENTROPY_COEF = [0.05, 0.05, 0.05, 0.05] CRITIC_COEF = [0.5, 0.5, 0.5, 0.5] TARGET_LEARNING_RATE = 1e-6 -FREEZE_VIEW_NETWORK = False +FREEZE_VIEW_NETWORK = True BROADCASTREWARD = False ANNEAL_LEARNING_RATE = True CLIP_VLOSS = True NORM_ADV = False -TRAIN = True -SAVE_MODEL = True +TRAIN = False +SAVE_MODEL = False WANDB_TACK = True LOAD_DIR = None -#LOAD_DIR = "../PPO-Model/PList_Go_LeakyReLU_9331_1677696843_middle.pt" +LOAD_DIR = "../PPO-Model/PList_Go_LeakyReLU_9331_1677965178_bestGoto/PList_Go_LeakyReLU_9331_1677965178_10.709002.pt" # public data class Targets(Enum): @@ -314,12 +316,15 @@ class AimbotSideChannel(SideChannel): def __init__(self, channel_id: uuid.UUID) -> None: super().__init__(channel_id) def on_message_received(self, msg: IncomingMessage) -> None: + global SCrecieved # make sure this variable is global """ Note: We must implement this method of the SideChannel interface to receive messages from Unity + Message will be sent like this: + "Warning|Message1|Message2|Message3" or + "Error|Message1|Message2|Message3" """ thisMessage = msg.read_string() - # print(thisMessage) thisResult = thisMessage.split("|") if(thisResult[0] == "result"): TotalRounds[thisResult[1]]+=1 @@ -329,6 +334,22 @@ class AimbotSideChannel(SideChannel): #print(WinRounds) elif(thisResult[0] == "Error"): print(thisMessage) + + # # while Message type is Warning + # if(thisResult[0] == "Warning"): + # # while Message1 is result means one game is over + # if (thisResult[1] == "Result"): + # TotalRounds[thisResult[2]]+=1 + # # while Message3 is Win means this agent win this game + # if(thisResult[3] == "Win"): + # WinRounds[thisResult[2]]+=1 + # # while Message1 is GameState means this game is just start + # # and tell python which game mode is + # elif (thisResult[1] == "GameState"): + # SCrecieved = 1 + # # while Message type is Error + # elif(thisResult[0] == "Error"): + # print(thisMessage) # 发送函数 def send_string(self, data: str) -> None: # send a string toC# diff --git a/Aimbot-PPO-Python/Pytorch/test2.ipynb b/Aimbot-PPO-Python/Pytorch/test2.ipynb new file mode 100644 index 0000000..dc895ad --- /dev/null +++ b/Aimbot-PPO-Python/Pytorch/test2.ipynb @@ -0,0 +1,134 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MyNet(\n", + " (fc1): Linear(in_features=10, out_features=20, bias=True)\n", + " (fc2): Linear(in_features=20, out_features=10, bias=True)\n", + ")\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAANMAAAD5CAYAAAC9MACJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYnUlEQVR4nO3deZhcZZXH8e+PzoJpCNkkQAjLAALRQZyJcQVBFiEiMIqaOCo4YARlBscVRdFHHmaCDDI+AyObGTZZFA1mNATiLopIQPY1YpCEkBASQhKWpLvP/FG3M0Wnqvt03zedt6rOh6eeruX0W7ebnL633vvec2RmhBDK22pLb0AIzSKSKYREIplCSCSSKYREIplCSCSSKYREhmzpDahl5Jgh9uoJw12xTz0zxj3uuHHPu2OffWakO9Z7cqGrvcs95pDn/X/nhqx60R3bMepV7ti2l33b+9LLz7F+wzq5B67hXQe327MrO12xd9778s1mdkRvMZKOAL4NtAGXmdnMHq+fDHwK6ATWAjPM7MGBbHu3LJPp1ROGM3P2Pq7Yr1/6Yfe4Hzt+njv2qot6/X/1Cl1tvrh1U/z/6MfO29odO+aH97hjnztyP3fsyMdfcMXdfu9F7jHrWbGyk9tv3tkVO3THP4/r7XVJbcCFwGHAYuAOSXN6JMs1ZnZREX808C3A/z+9hlKHeZKOkPSIpIWSTq/x+nBJ1xev3y5ptzLvF5qZ0WldrpvDFGChmT1uZuuB64BjXvFuZtWHKe34DzDqGnAyVWX/kcAkYLqkST3CTgRWmdmewPnAOQN9v9DcDOjCXDeHCcCTVY8XF8+9gqRPSfoz8E3gX8r+DGX2TH1mf/H4iuL+DcAhkkodW4fm1eX8DxgnaUHVbcZA3s/MLjSzPYAvAl8pu/1lPjPVyv431Ysxsw5Jq4GxwIoS7xuakGFs8B3CAawws8m9vL4EmFj1eOfiuXquA77jffN6spkalzSj+y/N8ys7tvTmhEFmQCfmujncAewlaXdJw4BpwJzqAEl7VT18N/BY2Z+hzJ7Jk/3dMYslDQG2A56tNZiZXQJcArDH37bHUvYW5Pw81KfiKOhU4GYqU+OzzOwBSd8AFpjZHOBUSYcCG4BVwPFl37dMMm3MfipJMw34UI+YOVQ28jbgOOAXFtd8hBoM6Ez4T8PM5gJzezx3ZtX905K9WWHAyeTM/u8CV0laCKykknAh1OQ/pZ2nUidtHdn/EvD+Mu8RWoP5Pw9lK8sVEKs6RvCDZ3qbrPl/E+fW/AhW04U7Hu6O3XveUnfsknfv6IrrfMm5VALY5qn17thHz/avathlnn9y58UdfKswuh4qf7bDDDY0di7lmUyhFYlOGvsUZCRTyIIBXbFnCiGN2DOFkEDlpG0kUwilGbDBslmQMyCRTCELhujMZ3XbgEQyhWx0WRzmhVBafGYKIRnRGZ+ZQiivcqVtJFNyHY908dw717liXz7ob9zj7n2pf+nRy7v4qx5t5Suqw47z/b/uRe9xh3L2kde7Y7+2k3/g9WuGueI23OUesi4zsd78y61ylGUyhdbUFZ+ZQiivMgERh3khJBATECEkERMQISTUGSdtQyjPEBussf85lqnoOlHSLyU9KOkBSZsUqJB0kKTVku4ubmfWGiuE7gkIzy1XZf4UdACfNbO7JG0L3Clpfo1OAr81s6NKvE9oAYZa9zDPzJYCS4v7ayQ9RKWCa6m2HKF1NfoERJKtL7pbvAG4vcbLb5F0j6SbJL02xfuF5mMGnbaV65ar0p/4JG0D/BD4dI82HQB3Abua2VpJU4Ebgb2ooSi+PgNg6Ku3Y+llvmVC7df6f4QR965xx95wyxV9BxXe/fnPuOJGLVjmHvPpt4x3x551+XR3bNcof6GFfa5d7Yp7bnn5ineVCYjGXk5Utj/TUCqJ9D0z+1HP183seTNbW9yfCwyVVLNRlZldYmaTzWxy28gRZTYrNKhGn4AoM5snKhVbHzKzb9WJ2aG7hYykKcX7+VebhpZhiC7z3Twcjfg+U8xE3yvp55J2LfszlDnMexvwEeA+SXcXz30Z2AWgaHF4HHCKpA7gRWBa1BoP9aTa6zjbcP4JmGxmL0g6hUrDsw+Wed8ys3m3Qu/LfM3sAuCCgb5HaB2VunnJDuE2NuIDkNTdiG9jMpnZL6vi/wD4myPX0dinnEMTSVrR1dOIr9qJwE1l3zSSKWShUurLPZs3TtKCqseXFP29+k3Sh4HJwDsG8v3VIplCFszUn8O8JG04i2ZnZwDvMLOXvW9eTyRTyEbCE7J9NuKT9AbgYuAIM1ue4k0jmUIWKtczpfnM5GzEdy6wDfCD4uzNX83s6DLvG8kUMpH2SltHI75Dk71ZIctk0po2tvrZaFfs2umr3OPO/Pd57tjTlx7iju3Y2vcXtWtb/8qOfb7qXy/8hT/d6o6dNMy/pOrwxZ93xW1YUn4ZUGVqvEVXjYeQUjOszYtkCtlo9EswIplCFiqXYMRhXghJxGemEBKorBqPw7wQSovOgSEkE3umEJKJwv0hJBCzeZvJa3ZYxi1fPNcV+8ZbNql9Wddv1u7jjl2wbGLfQYWX3tOzjkxt7f+41j3mlHG+MQF+uvr17tiZM/wFokaP2+CKa3spzcXTcZgXQgLdNSAaWYpSX4uANUAn0NHzOpOioMq3ganAC8AJZpag11xoJgZ0xJ4JgIPNbEWd146kUitvLyqXDn+H3i8hDi0qDvP6dgxwZVGV6A+SRknasSivHEJFP8p45SrFnwIDbpF0Z1GVtadaxS0mJHjf0ES6Lw703HKVYs/0djNbIml7YL6kh83sN/0dpLo88s4TGnspfhiYlt8zmdmS4utyYDaVmmXVXMUtqssjjx3b2MfOof+6Lw5MVdF1Syhba7y96M2EpHbgcOD+HmFzgI+q4s3A6vi8FHoyREfXVq5brsoe5o0HZhcFKYYA15jZPEknw8YSyXOpTIsvpDI1/rGS7xmaVM6fhzxKJVNRfnaT0+9FEnXfN+BTZd4ntABr/M9MWa6AeOi57Xnj//qWCQ171j9Z8ZNzDnLHrjzA33No2OiXXHEvbhjqHvMHv/efiht7p//Q5+vX/Y879tzTPuILTJADUVAlhIQimUJIwBCdGU8ueEQyhWy09ARECKlYE0xANPZ+NTQVM7luHo42nAdKuktSh6TjUmx/JFPIRLqetlVtOI8EJgHTJU3qEfZX4ATgmlQ/QRzmhWx49zoOnjaci4rX/OdA+hDJFLJgBp1dW6wNZxKRTCEb/ZjNS9aGM6VIppAFo1+HeUnacKaWZTINf9Z4zZW+JTpPHrqNe9xRj/qrA838xvfcsSdffbIrbsz31rnHXPF1f4vV7555Ud9Bhc9N/4Q79uTLb3DFfeW9/h5Z9SW9vKLPNpybQ8zmhWyY+W59j2MdQHcbzoeA73e34ZR0NICkN0paDLwfuFjSA2W3P8s9U2hNCWfzPG0476By+JdMJFPIQmU2r7EPlCKZQjY8h3A5i2QK2Uh5mLclRDKFLBj+dXe5GvBBqqS9Jd1ddXte0qd7xBwkaXVVzJl1hguhcq7JccvVgPdMZvYIsD9sXFi4hEqpr55+a2ZHDfR9QoswsHTLibaIVId5hwB/NrMnEo0XWlDLHub1MA24ts5rb5F0j6SbJPmbA4WWk+qk7ZaSoqXMMOBo4Es1Xr4L2NXM1kqaCtxIpRtGrXE2lkfeeshI2la94Hr/zq3b3dv6oatucsee875p7tjzbpjlijv/V/4VLT9+64Xu2LOXTHXH6vaeNULre7pjO1fcBitfzrqfa/OylGLPdCRwl5kt6/mCmT1vZmuL+3OBoZLG1RqkujzysCEjEmxWaCgGmHy3TKVIpunUOcSTtEPR7AxJU4r3ezbBe4Ym1NKHeUV98cOAT1Q9V10a+TjgFEkdwIvAtKLCawg9qLVn88xsHTC2x3PVpZEvAC4o8x6hhTT4n9lYARHyYI0/ARHJFPIRe6YQUok9UwhpJCu6tWVEMoU8dJ9namCRTCEbjX7SJMtkGrb7eiZe6avMtPTK7d3j/vq5fdyxnSP8jclOu/EEV9y2r/WfI//AxZ91x+54m6+SE8DQSb5lWgC3HLurK+75J+5zj9mrSKYQEonDvBDSUOyZQkjABK28nCiEpGLPFEIiDZ5MjV31LzSXhBVVHJ0Dh0u6vnj9dkm7ld38SKaQh4QXBzo7B54IrDKzPYHzgXPK/giRTCEbMt/NYWPnQDNbD3R3Dqx2DHBFcf8G4JDuC1kHKpIp5CPdYV6tzoET6sUUXTNW0+PavP6KCYiQjX6cZ4rOgV7r/zKMJz+2iyu282x/o62nTvJ3EDl19g/csWc94quxOeJXo9xj/vA757tjf/TRmgWfapowdKU79qsP9jwyqm3DvyY6PzS4nQO7YxZLGgJsR8n6JHGYF/LgPcTz7b02dg4sStFNA+b0iJkDHF/cPw74Rdn6JK5kkjRL0nJJ91c9N0bSfEmPFV9H1/ne44uYxyQdXysmBCBZMnk6BwLfBcZKWgh8Bthk+ry/vId5l1MpjHJl1XOnAz83s5nFPP7pwBerv0nSGOBrwGQqv4Y7Jc0xsxRNUEOTUcKLAx2dA1+i0oIzGdeeycx+A/Q82K6eWrwCOLbGt74LmG9mK4sEmg8cMbBNDU2vwdtglJmAGG9mS4v7TwPja8R4pihD6M85pGwlmc0zM5PK/SpeUWt86MgUmxUaTYNfz1RmNm+ZpB0Biq/La8R4piiBHrXG26LWeEtq8MO8MslUPbV4PPDjGjE3A4dLGl3M9h1ePBfCJhIuJ9oivFPj1wK3AXtLWizpRGAmcJikx4BDi8dImizpMgAzWwmcRWXe/w7gG8VzIbySVWbzPLdcuT4zmdn0Oi8dUiN2AXBS1eNZgK+BUWhtGe91PLJcTtQxYggr31DzHPAmdj6jH6esnqr1sa62PYb6V5asWO6bMPn4v/3aPea4Nn8Tt1+s9FddevrsPdyx459a54r7y5JUy4nSDLOlZJlMoTXl/HnII9bmhZBI7JlCPhp8zxTJFPJgec/UeUQyhXzEnimE8kTjT0BEMoV8RDKFkEDmS4U8IplCPmICIoQ0Ys+0GXQOh+d39Z1P3mmGf93so3P3dcdOu8AfO3a171/B3x24yD3m7jfOcMfuec16d+zff/tOd+yZ43/ninvnkSvcY/YqkimEBDK/VskjkilkIw7zQkglkimENGI5UQgpxGemENJQcWtkfc4/1ymNfK6khyXdK2m2pFF1vneRpPsk3d2ja0EIm2qB6kSXs2kV1vnA68xsP+BR4Eu9fP/BZrZ/H10LQhiU6kT9qJE/T9Jzkn7iHbvPZKpVGtnMbimKowP8gUo9vBDKGZw9U3eN/L2An1O/YP+5wEf6M3CKy9b/CbipzmsG3CLpzqJiawi1DV6pL0+NfMzs58Ca/gxcagJC0hlAB/C9OiFvN7MlkrYH5kt6uNjT1RprY3nk4a8axbj7O2qFbeJPu+7m3t6LT7rUHXv+se9zxz5yynauuLO+dIJ7zEm/XeSOvfqO2e7Yt93u/5v28Ltf7Yp7fMX33WP2anA+D3lq5A/IgJNJ0gnAUcAh9ZpEmdmS4utySbOpNO6tmUxFG8VLALYZvXPGHzPD5pKqDaeknwE71Pi+M6ofpKiRX21AySTpCOALwDvM7IU6Me3AVma2prh/OPCNAW9paH7+f9a9tuE0s0PrvSZpmaQdzWxpLzXyB8QzNV6rNPIFwLZUDt3ulnRREbuTpO4GU+OBWyXdA/wR+KmZzUu14aH5DFKtcU+N/AHpc89UpzTyd+vEPgVMLe4/Dry+1NaF1mEM1sWBM4HvFzuFJ4APQKVGPnCymZ1UPP4tsA+wjaTFwIlm1mvTiVgBEbIwWAVVzOxZfDXyD+jv2JFMIR8NPu0UyRSyodqTwg0jkinkIfN1dx6RTCEbcaVtCInExYGbQefYLladsNYVu+2to9zjfvmPJ/UdVNh+8YPu2N+95zJX3NvaT3OP+cJ4f1OyYz/5aXfsgxdf0ndQ4TWnneKKe/m/hrvH7FXsmUJIICq6hpBQJFMI5UUXjBASUldjZ1MkU8hDnGcKIZ2YGg8hldgzhZBGTECEkIIBsdA1PXuxjY57RrliNcI/btdQf83Qp6dPcseeuJ8vru30Ye4xd7rxCXfsullD3bEHntKPvk8PPO2Ke2bFBveYvYnPTCEk0AznmQZaHvnrkpYU9R/uljS1zvceIekRSQsl1Sv2F0LlEM97y9RAyyMDnF+UPd7fzOb2fFFSG3AhcCQwCZguyX/sFFrOIBVU2WwGVB7ZaQqw0MweN7P1wHVUqmmGUFsLFO6v59SiC8asOsXPJwBPVj1eXDwXQk1Nv2eq4zvAHsD+wFLgvLIbImmGpAWSFnSuW1d2uNBoDOg03y1TA0omM1tmZp1m1gVcSuWQrqclwMSqxzsXz9Ub8xIzm2xmk9va2weyWaHBteSeqSgr2+0fgPtrhN0B7CVpd0nDgGlUqmmGUFuDz+b1eZ6pKI98EJVi6YuBrwEHSdqfys55EfCJInYn4DIzm2pmHZJOBW4G2oBZZvbA5vghQnPIea/jsdnKIxeP5wKbTJuHsInMZ+o8slwBMaR9A2Pe7FvK0n7WSPe4V193oTv2rdd/1h27zTv2dsXtefUq95gbJo5zx3ZetLU79uRv3uCOnTriyb6DgEOmDuTMySsJ0CBMLkgaA1wP7EblqOoDZraqR8z+VCbZRgKdwNlmdn1fY6foHBhCEjJz3UrytOF8Afiomb2WyoKF/6zXBL1aJFPIg/eEbfmd1zH00YbTzB41s8eK+09R6eHUZxvFLA/zQisatJm6frXhlDQFGAb8ua+BI5lCNnJrw1mcAroKOL44p9qrSKaQD/+eabO34ZQ0EvgpcIaZ/cGzUfGZKeTBKrN5nltJfbbhLBYZzAauNDP39GckU8jH4ExAzAQOk/QYcGjxGEmTJXUXjf8AcCBwQtU1e/v3NXAc5oVsDEazM08bTjO7Gri6v2NHMoV8ZLzuziOSKeTBGKxu65tNlsm0+9bPcvW+V7pi33nSae5xj9/ncHfshIP9/2fN+Vvsuv9h95hv+JM7lHlP7OuOnfXJY92xXzux0xW3ZM1/u8esRyRZ3bBFZZlMoUV1NfauKZIp5CEO80JIJw7zQkglkimEFPK+JN0jkinkobs6UQPz1ICYBRwFLDez1xXPXQ90X146CnjOzPav8b2LgDVUrlbs6G1xYgit8JnpcuACYOOJHzP7YPd9SecBq3v5/oPNbMVANzC0kGZPJjP7jaTdar0mSVQWBb4z8XaFVmNAgzeILrtq/ABgWfclvjUYcIukOyX5GwOFFuSsmZfx3qvsBMR04NpeXn+7mS2RtD0wX9LDRSOATRTJNgOgbfRoDv3h51wb8KqV/r8HLx7ob8LxzOv9v5rRB/gqKX3/gtvcY05/Xa3GI7VNufmv7tg//vMu7tjT9vq9K+68EWvcY/Yq40TxGPCeSdIQ4L1UyibVZGZLiq/LqVxsVauMcndslEduZQZ0dvlumSpzmHco8LCZLa71oqR2Sdt23wcOp3YZ5RCoHOZ1+W6Z8nQOvBa4Ddhb0mJJJxYvTaPHIZ6knSR1V3AdD9wq6R7gj8BPzWxeuk0PTafZPzPVKY+MmZ1Q47mN5ZHN7HHg9SW3L7SKJpjNixUQIR8Z73U8IplCPiKZQkjADDp9V/bmKpIp5CP2TCEkEskUQgoWs3mbQ/s2L/HGNz3qiv3Q9q4y0AAc8An/4vWDzvMtZwKwy7d3xX381KP8Y+7SZweTje5fucEd+6V9/af6rjzqYFfc6icSnIs3cNTGz1qWyRRaVMZLhTyi1njIg1ml1JfnVoKkMZLmS3qs+Dq6Rsyuku4qaow/IOlkz9iRTCEfg7OcyNOGcynwluLq8TcBp0vaqa+BI5lCNqyry3UrydOGc72ZvVw8HI4zTyKZQiYG7eJAVxtOSRMl3Qs8CZxTrDvtVUxAhDz0b6HrZm/DaWZPAvsVh3c3SrrBzJb1tlGRTCELBph/OdFmb8NZNdZTku6nUqKh1y6CcZgX8mCDdnGgpw3nzpJeVdwfDbwdeKSvgSOZQjasy1y3kjxtOPcFbi8ubP018B9mdl9fA8dhXsjHIKyAcLbhnA/s19+xZRkuLpT0DPBEj6fHAc1YzLIZfq5dzcy//qkGSfOo/C48VpiZv3zTIMkymWqRtKAZyys368/ViuIzUwiJRDKFkEgjJdMlfYc0pGb9uVpOw3xmCiF3jbRnCiFrDZFMko6Q9IikhZJqLZlvSJIWSbqvuG5mQd/fEXKW/WGepDbgUeAwYDFwBzDdzB7cohuWQNFZcXI0g2sOjbBnmgIsNLPHzWw9cB2Va1JCyEojJNMEKteUdFtcPNcMohlcE4m1eVuWuxlcyF8j7JmWABOrHu9cPNfw+tMMLuSvEZLpDmAvSbtLGkalL9ScLbxNpUUzuOaT/WGemXVIOhW4GWgDZpnZA1t4s1IYD8yuNKxnCHBNNINrbNlPjYfQKBrhMC+EhhDJFEIikUwhJBLJFEIikUwhJBLJFEIikUwhJBLJFEIi/weq7RffiwqZhgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import torch\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# 创建一个神经网络\n", + "class MyNet(torch.nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.fc1 = torch.nn.Linear(10, 20)\n", + " self.fc2 = torch.nn.Linear(20, 10)\n", + "\n", + " def forward(self, x):\n", + " x = torch.relu(self.fc1(x))\n", + " x = self.fc2(x)\n", + " return x\n", + "\n", + "net = MyNet()\n", + "\n", + "# 打印神经网络结构\n", + "print(net)\n", + "\n", + "# 获取第一层权重张量\n", + "weights = net.state_dict()['fc1.weight']\n", + "\n", + "# 将权重张量转换为numpy数组，并可视化\n", + "plt.imshow(weights.numpy())\n", + "plt.colorbar()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python version: 3.11.3 | packaged by Anaconda, Inc. | (main, Apr 19 2023, 23:46:34) [MSC v.1916 64 bit (AMD64)]\n" + ] + } + ], + "source": [ + "# print python version\n", + "import sys\n", + "print('python version: ', sys.version)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import argparse\n", + "import wandb\n", + "import time\n", + "import numpy as np\n", + "import random\n", + "import uuid\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "from AimbotEnv import Aimbot\n", + "from tqdm import tqdm\n", + "from torch.distributions.normal import Normal\n", + "from torch.distributions.categorical import Categorical\n", + "from distutils.util import strtobool\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "from mlagents_envs.environment import UnityEnvironment\n", + "from mlagents_envs.side_channel.side_channel import (\n", + " SideChannel,\n", + " IncomingMessage,\n", + " OutgoingMessage,\n", + ")\n", + "from typing import List\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.11.3" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Aimbot-PPO-Python/Pytorch/testarea.ipynb b/Aimbot-PPO-Python/Pytorch/testarea.ipynb index 33ce0c5..5b95a12 100644 --- a/Aimbot-PPO-Python/Pytorch/testarea.ipynb +++ b/Aimbot-PPO-Python/Pytorch/testarea.ipynb @@ -958,44 +958,295 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([-1.0139])\n" - ] - } - ], + "outputs": [], "source": [ - "logits = logits - logits.logsumexp(dim=-1, keepdim=True)\n", - "min_real = torch.finfo(logits.dtype).min\n", - "logits = torch.clamp(logits, min=min_real)\n", - "p_log_p = logits*logits\n", - "print(-p_log_p.sum(-1))" + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "\n", + "from AimbotEnv import Aimbot\n", + "from enum import Enum\n", + "from torch.distributions.normal import Normal\n", + "from torch.distributions.categorical import Categorical\n", + "\n", + "DEFAULT_SEED = 9331\n", + "ENV_PATH = \"../Build/3.0/Mix/Aimbot-ParallelEnv\"\n", + "WAND_ENTITY = \"koha9\"\n", + "WORKER_ID = 1\n", + "BASE_PORT = 1000\n", + "\n", + "# tensorboard names\n", + "game_name = \"Aimbot_Target_Hybrid_PMNN_V3\"\n", + "game_type = \"PList_Mix_LeakyReLU_512Batch\"\n", + "\n", + "# max round steps per agent is 2500/Decision_period, 25 seconds\n", + "# !!!check every parameters before run!!!\n", + "\n", + "TOTAL_STEPS = 3150000\n", + "BATCH_SIZE = 512\n", + "MAX_TRAINNING_DATASETS = 6000\n", + "DECISION_PERIOD = 1\n", + "LEARNING_RATE = 6.5e-4\n", + "GAMMA = 0.99\n", + "GAE_LAMBDA = 0.95\n", + "EPOCHS = 3\n", + "CLIP_COEF = 0.11\n", + "LOSS_COEF = [1.0, 1.0, 1.0, 1.0] # free go attack defence\n", + "POLICY_COEF = [1.0, 1.0, 1.0, 1.0]\n", + "ENTROPY_COEF = [0.05, 0.05, 0.05, 0.05]\n", + "CRITIC_COEF = [0.5, 0.5, 0.5, 0.5]\n", + "TARGET_LEARNING_RATE = 1e-6\n", + "FREEZE_VIEW_NETWORK = False\n", + "\n", + "BROADCASTREWARD = False\n", + "ANNEAL_LEARNING_RATE = True\n", + "CLIP_VLOSS = True\n", + "NORM_ADV = False\n", + "TRAIN = True\n", + "SAVE_MODEL = True\n", + "WANDB_TACK = True\n", + "LOAD_DIR = None\n", + "LOAD_DIR = \"../PPO-Model/PList_Goto_LeakyReLU_256Batch_9331_1678785562/PList_Goto_LeakyReLU_256Batch_9331_1678785562_8.370919.pt\"\n", + "\n", + "# public data\n", + "class Targets(Enum):\n", + " Free = 0\n", + " Go = 1\n", + " Attack = 2\n", + " Defence = 3\n", + " Num = 4\n", + "TARGET_STATE_SIZE = 6\n", + "INAREA_STATE_SIZE = 1\n", + "TIME_STATE_SIZE = 1\n", + "GUN_STATE_SIZE = 1\n", + "MY_STATE_SIZE = 4\n", + "TOTAL_T_SIZE = TARGET_STATE_SIZE+INAREA_STATE_SIZE+TIME_STATE_SIZE+GUN_STATE_SIZE+MY_STATE_SIZE\n", + "BASE_WINREWARD = 999\n", + "BASE_LOSEREWARD = -999\n", + "TARGETNUM= 4\n", + "ENV_TIMELIMIT = 30\n", + "RESULT_BROADCAST_RATIO = 1/ENV_TIMELIMIT\n", + "\n", + "def layer_init(layer, std=np.sqrt(2), bias_const=0.0):\n", + " torch.nn.init.orthogonal_(layer.weight, std)\n", + " torch.nn.init.constant_(layer.bias, bias_const)\n", + " return layer\n", + "\n", + "\n", + "class PPOAgent(nn.Module):\n", + " def __init__(self, env: Aimbot,targetNum:int):\n", + " super(PPOAgent, self).__init__()\n", + " self.targetNum = targetNum\n", + " self.stateSize = env.unity_observation_shape[0]\n", + " self.agentNum = env.unity_agent_num\n", + " self.targetSize = TARGET_STATE_SIZE\n", + " self.timeSize = TIME_STATE_SIZE\n", + " self.gunSize = GUN_STATE_SIZE\n", + " self.myStateSize = MY_STATE_SIZE\n", + " self.raySize = env.unity_observation_shape[0] - TOTAL_T_SIZE\n", + " self.nonRaySize = TOTAL_T_SIZE\n", + " self.head_input_size = env.unity_observation_shape[0] - self.targetSize-self.timeSize-self.gunSize# except target state input\n", + "\n", + " self.discrete_size = env.unity_discrete_size\n", + " self.discrete_shape = list(env.unity_discrete_branches)\n", + " self.continuous_size = env.unity_continuous_size\n", + "\n", + " self.viewNetwork = nn.Sequential(\n", + " layer_init(nn.Linear(self.raySize, 200)),\n", + " nn.LeakyReLU()\n", + " )\n", + " self.targetNetworks = nn.ModuleList([nn.Sequential(\n", + " layer_init(nn.Linear(self.nonRaySize, 100)),\n", + " nn.LeakyReLU()\n", + " )for i in range(targetNum)])\n", + " self.middleNetworks = nn.ModuleList([nn.Sequential(\n", + " layer_init(nn.Linear(300,200)),\n", + " nn.LeakyReLU()\n", + " )for i in range(targetNum)])\n", + " self.actor_dis = nn.ModuleList([layer_init(nn.Linear(200, self.discrete_size), std=0.5) for i in range(targetNum)])\n", + " self.actor_mean = nn.ModuleList([layer_init(nn.Linear(200, self.continuous_size), std=0.5) for i in range(targetNum)])\n", + " # self.actor_logstd = nn.ModuleList([layer_init(nn.Linear(200, self.continuous_size), std=1) for i in range(targetNum)])\n", + " # self.actor_logstd = nn.Parameter(torch.zeros(1, self.continuous_size))\n", + " self.actor_logstd = nn.ParameterList([nn.Parameter(torch.zeros(1,self.continuous_size))for i in range(targetNum)]) # nn.Parameter(torch.zeros(1, self.continuous_size))\n", + " self.critic = nn.ModuleList([layer_init(nn.Linear(200, 1), std=1)for i in range(targetNum)])\n", + "\n", + " def get_value(self, state: torch.Tensor):\n", + " target = state[:,0].to(torch.int32) # int\n", + " thisStateNum = target.size()[0]\n", + " viewInput = state[:,-self.raySize:] # all ray input\n", + " targetInput = state[:,:self.nonRaySize]\n", + " viewLayer = self.viewNetwork(viewInput)\n", + " targetLayer = torch.stack([self.targetNetworks[target[i]](targetInput[i]) for i in range(thisStateNum)])\n", + " middleInput = torch.cat([viewLayer,targetLayer],dim = 1)\n", + " middleLayer = torch.stack([self.middleNetworks[target[i]](middleInput[i]) for i in range(thisStateNum)])\n", + " criticV = torch.stack([self.critic[target[i]](middleLayer[i]) for i in range(thisStateNum)]) # self.critic\n", + " return criticV\n", + "\n", + " def get_actions_value(self, state: torch.Tensor, actions=None):\n", + " target = state[:,0].to(torch.int32) # int\n", + " thisStateNum = target.size()[0]\n", + " viewInput = state[:,-self.raySize:] # all ray input\n", + " targetInput = state[:,:self.nonRaySize]\n", + " viewLayer = self.viewNetwork(viewInput)\n", + " targetLayer = torch.stack([self.targetNetworks[target[i]](targetInput[i]) for i in range(thisStateNum)])\n", + " middleInput = torch.cat([viewLayer,targetLayer],dim = 1)\n", + " middleLayer = torch.stack([self.middleNetworks[target[i]](middleInput[i]) for i in range(thisStateNum)])\n", + "\n", + " # discrete\n", + " # 递归targets的数量,既agent数来实现根据target不同来选用对应的输出网络计算输出\n", + " dis_logits = torch.stack([self.actor_dis[target[i]](middleLayer[i]) for i in range(thisStateNum)])\n", + " split_logits = torch.split(dis_logits, self.discrete_shape, dim=1)\n", + " multi_categoricals = [Categorical(logits=thisLogits) for thisLogits in split_logits]\n", + " # continuous\n", + " actions_mean = torch.stack([self.actor_mean[target[i]](middleLayer[i]) for i in range(thisStateNum)]) # self.actor_mean(hidden)\n", + " # action_logstd = torch.stack([self.actor_logstd[target[i]](middleLayer[i]) for i in range(thisStateNum)]) # self.actor_logstd(hidden)\n", + " # action_logstd = self.actor_logstd.expand_as(actions_mean) # self.actor_logstd.expand_as(actions_mean)\n", + " action_logstd = torch.stack([torch.squeeze(self.actor_logstd[target[i]],0) for i in range(thisStateNum)])\n", + " # print(action_logstd)\n", + " action_std = torch.exp(action_logstd) # torch.exp(action_logstd)\n", + " con_probs = Normal(actions_mean, action_std)\n", + " # critic\n", + " criticV = torch.stack([self.critic[target[i]](middleLayer[i]) for i in range(thisStateNum)]) # self.critic\n", + "\n", + " if actions is None:\n", + " if True:\n", + " # select actions base on probability distribution model\n", + " disAct = torch.stack([ctgr.sample() for ctgr in multi_categoricals])\n", + " conAct = con_probs.sample()\n", + " actions = torch.cat([disAct.T, conAct], dim=1)\n", + " else:\n", + " # select actions base on best probability distribution\n", + " # disAct = torch.stack([torch.argmax(logit, dim=1) for logit in split_logits])\n", + " conAct = actions_mean\n", + " disAct = torch.stack([ctgr.sample() for ctgr in multi_categoricals])\n", + " conAct = con_probs.sample()\n", + " actions = torch.cat([disAct.T, conAct], dim=1)\n", + " else:\n", + " disAct = actions[:, 0 : env.unity_discrete_type].T\n", + " conAct = actions[:, env.unity_discrete_type :]\n", + " dis_log_prob = torch.stack(\n", + " [ctgr.log_prob(act) for act, ctgr in zip(disAct, multi_categoricals)]\n", + " )\n", + " dis_entropy = torch.stack([ctgr.entropy() for ctgr in multi_categoricals])\n", + " return (\n", + " actions,\n", + " dis_log_prob.sum(0),\n", + " dis_entropy.sum(0),\n", + " con_probs.log_prob(conAct).sum(1),\n", + " con_probs.entropy().sum(1),\n", + " criticV,\n", + " )" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, + "outputs": [], + "source": [ + "niceGotoLOAD_DIR = \"C:/Users/UCUNI/OneDrive/Unity/ML-Agents/Aimbot-PPO/Aimbot-PPO-Python/PPO-Model/PList_Go_LeakyReLU_9331_1677965178_GOTOModel/PList_Go_LeakyReLU_9331_1677965178_last.pt\"\n", + "badGotoLoar_Dir = \"C:/Users/UCUNI/OneDrive/Unity/ML-Agents/Aimbot-PPO/Aimbot-PPO-Python/PPO-Model/PList_Attack_LeakyReLU_9331_1678547500/PList_Attack_LeakyReLU_9331_1678547500_last.pt\"\n", + "\n", + "niceGotoAgent = torch.load(niceGotoLOAD_DIR)\n", + "badGotoAgent = torch.load(badGotoLoar_Dir)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "37\n" + "odict_keys(['viewNetwork.0.weight', 'viewNetwork.0.bias', 'targetNetworks.0.0.weight', 'targetNetworks.0.0.bias', 'targetNetworks.1.0.weight', 'targetNetworks.1.0.bias', 'targetNetworks.2.0.weight', 'targetNetworks.2.0.bias', 'targetNetworks.3.0.weight', 'targetNetworks.3.0.bias', 'middleNetworks.0.0.weight', 'middleNetworks.0.0.bias', 'middleNetworks.1.0.weight', 'middleNetworks.1.0.bias', 'middleNetworks.2.0.weight', 'middleNetworks.2.0.bias', 'middleNetworks.3.0.weight', 'middleNetworks.3.0.bias', 'actor_dis.0.weight', 'actor_dis.0.bias', 'actor_dis.1.weight', 'actor_dis.1.bias', 'actor_dis.2.weight', 'actor_dis.2.bias', 'actor_dis.3.weight', 'actor_dis.3.bias', 'actor_mean.0.weight', 'actor_mean.0.bias', 'actor_mean.1.weight', 'actor_mean.1.bias', 'actor_mean.2.weight', 'actor_mean.2.bias', 'actor_mean.3.weight', 'actor_mean.3.bias', 'actor_logstd.0', 'actor_logstd.1', 'actor_logstd.2', 'actor_logstd.3', 'critic.0.weight', 'critic.0.bias', 'critic.1.weight', 'critic.1.bias', 'critic.2.weight', 'critic.2.bias', 'critic.3.weight', 'critic.3.bias'])\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "a = 13\n", - "b = 24\n", + "import matplotlib.pyplot as plt\n", "\n", - "c = a + b\n", - "print(c)" + "print(niceGotoAgent.state_dict().keys())\n", + "# 获取第一层权重张量\n", + "Goodweights = niceGotoAgent.state_dict()['targetNetworks.1.0.weight'].cpu()\n", + "Badweights = badGotoAgent.state_dict()['targetNetworks.1.0.weight'].cpu()\n", + "# 将权重张量转换为numpy数组，并可视化\n", + "\n", + "fig,(ax1,ax2) = plt.subplots(2,1,figsize=(20,5))\n", + "ax1.imshow(np.rot90(Goodweights.numpy()))\n", + "ax1.set_title('Good weights')\n", + "ax1.axis('off')\n", + "ax2.imshow(np.rot90(Badweights.numpy()))\n", + "ax2.set_title('Bad weights')\n", + "ax2.axis('off')\n", + "# 显示图表\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8QAAAEuCAYAAABI7Ns6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAA7jElEQVR4nO3de6xl6Vnf+d+71r6dvc+1uqq6Xe6LbXDhW8cOdoYAji/CYxQTY0shGYS5OYqUDCaBuWSQYTIBBBMJwiCcDpmMA0oCceSog8YGgtISwd3mYhIbG2xj2cbubld13bqqTp3bvq291jt/nN2kaFed58d0kU71+n6klrpqP+dZ73rXe91713lTzlkAAAAAALRN8WwXAAAAAACAZwMbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAAAAALQSG2IAAAAAQCuxIQYA4BZKKT2WUnrTn2H+d6SUHjJjvzul9Jt/VmUBAOB2x4YYAPCcl1L61pTS76aUDlJKl5b//z0ppfRsl+1PK+f8r3POb74VuVJKH0op/c1bkQsAgNsRG2IAwHNaSul/kfQzkn5S0l2S7pT0tyV9vaTes1g0AADwLGNDDAB4zkopbUj6UUnfk3N+MOe8lw99POf8jpzz7Km4lNK/Sik9mVJ6PKX0v6eUiuVrxfLPjy8/Xf5Xy7xPXeM7lq9dSSn90BFleWFK6dp1ed+bUrp03eu/kFL6/uvK83MppfMppSdSSj+WUiqXr/2Jr0GnlN6cUvpsSmknpfSzKaWHn/6pb0rpH6WUtlNKj6aU/vLy735c0l+S9EBKaT+l9EA69NPL+9xNKX0ypfSKZ/gYAAD4bxYbYgDAc9nXSupL+kAQ948lbUh6kaTXS/pOSe9cvvbdy//euHx9VdIDkpRSepmkfyrpOySdknSHpLtvdIGc86OSdiX9+eVfvU7Sfkrppcs/v17Sw8v//xeSFpK+chn/Zklf9tXmlNJxSQ9Kevfy2p+V9HVPC/ua5d8fl/QTkn4upZRyzj8k6cOSvjfnvJpz/t7ldV4n6fSyPv66pCs3uh8AAJ4L2BADAJ7Ljku6nHNePPUXKaXfXn5SO0kpvW75yeu3Snr38hPkxyT9lA43uZL0Dkn/V875iznnfR1uPr81pdSR9C2SfiXn/Mjy0+a/L6k5ojwPS3p9Sumu5Z8fXP75hZLWJf1+SulOSW+R9P0554Oc8yVJP70s49O9RdKnc86/tLzH90i68LSYx3PO780515L+paTn6fBr4zdSSVqT9BJJKef8mZzz+SPuBwCA21rn2S4AAAB/hq5IOp5S6jy1Kc45f50kpZTO6vCN4eOSupIev+7nHpf0/OX/n7rBax0dbipPSTrz1As554OU0lGfqD4s6ZslnZX0iKQP6XDjPZX04Zxzk1K6b1me89f9zq/i+utc5+nXz8v7ut6F614fL3Ou3qhwOef/mFJ6QNI/kXRfSumXJP2vOefdI+4JAIDbFp8QAwCey35H0kzS246IuazDT0bvu+7v7pX0xPL/z93gtYWki5LOS7rnqRdSSkMdfnX5Zh7W4b/bfcPy/39Th7/c6/qvS59Zlvl4znlz+d96zvnlN8h3Xtd9RXv5W7Nv+JXtm8hf9hc5vyfn/GpJL9PhV6f/3p8iHwAAtxU2xACA56yc8zVJPyLpZ1NK35JSWlv+kqxXSRotY2pJ/1bSjy9fv0/S/yzpF5dp/o2k/2n5S7FWJf2fkt6//MT5QUl/JaX02pRST4e/wOumc2vO+fOSJpK+XdLDy09eL0r6q1puiJdfUX5I0k+llNaX5f2KlNLrb5DyVyXdn1J6+/Ir3O/S4W/Sdl3U4b+LliSllP5CSulrUkpdSQc6/OT6qK+AAwBwW2NDDAB4Tss5/4QON7j/mw43gBcl/TNJPyDpt5dhf0eHG8Av6vBT2/dJ+vnlaz8v6Rd0+BXnR3W4Sfw7y9yf1uEm9H06/LR2W4dfhz7Kw5Ku5JzPXPfnJOn3rov5Th0eCfWHy5wP6vDf/j793i5L+ms6/GVZV3T4qe5HdfgJs+NnJH3L8jdQv0eH/475vctrPr7M+ZNmLgAAbjsp5y/7thQAALgNLY90OivpHTnn33i2ywMAwH/r+IQYAIDbWErpG1NKmymlvqQf1OGnzR95losFAMBtgQ0xAAC3t6+V9AUd/nKwt0p6e8558uwWCQCA2wNfmQYAAAAAtBKfEAMAAAAAWokNMQAAAACglTpHvfi1D/1A+H3qc2ePeVcqva9mn773Yhjz2O/cY+Wq1uJrFse9kynqSRkHLbz3F1a/eGS1S5Imr/T++VdK8T2WndrK1f+ttTBm65vOWbmqJq6L7Q97R2XmV+3FQZ+Myy7JeguoOj32cuUUh5j/IqF4YhDGLDa857h1aieM6ZTesaJPXloPY7oXelau578mbjtPfPSUlau+exrGdPsLK9fx9YMw5twXTli5cjeu19UT8fUkafGJzTCmfGX8rCWvHd696eX63OfjZzR8PB7jJGn8oiqMST2v3Zfn+2HM1v2XrVzVIh7vN4feGP3YYyfDmPtPnwljJOkzv/tCKy7dG7exujLmNEknj++GMZcux+OEqzTGQkn6+jd8Koz56HlvrTCZxGPYcOitFbIxL+xfXLVyyRhPkhEjSf2VuK/1ftubR8s3XgljFsYaQJJecvxSGPOx//xiK9fg3nitMN5e8XJtxM97PvXGuXzNmCM34ucjScWlOFdxt7eGuWsrrq8zZ+6wcq1/Ki7X7v1zK1eaxmNTHnjzwmgrHqfHe/HcIUmF0dfqsdcmTjwvnm8vX/H6Yzbq6577vLnv/Cfidflizav7Yj1u0/2B1+7v3Ijb6uPnvbb62Le/+4aDNJ8QAwAAAABaiQ0xAAAAAKCV2BADAAAAAFqJDTEAAAAAoJXYEAMAAAAAWokNMQAAAACgldgQAwAAAABaiQ0xAAAAAKCV2BADAAAAAFop5Zxv+uJXvv/Hbv7iUjXteFealFbYifu2w5jtnZGVK6Ww+Kpr7z2B4twgjFms11auzvo8zrXXtXI5b2l0RpWVqp7Hz2iwOrNyTa6uhDHFcGHl6vbiuJlxPUnqbU3DmPnV+FlLUrkRP8fBwKv78V4/jMljs6914nbfW/eeY6cTt+mm8frQ9IrRJla9+sqL+Jp56o05Tpuov+SNOfXxuE10+t44sXCed05Wru5a/Lyr/Z6Vq7cW3+N8bI5fRvl7o/h6kjQ3yp+6jZXL0THGJUnq9+O4/cte+1o7sW/FHezFY1hj9CFJKntxndW73vMu1uL+7fRtScqN1/a9ZHFIKo0gSR3jeXe63hgw3Y/nBe1588LKqbjtLBbemFlNzP5tyPP4eXeNMUeS7tiM7/HChU0rl2ZxXXSuefW1uDMuv9u+ik7cH0dDb34/ODDGidrrZ85z7JhrvoVR98P1eN6WpPHVYRxk7BUkKRljYeGOE924LpI5xFVVXF89c76aPBnXl7P2laSiiOurY7RnSZpNb92Y8+i3/eANa5ZPiAEAAAAArcSGGAAAAADQSmyIAQAAAACtxIYYAAAAANBKbIgBAAAAAK3EhhgAAAAA0EpsiAEAAAAArcSGGAAAAADQSkee6F7t9uIMXe8Qag28w5efPLMVxhSrlZUrGdv9Zt877Ln7gvjA99o8OLoo47ooV71DtLNRre7B6qfvvRDGfOHCCStXsRKXf7DiHe49nRjtsF9buYoibq/Fmte+6umR3UeSdGC2r7WTcfs6KAZWrtFafGD93pOrVq55Fbed7tbMyiWj7u/YiutBkq7txofHNz2vTcx3+mFMutO7x/4gbjtz4+B7SRreFdfF9PE1K9diHF+zcyJuN5JUzeJ2v7o5sXLtX4zbYT3w3rc9dnI3jLl6cd3KpUV8zWoc14Mk9e802vTCG6P3r3ltJ5tjvpXLmOLLDW8sd8rVG3q56sfittOc8tr0cBT374kzD0kaDeNcdTafTzLmq2Nefc0ei8eKU6+4aOV6sojrfm6ME5KUZ3FfS8bcIUkXnjDWj+ZaQZ14cdWMvLVC6axFzTGgNNaPu8a4KkmpigvWucPrQ00ZP6Om8e6xO4jXj1VVWrlK4xnVe946TUYzrKdeuZxxtTGez2GyuF7n57314333x/uAL104ZuWqJ3G9NuZ6W5fidVqzavbtm+ATYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArdY56sVyrwgT1+MgU/8XC23t3N6dhTG68XPV2P4zpbXu5ZuUgjOlvxGWXpEUV11nOVio1U6P+k5fsc2fvDGNyZb6HUqcwJI3mVqpOt46DnBhJ0+34OaaBl8u5x3K0sFLtXR3FQXOv7vcOumHMyvGxlWt6ziiXqxO3wyfPb9yyy5VDr+67a3E7rPZ6Vq6Z0T/KTa/dV/O4b2+++KqVa1bFbeJgJ+4bkjQyxrnJOB57JalYjeeYZl5auba3V+Mgsw85z6gwx9W58RwLY66VpGbizbepb4xh5hwz+MOVMKa6/8DKlXpNGFMUXsFm6/E9DvreGLC/PQxjhhsTK9fO2XgM65/0xt9sPO888tpO/779MObaxBsDFlXcJ1M8PR4y5tHqUtwGJWnleXE7nF7w5rTR8/fCmINdr76czpYbr8KcupfRzySpuzkLY+YH3tynyljzmWurahrPV+6eolyPx/KuESOZ64DSG7+Go7ju9y8ac5qktBKPc80J7x7PXNoKY4qO177yKK4Ldx4t74n79tzZDx1Vlmf00wAAAAAA3KbYEAMAAAAAWokNMQAAAACgldgQAwAAAABaiQ0xAAAAAKCV2BADAAAAAFqJDTEAAAAAoJXYEAMAAAAAWunIU4zrnfgQ6jT0Dr7P5mHVi1l8sHIqvFz9k+Mwptr0DnJOi/jQ8cIsV6cb19l87B2GPjwW3+N8ZhxyLinn+B7rA+89lM5GfAj4dOLdY1HEh4BXY+8eu2txudz2lbveIfNerjimHHoHqy/mcZt224TW47bq1n3Ri+ur2/fGk6aO22G107dy1d24fXXXZ16uqgxjitJrN5trkzDm2t6KlctpE0UnrgdJmjhjk9eF1Czi59hdqaxcXaM/jitv/KqvGfe46fXHrjF+NdO43UiSzHnUqn9jvJekySmjvRrtXpKyUf/9Na+vFZM419QcA1InrrDJ3sDKVW7F5R/0vDY97cftsJl5dV8ZbcdZA0jS6mgaxuwfePUlo+7TullfxtiUjetJ0mQct53cePXl9jUvlxFjjKuSNN+N77EceXVfjox12sRcdxgGd8TzoyRVxtxX197zKVbi9cnAXKcd7Mb9Y+V4vL6XpOn5URiTV7x1x2Az7tsz8zk2U2PdYbav6bYxnrjz483K8ox+GgAAAACA2xQbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0UueoF9NwESYouo11oXq3Z8Wl1cqKc8xnR96eJKksvfLnMn7vYD6PrydJzSLO1enHdS9Jk/1+HJSsVEopx0GD+pblytkrWHUtvsfB8YmXy3hG9aS0cqmOy18MvOfo1EW98MqVjXLlwnjWkpLRP8qel6vsxG1nPu1aufI87kP9Y16bmE/ia1Z7Rj+TJGM4Kde9MefyY8fCmGJzbuUqO/E1FxNv/OoO4zG60/XGifnMeN6Pjqxck+fPwpii55WrNO6x2vfmtLqO41bv3LdyLcwxwJnXxudWvVzH4nptjDFHkjqjuL2641yzYYytxjghSWk/jhu9YMfKtXcxrtfdSwMrV9qK66tjzjF1Hd9jVXl1P7swDGNWTnltup7H13TmDkkqjHmtMccmZ052179O+d3xpGni+ipWzHWH0W/rfW9OLtbitppn5mdwxnCyMfLm94s7m7fkepKsNd/E6GeSJKOtTsdem7A03k06c/JwNZ4TJGnmrDuMfZokyelr5p7iZviEGAAAAADQSmyIAQAAAACtxIYYAAAAANBKbIgBAAAAAK3EhhgAAAAA0EpsiAEAAAAArcSGGAAAAADQSmyIAQAAAACtdOSJyKcfqMIEn3uXeXC0eYB5Oh8fWF8fjw8Al6R7PhAfYH727d4h7aub4zBm79KqlevVL300jPnYH91n5XIOCu9c8Q5WP/nR+Bkl7zHqq9/9B2HMZ3busnItTsbv25z7yCkr19ve8rthzC9/7n4rV6+/CGO+6/RHrFwf+OE3hTHn3hr3R0n6qvsuhDEPnv53Vq77f+XvhjGdramVq17E/fFjb3zAyvXVv/Z9Ycyrnv+ElesTv/5VYUz58l0rV9PEbfW7X+K1iTPTY2HMb517oZXrb734w2HMqwZfsnK944PvinO95vNWrp3XXgljvvi+V1m5Nh9ZCWNe/c54XJKkj//zPxfGXPmLXn88cepaGLOzH5ddkr7hRZ+z4n7tE/EY1j8Zz2mSNLsSl+37XveQlWtYxHP3I9unrVwfe+hlYcw3vvU/Wbn+wxdfGsa8+q6zVq5HvvjyMOaVr/mClev3v3R3HJSylavbi+erlQ+tWbmG3xzPMZd3vPXQG1/y2TDmoxfusXKVRbxAecHmVSvXxz8Vj63lQTynSdKb3/B7Ycy///QrrFyjjUkY87YXftLK9f6HXhvGbMSPR5J0+m/8URizv+hbuT75+bjdX90ZWbnUxGvkchT3DUmqZ/Hzzl531KNv+vkw5it+/Z1esq14XO0b61VJWv9g3G9/5B+8z8r1njPfEMZUjdeHzj4SjwHNy/atXDfDJ8QAAAAAgFZiQwwAAAAAaCU2xAAAAACAVmJDDAAAAABoJTbEAAAAAIBWYkMMAAAAAGglNsQAAAAAgFZiQwwAAAAAaCU2xAAAAACAVko555u++IJf/Ic3f3Epjzvelfq1FVZ0mjCmmXjXTIP4ms71JKm50g9j8urCyuVcsyjDqpckLWZlHDT33vdIK8YzapKVq+zFuXL2ctXT+B7LFbPui7jue0bZJelgeyWMKY02KEn1XjeMKVYrK5fD7UMq4nZYmPWVjDbt1IMkdTdmYUxhlF2SGqNNN7XRzyTVxnhYDr22Wpv99lbpj+ZW3HwaP6O8MMs+jeO6x6ZWKud5zw56Xi5jjC7NuWMxi9tENsfV7oo3BvT6cRs72BlYuTrG3G3NQ5LKXlxn9cTLlTrx83brtWe0/br22nRtjK0dc75aHHjjoaMwrplrr74czngvSU1l1Ks5njj32JhttWu0iYUxFkpSXsT16s4LMtZNKXl1Xxv16ubqGOuA+dirr8FqXPfzqbeGcceAWyXPvfYlY/pw9jCSN992h97csTDK7zxrSarMZ+RwxpPsjCWSHn/nD9ywUfAJMQAAAACgldgQAwAAAABaiQ0xAAAAAKCV2BADAAAAAFqJDTEAAAAAoJXYEAMAAAAAWokNMQAAAACgldgQAwAAAABa6chTk51D2gd3TKwLLSrvsOpONz7wuRjGh3ZL0mS/H+cqjNOxJdW9OK7T9w6rXhgHwxell6s7MA5zH1iprGdUdM36Mg73dg6rl6TuKD5QPBuH1UvSYh4fFO7EHAYa1zQPtVcRxyUjRpIa43DywebUyjU3DlZ3D75PzttvRj+TpGq/F8aUK14fqg/ie0xmuQqjP9YTbyxMRl9zDquXvGe0WHjlykZ9dbe89lX34ms2jfu+7a2rr8YYC912n51Les3LaveSVC/iOkte8WXVmDHmSFJtzH1p4PXbohfHOWOhJC2M+cptO8684M5XxUo8nvT6xhpAUm2s5+rsjQGFUReNcT1J6q7E87s7BhTGfJtWvOdYG+PhYHVm5Zoaa1G3rRaduPxO/5ekPDbmd3PNNzeu6a4fZwfxOJfN+to8uRfGXDu/buXqGuumypwXnLpojHFJ8tYK9jzqFN9c197Ke8xjI85cI9/0x5/RTwMAAAAAcJtiQwwAAAAAaCU2xAAAAACAVmJDDAAAAABoJTbEAAAAAIBWYkMMAAAAAGglNsQAAAAAgFZiQwwAAAAAaCU2xAAAAACAVuo80wTT7YEVV65WVtz87CiMaUa1lUtlDkOqed/LZbx1EF/tUKcfl7/sePdYFPFVmyZZuTrJqK89r76ScY+doXePTRNXfnYr35Ar732iNIjLXx90rVzd9VkY49Z9f2Maxkyvev3W0mussE7XGQO8Ianei+u17My9XDm+Zqe/sHJVk7hchdE3JElGt+10vVyLqoxzmWNObYyryt6Y0+159erodOJ2WC/iepCktWMHYczulXiukqRklMuJkaRm7pU/G2O+EyNJ9TTuH6sn4vqSpMnYGMOMeUiyuocGI28MmBn91qstqbseX7OuvTnGed7TqdcmUieu11x7d9kz5qs6effo9NvJbs/K1RzEddG/a+zlMvpHNffmK2f+qNy1wjCu++mVFSuXunHdrxjrCUnK5pjvmE6NccKZhyTVTrnMMWcxNZ6RWQ/N2Gg77rq2MK5p1tdoLX7e+1eHVi4tjHJ1zZt0103PAJ8QAwAAAABaiQ0xAAAAAKCV2BADAAAAAFqJDTEAAAAAoJXYEAMAAAAAWokNMQAAAACgldgQAwAAAABaiQ0xAAAAAKCVjjwZuuzFh3Y35mHP7pHd/Xv3whj3APC5c2i6mavTjQ9Wd8tVzeJyOYfCH17UCKlv4fsenbhNSFI2Dh2vh3GdSlIq4pvsGQffS9J8GperXDHLZRzmXpl13+3Gh45XZt3P9m/dofbFLTwM3ekfjXOQu2S1w3pRWqm66/MwptrvWblktNXSfI6NUV+12b4Ko1yNmauzWoUx7lg42xmEMeUovp4rL7x73N+Ly5W65lg4j6+Z3H5mPEfJG/N7o7jdS1JljJn711asXKrjdtFfn1mpKmN+n1z1yjXYmoYx2at6dYz+7c7vU6O+cuO16Wxc0x3v58YaxmbMo90VbwyojPlj6o7lht7QK5ezVkjGeluSZpNunGvgPcfBatzXrHW0pHoWz7eFOWYONuJyzcZxPUjS3pOrYUxhrkWdea0w53cZxW/m3hrGmmN6XpvYvzKMg8z1Y3cjnmPcdZo1dx88s3GJT4gBAAAAAK3EhhgAAAAA0EpsiAEAAAAArcSGGAAAAADQSmyIAQAAAACtxIYYAAAAANBKbIgBAAAAAK3EhhgAAAAA0EpsiAEAAAAArdQ56sWmTmGCbMRI0qIuvbjxkUWSJHVHlZVrNJyFMdNZ18pVzeJy5carC0d/4N2jY7I7sOI6g0UYU3ZqK1cziN9rqQ68us/G2zbTXS9X//jEinPMLq+EMcWa9xwXC6N/LLz3r1aPH4QxB2ab2NgYhzHbF9etXPP9+BkNzOdTzeP+2OnG7Vny+rZTp5JZrylbuYYr8zBm/4xX97kTX7Nc99pqfRDXVxp440RhjDmFWV9OH9rY8p7jtSdXw5jO0GtftTEvNJO4TiVp5ZjXPyZ7/TBmPvbGzE4/fpb13Jvfc47rYnY1Hlclqbs5jYOGVipNd+P6kjm9dzbjZzQ3xi/Xujk27V5YC2OauTfHFMYarOw0Vq6OEbeovPaVjLa66Y4BX9oMY+bmnFwa9ZXMca4x1k3djXjtK0mTa/F81VuL5yFJ6q7Gde/M25I0m8T32Ol5c0xVx8+ocdtXGbfVbLaJPI6vObzTa6vjy/FA54y9kpS68T0WxnpCksoyjlvMvHKtrMXj/bgyB/yb4BNiAAAAAEArsSEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAAAAALTSkadkuwdMO5J5SHs2DoZPhXcodLWID75ujEO7Je+Qeffw+M3N+LDta9sjK5f24wPMV0/tWam2hpMw5uzFLSuX03b6697h8fNpfI9a9dqXY2G0G0nW20nNgVF2SQPj0PF52bNy7V9bCWPSwZFd/49tT9fDmHKtsnLVRl3MJl595Squ/NoYSySpO1iEMftXvQPfy5U4V7XTt3I58qi24tI4btP1xGv3ndX4eZcdr1zzcdymu8O5latnXPPa5VUrl5oUhiz2vLa69bzdMGb73IaVa2HOyc4c6c6j9XbcXnPXHH+NuGLg5VpcjPtk73nxXCtJM2MeVenV13g/rq87T+xYua7sxOuAycSbF9IibtPDU/tWLsd4zxvnqj2j/B2v7pMxhl1L3toqbcTjTmm2ibXVeG21fcUbm5z5dvHkwMqlftzXOuZYnnPcvhqjDUrS5lbcb+vGnN978Zw8Obvm5bprHMZU5homjYy1wtxbpxVGruaqN07cffpSGPPEpU0r1/Sq0Q7Nvj2+HI/3Tj0c+fPP6KcBAAAAALhNsSEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAAAAALQSG2IAAAAAQCulnPOzXQYAAAAAAP6r4xNiAAAAAEArsSEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAOAZSCk9llJ6059h/neklB4yY787pfSbf1ZlAQDguYYNMQCgVZYb2ElKaT+ltJ1S+tWU0j3PdrluJuf8r3POb74VuVJKH0op/c1bkQsAgOcCNsQAgDZ6a855VdLzJF2U9I+f5fIAAIBnARtiAEBr5Zynkh6U9LKn/i6l9E0ppY+nlHZTSmdSSj98/c+klL4jpfR4SulKSumHbpY7pfTClNK1lFKx/PN7U0qXrnv9F1JK37/8/42U0s+llM6nlJ5IKf1YSqlcvvYnvgadUnpzSumzKaWdlNLPppQefvqnvimlf7T89PvRlNJfXv7dj0v6S5IeWH46/kA69NMppUvL+/1kSukV/3/rEwCA2w0bYgBAa6WUhpL+B0kfue6vDyR9p6RNSd8k6X9MKb19Gf8ySf9U0ndIOiXpDkl33yh3zvlRSbuS/vzyr14naT+l9NLln18v6eHl//8LSQtJX7mMf7OkL/tqc0rpuA438O9eXvuzkr7uaWFfs/z745J+QtLPpZRSzvmHJH1Y0vfmnFdzzt+7vM7rJJ2WtCHpr0u6cqP7AQDguYgNMQCgjf7flNI1STuS/ntJP/nUCznnD+WcP5lzbnLOfyDp3+hw8ypJ3yLpV3LOj+ScZ5L+vqTmiOs8LOn1KaW7ln9+cPnnF0pal/T7KaU7Jb1F0vfnnA9yzpck/bSkb71BvrdI+nTO+ZdyzgtJ75F04Wkxj+ec35tzriX9Sx1+LfzOm5SvkrQm6SWSUs75Mznn80fcDwAAzylsiAEAbfT2nPOmpIGk75X08FOb1pTS16SUfiOl9GRKaUfS39bhp63S4afCZ55KknM+0NGfqD4s6Q06/BT2EUkf0uHm+vWSPpxzbiTdJ6kr6fzyK9bXJP0zSSdvkO/p18+Szj4t5sJ1r4+X/7t6o8LlnP+jpAck/RNJl1JK/09Kaf2I+wEA4DmFDTEAoLVyznXO+Zck1ZJeu/zr90n6oKR7cs4bkv5vSWn52nlJf/wbqZdfub7jiEs8rMN/t/uG5f//pqSv15/8uvQZSTNJx3POm8v/1nPOL79BvvO67ivaKaWkm3xl+ybyl/1Fzu/JOb9ah/+O+rSkv/enyAcAwG2NDTEAoLWWv1TqbZK2JH1m+ddrkq7mnKcppf9O0rdd9yMPSvorKaXXppR6kn5UR8ylOefPS5pI+nZJD+ecd3X4W63/qpYb4uVXlB+S9FMppfWUUpFS+oqU0utvkPJXJd2fUnp7Sqkj6V2S7rpB3M1clPSi6+7/Lyw/Ee/q8N9OT3X0V8ABAHhOYUMMAGijX04p7evwl179uKTvyjl/evna90j60ZTSnqT/Q9K/feqHljHv0uGnyOclbevLv7L8dA9LupJzPnPdn5Ok37su5jsl9ST94TLngzr8t79/Qs75sqS/psNflnVFh5/qflSHnzA7fkbStyx/A/V7dPjvmN+7vObjy5w/ecTPAwDwnJIO//kRAAC43SyPdDor6R055994tssDAMDthk+IAQC4jaSUvjGltJlS6kv6QR1+2vyR4McAAMANsCEGAOD28rWSviDpsqS36vA3Zk+e3SIBAHB74ivTAAAAAIBW4hNiAAAAAEArsSEGAAAAALRS56gXv/ahHwi/T33u7DHvSqX31ezT914MYx77nXusXNVafM3iuHdSRT0p46CF9/7C6hePrHZJ0uSV3j8HSym+x7JTW7n6v7UWxmx90zkrV9XEdbH9Ye/ozPyqvTjok3HZJVlvAVWnx16unOIQ818kFE8MwpjFhvcct07thDGd0jtm9MlL62FM90LPyvX818Rt54mPnrJy1XdPw5huf2HlOr5+EMac+8IJK1fuxvW6eiK+niQtPrEZxpSvjJ+15LXDuze9XJ/7fPyMho/HY5wkjV9UhTGp57X78nw/jNm6/7KVq1rE4/3m0BujH3vsZBhz/+kzYYwkfeZ3X2jFpXvjNlZXxpwm6eTx3TDm0uV4nHCVxlgoSV//hk+FMR89760VJpN4DBsOvbVCNuaF/YurVi4Z40kyYiSpvxL3td5ve/No+cYrYczCWANI0kuOXwpjPvafX2zlGtwbrxXG2ytero34ec+n3jiXrxlz5Eb8fCSpuBTnKu721jB3bcX1debMHVau9U/F5dq9f27lStN4bMoDb14YbcXj9HgvnjskqTD6Wj322sSJ58Xz7eUrXn/MRn3dc583953/RLwuX6x5dV+sx226P/Da/Z0bcVt9/LzXVh/79nffcJDmE2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK6Wc801f/Mr3/9jNX1yqph3vSpPSCjtx33YYs70zsnKlFBZfde29J1CcG4Qxi/XaytVZn8e59rpWLuctjc6oslLV8/gZDVZnVq7J1ZUwphgurFzdXhw3M64nSb2taRgzvxo/a0kqN+LnOBh4dT/e64cxeWz2tU7c7nvr3nPsdOI23TReH5peMdrEqldfeRFfM0+9McdpE/WXvDGnPh63iU7fGycWzvPOycrVXYufd7Xfs3L11uJ7nI/N8csof28UX0+S5kb5U7excjk6xrgkSf1+HLd/2Wtfayf2rbiDvXgMa4w+JEllL66zetd73sVa3L+dvi1JufHavpcsDkmlESSpYzzvTtcbA6b78bygPW9eWDkVt53Fwhszq4nZvw15Hj/vrjHmSNIdm/E9XriwaeXSLK6LzjWvvhZ3xuV321fRifvjaOjN7wcHxjhRe/3MeY4dc823MOp+uB7P25I0vjqMg4y9giQlYyws3HGiG9dFMoe4qorrq2fOV5Mn4/py1r6SVBRxfXWM9ixJs+mtG3Me/bYfvGHN8gkxAAAAAKCV2BADAAAAAFqJDTEAAAAAoJXYEAMAAAAAWokNMQAAAACgldgQAwAAAABaiQ0xAAAAAKCV2BADAAAAAFrpyBPdq91enKHrHUKtgXf48pNntsKYYrWyciVju9/se4c9d18QH/hemwdHF2VcF+Wqd4h2NqrVPVj99L0XwpgvXDhh5SpW4vIPVrzDvacTox32aytXUcTttVjz2lc9PbL7SJIOzPa1djJuXwfFwMo1WosPrN97ctXKNa/ittPdmlm5ZNT9HVtxPUjStd348Pim57WJ+U4/jEl3evfYH8RtZ24cfC9Jw7viupg+vmblWozja3ZOxO1GkqpZ3O5XNydWrv2LcTusB977tsdO7oYxVy+uW7m0iK9ZjeN6kKT+nUabXnhj9P41r+1kc8y3chlTfLnhjeVOuXpDL1f9WNx2mlNemx6O4v49ceYhSaNhnKvO5vNJxnx1zKuv2WPxWHHqFRetXE8Wcd3PjXFCkvIs7mvJmDsk6cITxvrRXCuoEy+umpG3Viidtag5BpTG+nHXGFclKVVxwTp3eH2oKeNn1DTePXYH8fqxqkorV2k8o3rPW6fJaIb11CuXM642xvM5TBbX6/y8t3687/54H/ClC8esXPUkrtfGXG/rUrxOa1bNvn0TfEIMAAAAAGglNsQAAAAAgFZiQwwAAAAAaCU2xAAAAACAVmJDDAAAAABoJTbEAAAAAIBWYkMMAAAAAGglNsQAAAAAgFZiQwwAAAAAaKXOUS+Wa1WYoB4fmeK/WHh77+7mNIzJjZer3u6HMb1tL9esHIQx/Y247JK0qOI6y9lKpWZq1H/ykn3u7J1hTK7M91DqFIak0dxK1enWcZATI2m6HT/HNPByOfdYjhZWqr2rozho7tX93kE3jFk5PrZyTc8Z5XJ14nb45PmNW3a5cujVfXctbofVXs/KNTP6R7nptftqHvftzRdftXLNqrhNHOzEfUOSRsY4NxnHY68kFavxHNPMSyvX9vZqHGT2IecZFea4OjeeY2HMtZLUTLz5NvWNMcycYwZ/uBLGVPcfWLlSrwljisIr2Gw9vsdB3xsD9reHYcxwY2Ll2jkbj2H9k974m43nnUde2+nftx/GXJt4Y8CiivtkiqfHQ8Y8Wl2K26AkrTwvbofTC96cNnr+XhhzsOvVl9PZcuNVmFP3MvqZJHU3Z2HM/MCb+1QZaz5zbVVN4/nK3VOU6/FY3jViJHMdUHrj13AU1/3+RWNOk5RW4nGuOeHd45lLW2FM0fHaVx7FdeHOo+U9cd+eO/uho8ryjH4aAAAAAIDbFBtiAAAAAEArsSEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArHXmKcb0TH0Kdht7B99k8rHoxiw9WToWXq39yHMZUm95BzmkRHzpemOXqdOM6m4+9w9CHx+J7nM+MQ84l5RzfY33gvYfS2YgPAZ9OvHssivgQ8Grs3WN3LS6X275y1ztk3ssVx5RD72D1xTxu026b0HrcVt26L3pxfXX73njS1HE7rHb6Vq66G7ev7vrMy1WVYUxReu1mc20SxlzbW7FyOW2i6MT1IEkTZ2zyupCaRfwcuyuVlatr9Mdx5Y1f9TXjHje9/tg1xq9mGrcbSZI5j1r1b4z3kjQ5ZbRXo91LUjbqv7/m9bViEueammNA6sQVNtkbWLnKrbj8g57Xpqf9uB02M6/uK6PtOGsASVodTcOY/QOvvmTUfVo368sYm7JxPUmajOO2kxuvvty+5uUyYoxxVZLmu/E9liOv7suRsU6bmOsOw+COeH6UpMqY++raez7FSrw+GZjrtIPduH+sHI/X95I0PT8KY/KKt+4YbMZ9e2Y+x2ZqrDvM9jXdNsYTd368WVme0U8DAAAAAHCbYkMMAAAAAGglNsQAAAAAgFZiQwwAAAAAaCU2xAAAAACAVmJDDAAAAABoJTbEAAAAAIBWYkMMAAAAAGglNsQAAAAAgFbqHPViGi7CBEW3sS5U7/asuLRaWXGO+ezI25MklaVX/lzG7x3M5/H1JKlZxLk6/bjuJWmy34+DkpVKKeU4aFDfslw5ewWrrsX3ODg+8XIZz6ielFYu1XH5i4H3HJ26qBdeubJRrlwYz1pSMvpH2fNylZ247cynXStXnsd9qH/MaxPzSXzNas/oZ5JkDCflujfmXH7sWBhTbM6tXGUnvuZi4o1f3WE8Rne63jgxnxnP+9GRlWvy/FkYU/S8cpXGPVb73pxW13Hc6p37Vq6FOQY489r43KqX61hcr40x5khSZxS3V3ecazaMsdUYJyQp7cdxoxfsWLn2Lsb1untpYOVKW3F9dcw5pq7je6wqr+5nF4ZhzMopr03X8/iaztwhSYUxrzXm2OTMye761ym/O540TVxfxYq57jD6bb3vzcnFWtxW88z8DM4YTjZG3vx+cWfzllxPkrXmmxj9TJJktNXp2GsTlsa7SWdOHq7Gc4IkzZx1h7FPkyQ5fc3cU9wMnxADAAAAAFqJDTEAAAAAoJXYEAMAAAAAWokNMQAAAACgldgQAwAAAABaiQ0xAAAAAKCV2BADAAAAAFqJDTEAAAAAoJWOPBH59ANVmOBz7zIPjjYPME/n4wPr6+PxAeCSdM8H4gPMz77dO6R9dXMcxuxdWrVyvfqlj4YxH/uj+6xczkHhnSveweonPxo/o+Q9Rn31u/8gjPnMzl1WrsXJ+H2bcx85ZeV621t+N4z55c/db+Xq9RdhzHed/oiV6wM//KYw5txb4/4oSV9134Uw5sHT/87Kdf+v/N0wprM1tXLVi7g/fuyND1i5vvrXvi+MedXzn7ByfeLXvyqMKV++a+VqmritfvdLvDZxZnosjPmtcy+0cv2tF384jHnV4EtWrnd88F1xrtd83sq189orYcwX3/cqK9fmIythzKvfGY9LkvTxf/7nwpgrf9HrjydOXQtjdvbjskvSN7zoc1bcr30iHsP6J+M5TZJmV+Kyfd/rHrJyDYt47n5k+7SV62MPvSyM+ca3/icr13/44kvDmFffddbK9cgXXx7GvPI1X7By/f6X7o6DUrZydXvxfLXyoTUr1/Cb4znm8o63HnrjSz4bxnz0wj1WrrKIFygv2Lxq5fr4p+KxtTyI5zRJevMbfi+M+feffoWVa7QxCWPe9sJPWrne/9Brw5iN+PFIkk7/jT8KY/YXfSvXJz8ft/urOyMrl5p4jVyO4r4hSfUsft7Z64569E0/H8Z8xa+/00u2FY+rfWO9KknrH4z77Y/8g/dZud5z5hvCmKrx+tDZR+IxoHnZvpXrZviEGAAAAADQSmyIAQAAAACtxIYYAAAAANBKbIgBAAAAAK3EhhgAAAAA0EpsiAEAAAAArcSGGAAAAADQSmyIAQAAAACtxIYYAAAAANBKKed80xdf8Iv/8OYvLuVxx7tSv7bCik4TxjQT75ppEF/TuZ4kNVf6YUxeXVi5nGsWZVj1kqTFrIyD5t77HmnFeEZNsnKVvThXzl6uehrfY7li1n0R133PKLskHWyvhDGl0QYlqd7rhjHFamXlcrh9SEXcDguzvpLRpp16kKTuxiyMKYyyS1JjtOmmNvqZpNoYD8uh11Zrs9/eKv3R3IqbT+NnlBdm2adxXPfY1ErlPO/ZQc/LZYzRpTl3LGZxm8jmuNpd8caAXj9uYwc7AytXx5i7rXlIUtmL66yeeLlSJ37ebr32jLZf116bro2xtWPOV4sDbzx0FMY1c+3Vl8MZ7yWpqYx6NccT5x4bs612jTaxMMZCScqLuF7deUHGuiklr+5ro17dXB1jHTAfe/U1WI3rfj711jDuGHCr5LnXvmRMH84eRvLm2+7QmzsWRvmdZy1JlfmMHM54kp2xRNLj7/yBGzYKPiEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAAAAALQSG2IAAAAAQCsdeWqyc0j74I6JdaFF5R1W3enGBz4Xw/jQbkma7PfjXIVxOrakuhfHdfreYdUL42D4ovRydQfGYe4DK5X1jIquWV/G4d7OYfWS1B3FB4pn47B6SVrM44PCnZjDQOOa5qH2KuK4ZMRIUmMcTj7YnFq55sbB6u7B98l5+83oZ5JU7ffCmHLF60P1QXyPySxXYfTHeuKNhcnoa85h9ZL3jBYLr1zZqK/ulte+6l58zaZx37e9dfXVGGOh2+6zc0mveVntXpLqRVxnySu+rBozxhxJqo25Lw28flv04jhnLJSkhTFfuW3HmRfc+apYiceTXt9YA0iqjfVcnb0xoDDqojGuJ0ndlXh+d8eAwphv04r3HGtjPByszqxcU2Mt6rbVohOX3+n/kpTHxvxurvnmxjXd9ePsIB7nsllfmyf3wphr59etXF1j3VSZ84JTF40xLkneWsGeR53im+vaW3mPeWzEmWvkm/74M/ppAAAAAABuU2yIAQAAAACtxIYYAAAAANBKbIgBAAAAAK3EhhgAAAAA0EpsiAEAAAAArcSGGAAAAADQSmyIAQAAAACtxIYYAAAAANBKnWeaYLo9sOLK1cqKm58dhTHNqLZyqcxhSDXve7mMtw7iqx3q9OPylx3vHosivmrTJCtXJxn1tefVVzLusTP07rFp4srPbuUbcuW9T5QGcfnrg66Vq7s+C2Pcuu9vTMOY6VWv31p6jRXW6TpjgDck1XtxvZaduZcrx9fs9BdWrmoSl6sw+oYkyei2na6Xa1GVcS5zzKmNcVXZG3O6Pa9eHZ1O3A7rRVwPkrR27CCM2b0Sz1WSlIxyOTGS1My98mdjzHdiJKmexv1j9URcX5I0GRtjmDEPSVb30GDkjQEzo996tSV11+Nr1rU3xzjPezr12kTqxPWaa+8ue8Z8VSfvHp1+O9ntWbmag7gu+neNvVxG/6jm3nzlzB+Vu1YYxnU/vbJi5VI3rvsVYz0hSdkc8x3TqTFOOPOQpNoplznmLKbGMzLroRkbbcdd1xbGNc36Gq3Fz3v/6tDKpYVRrq55k+666RngE2IAAAAAQCuxIQYAAAAAtBIbYgAAAABAK7EhBgAAAAC0EhtiAAAAAEArsSEGAAAAALQSG2IAAAAAQCuxIQYAAAAAtNKRJ0OXvfjQ7sY87Nk9srt/714Y4x4APncOTTdzdbrxwepuuapZXC7nUPjDixoh9S1836MTtwlJysah4/UwrlNJSkV8kz3j4HtJmk/jcpUrZrmMw9wrs+673fjQ8cqs+9n+rTvUvriFh6E7/aNxDnKXrHZYL0orVXd9HsZU+z0rl4y2WprPsTHqqzbbV2GUqzFzdVarMMYdC2c7gzCmHMXXc+WFd4/7e3G5UtccC+fxNZPbz4znKHljfm8Ut3tJqowxc//aipVLddwu+uszK1VlzO+Tq165BlvTMCZ7Va+O0b/d+X1q1FduvDadjWu64/3cWMPYjHm0u+KNAZUxf0zdsdzQG3rlctYKyVhvS9Js0o1zDbznOFiN+5q1jpZUz+L5tjDHzMFGXK7ZOK4HSdp7cjWMKcy1qDOvFeb8LqP4zdxbw1hzTM9rE/tXhnGQuX7sbsRzjLtOs+bug2c2LvEJMQAAAACgldgQAwAAAABaiQ0xAAAAAKCV2BADAAAAAFqJDTEAAAAAoJXYEAMAAAAAWokNMQAAAACgldgQAwAAAABaiQ0xAAAAAKCVOke92NQpTJCNGEla1KUXNz6ySJKk7qiyco2GszBmOutauapZXK7ceHXh6A+8e3RMdgdWXGewCGPKTm3lagbxey3VgVf32XjbZrrr5eofn1hxjtnllTCmWPOe42Jh9I+F9/7V6vGDMObAbBMbG+MwZvviupVrvh8/o4H5fKp53B873bg9S17fdupUMus1ZSvXcGUexuyf8eo+d+JrluteW60P4vpKA2+cKIwxpzDry+lDG1vec7z25GoY0xl67as25oVmEtepJK0c8/rHZK8fxszH3pjZ6cfPsp5783vOcV3MrsbjqiR1N6dx0NBKpeluXF8yp/fOZvyM5sb45Vo3x6bdC2thTDP35pjCWIOVncbK1THiFpXXvpLRVjfdMeBLm2HM3JyTS6O+kjnONca6qbsRr30laXItnq96a/E8JEnd1bjunXlbkmaT+B47PW+Oqer4GTVu+yrjtprNNpHH8TWHd3ptdXw5HuicsVeSUje+x8JYT0hSWcZxi5lXrpW1eLwfV+aAfxN8QgwAAAAAaCU2xAAAAACAVmJDDAAAAABoJTbEAAAAAIBWYkMMAAAAAGglNsQAAAAAgFZiQwwAAAAAaCU2xAAAAACAVjrylGz3gGlHMg9pz8bB8KnwDoWuFvHB141xaLfkHTLvHh6/uRkftn1te2Tl0n58gPnqqT0r1dZwEsacvbhl5XLaTn/dOzx+Po3vUate+3IsjHYjyXo7qTkwyi5pYBw6Pi97Vq79aythTDo4suv/se3pehhTrlVWrtqoi9nEq69cxZVfG2OJJHUHizBm/6p34Hu5EueqdvpWLkce1VZcGsdtup547b6zGj/vsuOVaz6O23R3OLdy9YxrXru8auVSk8KQxZ7XVreetxvGbJ/bsHItzDnZmSPdebTejttr7prjrxFXDLxci4txn+w9L55rJWlmzKMqvfoa78f1deeJHSvXlZ14HTCZePNCWsRtenhq38rlGO9541y1Z5S/49V9Msawa8lbW6WNeNwpzTaxthqvrbaveGOTM98unhxYudSP+1rHHMtzjttXY7RBSdrcivtt3Zjzey+ekydn17xcd43DmMpcw6SRsVaYe+u0wsjVXPXGibtPXwpjnri0aeWaXjXaodm3x5fj8d6phyN//hn9NAAAAAAAtyk2xAAAAACAVmJDDAAAAABoJTbEAAAAAIBWYkMMAAAAAGglNsQAAAAAgFZiQwwAAAAAaCU2xAAAAACAVmJDDAAAAABopZRzfrbLAAAAAADAf3V8QgwAAAAAaCU2xAAAAACAVmJDDAAAAABoJTbEAAAAAIBWYkMMAAAAAGglNsQAAAAAgFb6/wCc9ECFr9IaHwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "badGotoAgent.targetNetworks[1] = niceGotoAgent.targetNetworks[1]\n", + "badGotoAgent.middleNetworks[1] = niceGotoAgent.middleNetworks[1]\n", + "badGotoAgent.actor_dis[1] = niceGotoAgent.actor_dis[1]\n", + "badGotoAgent.actor_mean[1] = niceGotoAgent.actor_mean[1]\n", + "badGotoAgent.actor_logstd[1] = niceGotoAgent.actor_logstd[1]\n", + "badGotoAgent.critic[1] = niceGotoAgent.critic[1]\n", + "# 获取第一层权重张量\n", + "Goodweights = niceGotoAgent.state_dict()['targetNetworks.1.0.weight'].cpu()\n", + "Badweights = badGotoAgent.state_dict()['targetNetworks.1.0.weight'].cpu()\n", + "# 将权重张量转换为numpy数组，并可视化\n", + "\n", + "fig,(ax1,ax2) = plt.subplots(2,1,figsize=(20,5))\n", + "ax1.imshow(np.rot90(Goodweights.numpy()))\n", + "ax1.set_title('Good weights')\n", + "ax1.axis('off')\n", + "ax2.imshow(np.rot90(Badweights.numpy()))\n", + "ax2.set_title('Bad weights')\n", + "ax2.axis('off')\n", + "# 显示图表\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "saveDir = \"C:/Users/UCUNI/OneDrive/Unity/ML-Agents/Aimbot-PPO/Aimbot-PPO-Python/PPO-Model/Chimera-1677965178-1678547500.pt\"\n", + "torch.save(badGotoAgent,saveDir)" ] } ],